Uaktualnij pakiet SDK do wprowadzania danych dla Javy i Kotlin do wersji 1.1

Z tego przewodnika dowiesz się, jak zaktualizować grę z wersji 1.0.0-beta pakietu Input SDK na Java i Kotlin do wersji 1.1.1-beta. Instrukcje dotyczące Unity znajdziesz w przewodniku po uaktualnianiu Unity.

Informacje o wersji

Gry Google Play na PC umożliwiają zmianę mapowania sterowania klawiaturą na podstawie przypisów klawiszy udostępnianych przez grę za pomocą pakietu SDK do wprowadzania danych.

Aby skorzystać z tej funkcji, wystarczy otworzyć nakładkę, wybrać elementy sterujące i kliknąć działanie, które chcesz zmapować.

Gry Google Play na PC mapują wszystkie opinie użytkownika na domyślne dane wejściowe gry. Dzięki temu gra nie musi wiedzieć, że gracz zmienia mapowanie. Jeśli potrzebujesz dostępu do nowego urządzenia wejściowego dla działania w grze, na przykład do wyświetlania elementów sterujących na klawiaturze, możesz opcjonalnie zarejestrować wywołanie zwrotne, które będzie otrzymywać powiadomienia o mapowaniu zdarzeń.

Gry Google Play na PC przechowują przypisane przez użytkownika kontrolery lokalnie, dzięki czemu są one dostępne w całych sesjach gry. Ponieważ dane są przechowywane lokalnie, nie wpływają na korzystanie z aplikacji na urządzeniu mobilnym i są usuwane po odinstalowaniu Gry Google Play na PC. Ustawienia sterowania nie są zachowywane na różnych komputerach PC.

Aby włączyć w grze mapowanie klawiszy, nie musisz uaktualniać pakietu Input SDK, ale może on zostać w niej wyłączony, jeśli wykryjemy nieobsługiwaną konfigurację.

Jeśli chcesz kontrolować sposób mapowania danych wejściowych lub jeśli ta funkcja jest wyłączona w przypadku Twojej gry, wykonaj te czynności:

  • Uaktualnij pakiet SDK Input do wersji 1.1.1-beta.
  • Zaktualizuj powiązania klawiszy, aby uniknąć nieobsługiwanych konfiguracji.
  • Zaktualizuj InputMap, aby włączyć funkcję przemapowania.

Jeśli chcesz zrezygnować z funkcji ponownego mapowania w grze, ale nadal wyświetlać wersję tylko do odczytu przypisanych klawiszy, wykonaj te czynności:

  • Uaktualnij pakiet SDK do wejścia 1.1.1-beta.
  • Zaktualizuj InputMap, aby ustawić funkcję przemapowania na wyłączoną.

Możesz uaktualnić swoją wersję pakietu SDK wejścia do wersji 1.1.1-beta, aby korzystać z zaawansowanych funkcji ponownego mapowania w Grach Google Play na PC. Korzystasz z InputContexts, aby określać elementy sterujące różnych scen gry, dodawać wywołania zwrotne w celu wykrywania przemapowań zdarzeń, zdefiniować zestaw zarezerwowanych kluczy, do których użytkownik nie może ponownie zmapować, oraz dezaktywować funkcję ponownego mapowania za pomocą InputAction, InputGroup lub InputMap.

Podczas przechodzenia na nową wersję pakietu SDK należy wziąć pod uwagę te wyjątki:

Nieobsługiwane konfiguracje

Przemapowanie danych wejściowych jest wyłączone, jeśli nie są spełnione te warunki:

  • InputAction korzystający z wielu klawiszy musi składać się z klawisza modyfikującego i niemodyfikującego. Na przykład Shift + A jest prawidłowy, ale A + B, Ctrl + Alt i Shift + A + Tab nie są.

  • Co najmniej 2 obiekty InputAction lub InputGroup nie mogą mieć tego samego unikalnego identyfikatora.

Uaktualnij

Pakiet Input SDK 1.1.1-beta jest zgodny wstecz z pakietem Input SDK 1.0.0-beta. Gry korzystające z poprzednich implementacji pakietu Input SDK nadal obsługują podstawowe przemapowanie, chyba że używają nieobsługiwanej konfiguracji. Jeśli Twoja gra korzysta z wcześniejszej wersji pakietu Input SDK, przeczytaj przewodnik po uaktualnieniu z wersji 0.0.4 do 1.0.0-beta.

Uaktualnienie do wersji 1.1.1-beta umożliwia korzystanie z nowych funkcji, takich jak:

Uaktualnij zależność

Jeśli do importowania pakietu SDK Input używasz Gradle, zaktualizuj go do najnowszej wersji:

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

Definiowanie pól statycznych

W przypadku wersji 1.1.1-beta warto zdefiniować obiekty InputAction, InputGroup, InputContext i InputMap jako pola statyczne klasy InputMappingProvider, ponieważ są one dostępne z innych części aplikacji:

Kotlin

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(...)
    }
}

Java

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

Zaktualizuj wprowadzone działania

Metoda InputAction.create() pakietu Input SDK 1.0.0-beta została wycofana. Element InputAction ma teraz identyfikator wersji i można go oznaczyć jako możliwy do przeniesienia lub nie. InputAction zdefiniowany za pomocą pakietu Input SDK 1.0.0-beta create() jest domyślnie przypisany i nie zawiera informacji o wersji:

InputAction w pakiecie Input SDK w wersji 1.0.0-beta

Kotlin

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

Java

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

Wejściowe działanie w pakiecie SDK danych wejściowych w wersji 1.1.1 (beta)

Kotlin

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
}

Java

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 w pakiecie Input SDK 1.1.1-beta (z ciągiem wersji)

Kotlin

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
)

Java

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

Więcej informacji o zarządzaniu wersjami przypisań klawiszy znajdziesz w artykule Śledzenie identyfikatorów kluczy.

Aktualizowanie grup wejściowych

W pakiecie SDK danych wejściowych 1.1.1-beta musisz jednoznacznie zidentyfikować każde InputGroup. Każdy element InputAction należy do elementu InputGroup, czyli zbioru powiązanych działań. Ułatwia to nawigację i odkrywanie elementów sterujących podczas rozgrywki. Podobnie jak InputAction musi mieć wyjątkowy identyfikator wśród wszystkich działań w ramach pojedynczego InputContext, tak InputGroup musi mieć unikalny identyfikator wśród istniejących grup.

W przykładach w tej sekcji gra ma 2 obiekty InputContext reprezentujące menu główne i mechanikę rozgrywki. Odpowiednie identyfikatory są śledzone dla każdego elementu InputGroup w tych kontekstach za pomocą takiego wyliczenia:

Kotlin

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
}

Java

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
}

Podobnie jak w przypadku metody InputAction, metoda InputGroup.create() w pakiecie Input SDK1.0.0-beta została wycofana. Musisz zaktualizować InputGroup w grze, podając identyfikator wersji i wartość logiczną wskazującą, czy obiekty InputAction w grupach można ponownie przypisać. Grupy utworzone za pomocą wycofanej metody pakietu Input SDK 1.0.0-beta create() można ponownie zmapować. Mają one identyfikator 0, a identyfikator wersji to pusty ciąg znaków (""):

InputGroup w Input SDK 1.0.0-beta

Kotlin

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

Java

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

Wejściowa grupa w pakiecie SDK do wprowadzania danych w wersji 1.1.1 beta

Kotlin

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

Java

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 w pakiecie Input SDK 1.1.1-beta (z ciągiem znaków wersji)

Kotlin

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

Java

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

Więcej informacji o zarządzaniu wersjami przypisań klawiszy znajdziesz w artykule Śledzenie identyfikatorów kluczy.

Aktualizowanie mapy danych wejściowych

Metoda InputMap.create() pakietu Input SDK 1.0.0-beta została wycofana. Zaktualizuj plik InputMap, aby przypisać identyfikator wersji, całkowicie zrezygnować z funkcji przemapowania lub przypisać do gry listę zablokowanych kluczy, których użytkownik nie może używać do przemapowania. Każda zmienna InputMapzdefiniowana za pomocą metody pakietu Input SDK 1.0.0-beta create() jest domyślnie możliwa do zamapowania, jest identyfikowana za pomocą identyfikatora 0 i nie ma żadnych zablokowanych kluczy.

InputMap w Input SDK 1.0.0-beta

Kotlin

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

Java

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

InputMap w Input SDK 1.1.1-beta

Kotlin

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()))
  )
}

Java


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

Co dalej

Kontynuuj aktualizację do wersji 1.1.1-beta, przypisując różne elementy sterujące do różnych scen za pomocą InputContexts lub aktualizując interfejs gry za pomocą InputRemappingListeners, aby otrzymywać powiadomienia o przemapowaniu zdarzeń.

Podczas aktualizowania powiązań kluczy zapoznaj się ze sprawdzonymi metodami projektowania powiązań kluczy i weź pod uwagę ograniczenia oraz ograniczenia funkcji ponownego mapowania.