Esegui l'upgrade dell'SDK di input per Java e Kotlin alla versione 1.1

Questa guida spiega come eseguire l'upgrade del tuo gioco dalla versione 1.0.0-beta SDK di input per Java e Kotlin alla versione 1.1.0-beta. Consulta le Guida all'upgrade di Unity per Unity istruzioni specifiche.

Note sulla versione

Google Play Giochi su PC supporta la rimappatura dei controlli da tastiera in base sulle associazioni di tasti fornite dal tuo gioco usando l'SDK di input.

Per accedere a questa funzionalità, gli utenti devono l'overlay, selezionando i controlli, e facendo clic sull'azione che vogliono rimappare.

Google Play Giochi su PC mappa ogni input rimappato dall'utente sul valore predefinito del tuo gioco di testo. In questo modo, il gioco non deve essere a conoscenza della rimappatura del giocatore. Se devi conoscere il nuovo input per un'azione in-game, ad esempio mostrare controlli da tastiera nel gioco, puoi facoltativamente registrare un callback per gli eventi di rimappatura.

Google Play Giochi su PC memorizza localmente i controlli rimappati di ogni utente, in modo che sono persistenti tra le sessioni di gioco. Poiché è archiviata in locale, influenzano l'esperienza mobile e vengono eliminati al momento della disinstallazione di Google Play Giochi su PC. Le impostazioni di controllo non sono rese persistenti in più PC.

Non è necessario eseguire l'upgrade dell'SDK di input per attivare la rimappatura dei tasti in il gioco, ma la rimappatura può essere disattivata per il gioco se rilevata la configurazione non supportata.

Se vuoi controllare l'esperienza di rimappatura dell'input o se la rimappatura non è attiva per il tuo gioco, svolgi i passaggi che seguono per risolvere il problema:

• Esegui l'upgrade all'SDK di input 1.1.0-beta.
• Aggiorna eventuali associazioni di tasti per evitare configurazioni non supportate.
• Aggiorna il tuo InputMap per impostare la funzionalità di rimappatura attivata.

Se vuoi disattivare la funzionalità di rimappatura per il tuo gioco mentre ti trovi ancora per visualizzare la versione di sola lettura delle associazioni di chiavi, segui questi passaggi:

• Esegui l'upgrade all'SDK di input 1.1.0-beta.
• Aggiorna il tuo InputMap per impostare la funzionalità di rimappatura su disattivata.

Puoi eseguire l'upgrade della tua versione dell'SDK di input a 1.1.0-beta per utilizzare sfruttare le funzionalità di rimappatura avanzate di Google Play Giochi su PC utilizzando InputContexts per definire i controlli per diverse scene del gioco, aggiungi per ascoltare gli eventi di rimappatura, definisci un insieme di chiavi riservate l'utente non può rimappare e disattivare la funzionalità di rimappatura per InputAction, InputGroup o InputMap.

Tieni presente le seguenti eccezioni durante l'upgrade alla nuova versione dell'SDK:

Configurazioni non supportate

La rimappatura dell'input è disattivata se le seguenti condizioni non sono soddisfatte:

• Un InputAction che utilizza più tasti deve essere composto da un modificatore e una chiave non modificatrice. Ad esempio, Maiusc + A è valido ma A + B, Ctrl + Alt e Maiusc + A + Tab non lo sono.

• Due o più oggetti InputAction o InputGroup non possono condividere lo stesso univoco.

Esegui l'upgrade

L'SDK di input 1.1.0-beta è compatibile con le versioni precedenti di Input SDK 1.0.0-beta. Giochi che utilizzano implementazioni precedenti dell'SDK di input supportano comunque la rimappatura di base, a meno che non utilizzino una configurazione non supportata. Se il gioco utilizza un precedente dell'SDK di input, valuta la possibilità di leggere guida all'upgrade dalla versione 0.0.4 alla versione 1.0.0-beta.

L'upgrade alla versione 1.1.0-beta abilita nuove funzionalità, tra cui:

• Attivazione delle modifiche ai controlli della scena.
• Ricezione di notifiche di eventi di mappatura delle chiavi.
• Disattivazione della rimappatura per azione, gruppo, contesto o mappa.

Esegui l'upgrade delle dipendenze

Se utilizzi Gradle per importare l'SDK di input, esegui l'upgrade alla versione più recente:

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

Definisci campi statici

Per la versione 1.1.0-beta è buona norma definire il valore InputAction, InputGroup, InputContext e InputMap come campi statici di InputMappingProvider poiché questi campi sono accessibili da altre parti della tua applicazione:

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;
    }
}

Aggiorna le tue azioni di input

Il metodo InputAction.create() dell'SDK di input 1.0.0-beta è ritirato. Un InputAction ora ha un identificatore di versione e può essere contrassegnato come rimappabili o meno. Un elemento InputAction definito utilizzando l'SDK di input Il metodo 1.0.0-beta create() è rimappabile per impostazione predefinita e non dispone del controllo delle versioni informazioni:

InputAction nell'SDK di input 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 nell'SDK di input 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 nell'SDK di input 1.1.0-beta (con stringa di versione)

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
);

Per ulteriori informazioni sul controllo delle versioni delle associazioni di chiavi, consulta ID chiave di monitoraggio.

Aggiorna i tuoi gruppi di input

Nell'SDK di input 1.1.0-beta devi identificare in modo univoco ogni InputGroup. Ogni InputAction appartiene a un InputGroup, una raccolta di azioni correlate. Ciò migliora la navigazione e la rilevabilità dei controlli durante il gameplay. Allo stesso modo in cui InputAction deve avere un identificatore univoco tra tutte le azioni in un singolo InputContext, un InputGroup deve avere un l'ID univoco nei gruppi esistenti.

Per gli esempi in questa sezione, un gioco ha due oggetti InputContext che rappresentano il menu principale e il gameplay. Vengono monitorati gli ID appropriati per ogni InputGroup in questi contesti utilizzando la seguente enumerazione:

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
}

Come InputAction, il metodo InputGroup.create() dell'SDK di input 1.0.0-beta è stato deprecato. Devi aggiornare InputGroup nel gioco con un identificatore di versione e un valore booleano che indica se il valore InputAction gli oggetti nei tuoi gruppi sono rimappabili. I gruppi creati con il metodo create() deprecato dell'SDK di input 1.0.0-beta sono rimappabili e hanno l'ID 0. e l'ID versione è una stringa vuota (""):

InputGroup nell'SDK di input 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 nell'SDK di input 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 nell'SDK di input 1.1.0-beta (con stringa di versione)

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
);

Per ulteriori informazioni sul controllo delle versioni delle associazioni di chiavi, consulta ID chiave di monitoraggio.

Aggiorna la tua InputMap

Il metodo InputMap.create() dell'SDK di input 1.0.0-beta è ritirato. Aggiorna InputMap per assegnare un identificatore di versione, disattiva completamente dalla funzionalità di rimappatura o assegnare un elenco di tasti riservati al tuo che l'utente non utilizzi per la rimappatura. Ogni InputMap definita utilizzando il metodo create() dell'SDK di input 1.0.0-beta è rimappabile per impostazione predefinita, è identificato con l'ID 0 e non ha e riservate.

InputMap nell'SDK di input 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 nell'SDK di input 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()
                )
        )
);

Passaggio successivo

Continua l'upgrade alla versione 1.1.0-beta entro il giorno Assegnare controlli diversi per scene diverse usando InputContexts o aggiornando l'UI del gioco Ricevere notifiche sugli eventi di rimappatura mediante InputRemappingListeners,

Quando aggiorni le associazioni di chiavi, dai un'occhiata Best practice per la progettazione delle associazioni di chiavi e considera le limitazioni e limitazioni della funzionalità di rimappatura.