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

Z tego przewodnika dowiesz się, jak zaktualizować grę z pakietu Input SDK w wersji 1.0.0-beta na Java i Kotlin na wersję 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 Input SDK.

Użytkownicy uzyskują dostęp do tej funkcji, otwierając nakładkę, wybierając elementy sterujące, a następnie klikając działanie, które chcą przemapować.

Gry Google Play na PC mapują każde przypisane przez użytkownika wejście na domyślne wejście gry. Dzięki temu gra nie musi wiedzieć, że gracz zmienia mapowanie. Jeśli chcesz poznać nowy sposób wprowadzania danych w grze, np. wyświetlania elementów sterujących w grze, możesz opcjonalnie zarejestrować funkcję wywołania zwrotnego, aby otrzymywać powiadomienia o przemapowaniu zdarzeń.

Gry Google Play na PC przechowują przypisane przez użytkownika kontrolery lokalnie, aby były 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 wielu urządzeniach 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 do wersji 1.1.1-beta.
  • Zaktualizuj dowolne kombinacje 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 wersji 1.1.1-beta.
  • Zaktualizuj InputMap, aby ustawić funkcję przemapowania na wyłączoną.

Aby korzystać z zaawansowanych funkcji przemapowania w Google Play Games na PC, możesz uaktualnić pakiet SDK do wprowadzania danych do wersji 1.1.1-beta. Aby to zrobić, użyj funkcji InputContexts do definiowania elementów sterujących w różnych scenach gry, dodaj funkcje wywołania zwrotnego, aby odbierać zdarzenia przemapowania, zdefiniuj zestaw rezerwowanych klawiszy, których użytkownik nie może przemapować, i dezaktywuj funkcję przemapowania za pomocą funkcji InputAction, InputGroup lub InputMap.

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

Konfiguracje nieobsługiwane

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

  • InputAction wykorzystujący wiele 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ą prawidłowe.

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

Aktualizowanie działań związanych z wprowadzaniem danych

Metoda InputAction.create() pakietu Input SDK 1.0.0-beta została wycofana. Obiekt InputAction ma teraz identyfikator wersji i może być oznaczony jako możliwy do zamapowania 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()
    )
);

InputAction w Input SDK 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 identyfikować poszczególne InputGroup. Każdy element InputAction należy do elementu InputGroup, czyli zbioru powiązanych działań. Dzięki temu poprawia się nawigacja i widoczność elementów sterujących podczas rozgrywki. Podobnie jak InputAction musi mieć unikalny 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. W tych kontekstach dla każdego InputGroup są śledzone odpowiednie identyfikatory za pomocą tej listy:

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

InputGroup w Input SDK 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ę zastrzeżonych 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 przypisania klawiszy zapoznaj się ze sprawdzonymi metodami projektowania przypisania klawiszy i weź pod uwagę ograniczenia oraz ograniczenia funkcji przemapowania.