Input System a fondo: Action Maps y rebinding

Del "leer teclas" a las acciones#

En Input básico leíste teclas directamente. El verdadero potencial del Input System está en separar qué hace el jugador ("Saltar", "Mover") de con qué lo hace (espacio, botón A, gatillo). Eso permite soportar teclado, mando y táctil a la vez, y que el jugador remapee los controles.

Input Actions Asset#

Crea un asset: Assets → Create → Input Actions. Ábrelo (doble clic) y define:

• Action Maps: grupos de acciones por contexto ("Player", "UI", "Vehicle").
• Actions: las acciones abstractas ("Move", "Jump", "Fire") y su tipo (Value, Button, Pass-Through).
• Bindings: a qué teclas/botones/ejes se mapea cada acción (puedes poner varios por acción y por dispositivo).

Leer una acción por código#

Con el asset generado, te suscribes a los eventos de cada acción:

using UnityEngine;
using UnityEngine.InputSystem;

public class Jugador : MonoBehaviour
{
    private Controles controles;   // la clase generada del asset
    private Vector2 mov;

    void Awake() => controles = new Controles();

    void OnEnable()
    {
        controles.Player.Enable();
        controles.Player.Jump.performed += AlSaltar;   // botón pulsado
    }

    void OnDisable()
    {
        controles.Player.Jump.performed -= AlSaltar;
        controles.Player.Disable();
    }

    void Update()
    {
        // Leer un valor continuo (Vector2 de un stick o WASD)
        mov = controles.Player.Move.ReadValue<Vector2>();
    }

    void AlSaltar(InputAction.CallbackContext ctx) => Debug.Log("¡Salto!");
}

PlayerInput: la vía cómoda#

El componente PlayerInput conecta el asset a tu objeto y llama a métodos por ti, sin gestionar suscripciones. Con el modo Send Messages o Invoke Unity Events, cada acción llama a un método OnMove, OnJump, etc.:

using UnityEngine;
using UnityEngine.InputSystem;

public class MovimientoPlayerInput : MonoBehaviour
{
    private Vector2 mov;

    // PlayerInput llama a esto automáticamente para la acción "Move"
    public void OnMove(InputAction.CallbackContext ctx) => mov = ctx.ReadValue<Vector2>();
    public void OnJump(InputAction.CallbackContext ctx) { if (ctx.performed) Saltar(); }

    void Saltar() { /* ... */ }
}

Es lo más rápido para empezar, y la base del multijugador local (varios PlayerInput, uno por jugador y dispositivo).

Soportar teclado y mando a la vez#

El Input System detecta el dispositivo automáticamente. Añadiendo bindings de teclado y de gamepad a la misma acción "Jump", funciona con ambos sin código extra. Los Control Schemes agrupan bindings por dispositivo para gestionar qué esquema usa cada jugador.

Remapear controles (rebinding)#

Dejar que el jugador cambie sus teclas es casi gratis con el Input System:

using UnityEngine.InputSystem;

void RemapearSalto(InputAction accion)
{
    accion.Disable();   // hay que desactivar la acción durante el rebind
    accion.PerformInteractiveRebinding()
        .OnComplete(op =>
        {
            op.Dispose();
            accion.Enable();
            Debug.Log("Nuevo control: " + accion.bindings[0].effectivePath);
        })
        .Start();   // espera a que el jugador pulse una tecla
}

Guarda los cambios con accion.SaveBindingOverridesAsJson() y cárgalos con LoadBindingOverridesFromJson() (persístelo con PlayerPrefs o JSON).

Táctil y móvil#

El Input System soporta Touchscreen y controles en pantalla (On-Screen Button/Stick), que emulan un mando virtual mapeado a tus acciones. Así el mismo código de "Move"/"Jump" vale para PC, mando y móvil.

Errores frecuentes#

• Olvidar habilitar la acción/mapa (.Enable()): no llega ningún input.
• No desuscribirse de los callbacks en OnDisable (fugas).
• Usar nombres de acción como strings sueltos en vez de la clase generada.
• Intentar remapear sin desactivar la acción primero.
• Dejar Active Input Handling solo en el sistema viejo y que el nuevo no funcione (ponlo en Both o Input System).

Ponte a prueba#

Resumen#

El Input System brilla con los Input Actions: defines acciones abstractas ("Move", "Jump") en un asset, las mapeas a teclado/mando/táctil, y lees por eventos (performed) o con PlayerInput. Genera la clase C# para evitar strings, soporta varios dispositivos a la vez y permite rebinding con PerformInteractiveRebinding (guardando los overrides). Es la base del multijugador local y del soporte multiplataforma. Amplía lo visto en Input básico.