Cómo actualizar el SDK de entrada para Java y Kotlin a la versión 1.1

En esta guía, se explica cómo actualizar tu juego de la versión 1.0.0-beta del SDK de entrada para Java y Kotlin a la versión 1.1.0-beta. Consulta la guía de actualización de Unity si necesitas instrucciones específicas.

Notas de la versión

Google Play Juegos para PC admite la reasignación de los controles del teclado según las combinaciones de teclas que proporciona tu juego con el SDK de entrada.

Para acceder a esta función, los usuarios deben abrir la superposición, seleccionar los controles y hacer clic en la acción que desean reasignar.

Google Play Juegos para PC asigna todas las entradas que volvió a asignar el usuario a la entrada predeterminada del juego. De esta manera, el juego no tiene que estar al tanto de la reasignación del jugador. Si necesitas conocer la nueva entrada para una acción en el juego, como mostrar los controles del teclado, puedes registrar una devolución de llamada para que se te notifique cuando se vuelvan a asignar los eventos.

Google Play Juegos para PC almacena los controles reasignados de cada usuario de forma local para que sean persistentes en todas las sesiones. Como se almacena de forma local, no influye en la experiencia en dispositivos móviles y se borra cuando se desinstala Google Play Juegos para PC. Los parámetros de configuración de control no persisten en varios dispositivos de PC.

No es necesario que actualices el SDK de entrada para habilitar la reasignación de teclas en el juego, pero sí puedes inhabilitar la reasignación si se detecta una configuración no admitida.

Si deseas controlar la experiencia de reasignación de entrada o si la función está inhabilitada para tu juego, sigue estos pasos:

• Actualiza al SDK de entrada 1.1.0-beta.
• Actualiza las vinculaciones de teclas para evitar las configuraciones no admitidas.
• Actualiza tu InputMap para establecer la función de reasignación en habilitada.

Si deseas inhabilitar la función de reasignación de tu juego y mostrar la versión de solo lectura de las vinculaciones de teclas, sigue estos pasos:

• Actualiza al SDK de entrada 1.1.0-beta.
• Actualiza tu InputMap para establecer la función de reasignación en inhabilitada.

Puedes actualizar tu versión del SDK de entrada a 1.1.0-beta para aprovechar las funciones avanzadas de reasignación en Google Play Juegos para PC con InputContexts para definir controles destinados a diferentes escenas del juego, agregar devoluciones de llamada para escuchar eventos de reasignación, definir un conjunto de teclas reservadas a las que el usuario no puede volver a asignar, además de desactivar la función de reasignación según InputAction, InputGroup o InputMap.

Ten en cuenta las siguientes excepciones cuando actualices a la nueva versión del SDK:

Parámetros de configuración no compatibles

La reasignación de entrada se inhabilita si no se cumplen las siguientes condiciones:

• Una InputAction que usa varias teclas debe constar de una teclas modificadora y no modificadora. Por ejemplo, Mayúsculas + A es válida, pero A + B, Ctrl + Alt y Mayúsculas + A + Tab no lo son.

• Dos o más objetos InputAction o InputGroup no pueden compartir el mismo ID único.

Actualización

El SDK de entrada 1.1.0-beta es retrocompatible con el SDK de entrada 1.0.0-beta. Los juegos que usan implementaciones anteriores del SDK de entrada aún admiten la reasignación básica, a menos que usen una configuración no admitida. Si tu juego usa una versión anterior del SDK de entrada, te recomendamos leer la guía de actualización de 0.0.4 a 1.0.0-beta.

La actualización a la versión 1.1.0-beta habilita nuevas funciones, incluidas las siguientes:

• Activar los cambios de control de escena
• Recibir notificaciones de eventos de asignación de teclas
• Inhabilitar la reasignación por acción, grupo, contexto o mapa

Cómo actualizar la dependencia

Si usas Gradle para importar el SDK de entrada, actualiza a la versión más reciente:

// build.gradle
dependencies {
   ...
   implementation 'com.google.android.libraries.play.games:inputmapping:1.1.0-beta'
   ...
}

Cómo definir campos estáticos

Para la versión 1.1.0-beta, se recomienda definir los objetos InputAction, InputGroup, InputContext y InputMap como campos estáticos de tu clase InputMappingProvider, ya que se puede acceder a estos campos desde otras partes de la aplicación:

class InputSDKProvider : InputMappingProvider {
    override fun onProvideInputMap(): InputMap { return gameInputMap }

    companion object {
        const val INPUTMAP_VERSION = "1.0.0"

        private val moveUpInputAction = InputAction.create(...)
        private val movementInputGroup = InputGroup.create(...)
        val menuContext = InputContext.create(...)
        val gameInputMap = InputMap.create(...)
    }
}

public class MyInputMappingProvider implements InputMappingProvider {
    private static final String INPUTMAP_VERSION = "1.0.0";

    private static final InputAction moveUpInputAction =
        InputAction.create(...);
    private static final InputGroup movementInputGroup = InputGroup.create(...);
    public static final InputContext menuContext = InputContext.create(...);
    public static final InputMap gameInputMap = InputMap.create(...);

    @Override
    public InputMap onProvideInputMap() {
        return gameInputMap;
    }
}

Cómo actualizar tus InputActions

El método InputAction.create() del SDK de entrada 1.0.0-beta dejó de estar disponible. Una InputAction ahora tiene un identificador de versión y se puede marcar como reasignable o no. Una InputAction definida con el método create() de 1.0.0-beta del SDK de entrada se puede reasignar de forma predeterminada y carece de información sobre el control de versiones:

InputAction en el SDK de entrada 1.0.0-beta

val jumpInputAction = InputAction.create(
    "Jump",
    InputEventIds.JUMP.id,
    InputControls.create(
        listOf(KeyEvent.KEYCODE_SPACE),
        emptyList()
    )
)

InputAction moveUpInputAction = InputAction.create(
    "Move Up",
    InputEventIds.MOVE_UP.ordinal(),
    InputControls.create(
        Collections.singletonList(KeyEvent.KEYCODE_W),
        Collections.emptyList()
    )
);

InputAction en el SDK de entrada 1.1.0-beta

companion object {
  private val moveUpInputAction = InputAction.create(
    "Move Up",
    InputActionsIds.DRIVE.ordinal.toLong(),
    InputControls.create(listOf(KeyEvent.KEYCODE_W), emptyList()),
    InputEnums.REMAP_OPTION_ENABLED) // This action is remappable
}

private static final InputAction moveUpInputAction = InputAction.create(
    "Move Up",
    InputEventIds.MOVE_UP.ordinal(),
    InputControls.create(
            Collections.singletonList(KeyEvent.KEYCODE_W),
            Collections.emptyList()),
    InputEnums.REMAP_OPTION_ENABLED // this action is remappable
);

InputAction en el SDK de entrada 1.1.0-beta (con string de versión)

private val enterMenuInputAction = InputAction.create(
    "Enter menu",
    InputControls.create(listOf(KeyEvent.KEYCODE_ENTER), emptyList()),
    InputIdentifier.create(
    INPUTMAP_VERSION, InputActionsIds.ENTER_MENU.ordinal.toLong()),
    InputEnums.REMAP_OPTION_ENABLED
)

private static final InputAction moveUpInputAction = InputAction.create(
    "Move Up",
    InputControls.create(
            Collections.singletonList(KeyEvent.KEYCODE_W),
            Collections.emptyList()),
    InputIdentifier.create(
            INPUTMAP_VERSION,
            InputEventIds.MOVE_UP.ordinal()),
    InputEnums.REMAP_OPTION_ENABLED // this action is remappable
);

Para obtener más información sobre el control de versiones de tus vinculaciones de teclas, consulta Cómo realizar un seguimiento de los ID de teclas.

Cómo actualizar tus InputInputs

En el SDK de entrada 1.1.0-beta, debes identificar cada InputGroup de forma única. Cada InputAction pertenece a InputGroup, una colección de acciones relacionadas. Esto mejora la navegación y la visibilidad de los controles durante el juego. De la misma manera que InputAction debe tener un identificador único entre todas las acciones de un solo InputContext, un InputGroup debe tener un ID único en todo los grupos existentes.

Para los ejemplos de esta sección, un juego tiene dos objetos InputContext que representan el menú principal y el juego. Se realiza un seguimiento de los IDs adecuados para cada InputGroup en estos contextos con la siguiente enumeración:

enum class InputGroupsIds {
    // Main menu scene
    BASIC_NAVIGATION, // WASD, Enter, Backspace
    MENU_ACTIONS, // C: chat, Space: quick game, S: store
    // Gameplay scene
    BASIC_MOVEMENT, // WASD, space: jump, Shift: run
    MOUSE_ACTIONS, // Left click: shoot, Right click: aim
    EMOJIS, // Emojis with keys 1,2,3,4 and 5
    GAME_ACTIONS, // M: map, P: pause, R: reload
}

public enum InputGroupsIds {
    // Main menu scene
    BASIC_NAVIGATION, // WASD, Enter, Backspace
    MENU_ACTIONS, // C: chat, Space: quick game, S: store
    // Gameplay scene
    BASIC_MOVEMENT, // WASD, space: jump, Shift: run
    MOUSE_ACTIONS, // Left click: shoot, Right click: aim
    EMOJIS, // Emojis with keys 1,2,3,4 and 5
    GAME_ACTIONS, // M: map, P: pause, R: reload
}

Al igual que InputAction, el método InputGroup.create() del SDK de entrada 1.0.0-beta dejó de estar disponible. Debes actualizar el objeto InputGroup de tu juego con un identificador de versión y un valor booleano que indique si los objetos InputAction de tus grupos son reasignables. Los grupos creados con el método create() del SDK de entrada 1.0.0-beta que dejó de estar disponible son reasignables, tienen el ID 0 y el ID de versión es una string vacía (""):

InputGroup en el SDK de entrada 1.0.0-beta

val movementInputGroup = InputGroup.create(
    "Basic Movement",
    listOf(
        moveUpInputAction,
        moveLeftInputAction,
        moveDownInputAction,
        moveRightInputAction,
        jumpInputAction,
        runInputAction)
)

InputGroup movementInputGroup = InputGroup.create(
    "Basic movement",
    Arrays.asList(
        moveUpInputAction,
        moveLeftInputAction,
        moveDownInputAction,
        moveRightInputAction,
        jumpInputAction,
        runInputAction
    )
);

InputGroup en el SDK de entrada 1.1.0-beta

companion object {
    private val movementInputGroup = InputGroup.create(
        "Basic movement",
        listOf(
            moveUpInputAction,
            moveLeftInputAction,
            moveDownInputAction,
            moveRightInputAction,
            jumpInputAction,
            runInputAction),
        InputGroupsIds.BASIC_MOVEMENT.ordinal.toLong(),
        // All the actions in this groups can't be remapped
        InputEnums.REMAP_OPTION_DISABLED
    )
}

private static final InputGroup movementInputGroup = InputGroup.create(
    "Basic movement",
    Arrays.asList(
            moveUpInputAction,
            moveLeftInputAction,
            moveDownInputAction,
            moveRightInputAction,
            jumpInputAction,
            runInputAction
    ),
    InputGroupsIds.BASIC_MOVEMENT.ordinal(),
    // All the actions in this groups can't be remapped
    InputEnums.REMAP_OPTION_DISABLED
);

InputGroup en el SDK de entrada 1.1.0-beta (con string de versión)

companion object {
    private val movementInputGroup  = InputGroup.create(
        "Basic movement",
        listOf(
            moveUpInputAction,
            moveLeftInputAction,
            moveDownInputAction,
            moveRightInputAction,
            jumpInputAction,
            runInputAction),
        InputIdentifier.create(
            INPUTMAP_VERSION, InputGroupsIds.BASIC_MOVEMENT.ordinal.toLong()),
        // All the actions in this groups can't be remapped
        InputEnums.REMAP_OPTION_DISABLED
    )
}

private static final InputGroup movementInputGroup = InputGroup.create(
    "Basic movement",
    Arrays.asList(
            moveUpInputAction,
            moveLeftInputAction,
            moveDownInputAction,
            moveRightInputAction,
            jumpInputAction,
            runInputAction
    ),
    InputIdentifier.create(
            INPUTMAP_VERSION,
            InputGroupsIds.BASIC_MOVEMENT.ordinal()),
    // All the actions in this groups can't be remapped
    InputEnums.REMAP_OPTION_DISABLED
);

Para obtener más información sobre el control de versiones de tus vinculaciones de teclas, consulta Cómo realizar un seguimiento de los ID de teclas.

Cómo actualizar tu InputMap

El método InputMap.create() del SDK de entrada 1.0.0-beta dejó de estar disponible. Actualiza tu InputMap para asignar un identificador de versión, inhabilitar por completo la función de reasignación o asignar una lista de teclas reservadas para tu juego que no deseas que el usuario vuelva a asignar. Cada InputMap definido con el método create() del SDK de entrada 1.0.0-beta se puede volver a asignar de forma predeterminada, se identifica con el ID 0 y no tiene ninguna tecla reservada.

InputMap en el SDK de entrada 1.0.0-beta

val gameInputMap = InputMap.create(
    listOf(movementInputGroup, mouseMovementInputGroup),
    MouseSettings.create(true, false)
)

InputMap gameInputMap = InputMap.create(
    Arrays.asList(movementInputGroup, mouseMovementInputGroup),
    MouseSettings.create(true, false)
);

InputMap en el SDK de entrada 1.1.0-beta

companion object {

  const val INPUTMAP_VERSION = "1.0.0"
  const val INPUT_MAP_ID = 0

  val gameInputMap = InputMap.create(
    listOf(movementInputGroup, mouseMovementInputGroup),
    MouseSettings.create(true, false),
    InputIdentifier.create(INPUTMAP_VERSION, INPUT_MAP_ID.toLong()),
    InputEnums.REMAP_OPTION_ENABLED,
    // Use ESCAPE as reserved key
    listof(InputControls.create(listOf(KeyEvent.KEYCODE_ESCAPE), emptyList()))
  )
}

public static final String INPUT_MAP_VERSION = "1.0.0-beta";
public static final long INPUT_MAP_ID = 0;

public static final InputMap gameInputMap = InputMap.create(
        Arrays.asList(movementInputGroup, mouseMovementInputGroup),
        MouseSettings.create(true, false),
        InputIdentifier.create(INPUTMAP_VERSION, INPUT_MAP_ID),
        InputEnums.REMAP_OPTION_ENABLED,
        // Use ESC key as reserved key
        Arrays.asList(
                InputControls.create(
                        Collections.singletonList(KeyEvent.KEYCODE_ESCAPE),
                        Collections.emptyList()
                )
        )
);

Próximos pasos

Continúa con la actualización a la versión 1.1.0-beta. Para ello, asigna distintos controles para diferentes escenas mediante InputContexts o actualiza la IU del juego para recibir notificaciones sobre los eventos de asignación con InputRemappingListeners.

Cuando actualices tus vinculaciones de teclas, consulta las prácticas recomendadas para diseñar vinculaciones de teclas y ten en cuenta las restricciones y limitaciones de la función de reasignación.