Giriş SDK'sını kullanmaya başlama

Bu dokümanda, Giriş SDK'sının nasıl ayarlanacağı ve gösterileceği açıklanmaktadır. PC Üzerinde Google Play Games'i destekleyen oyunlar. Görevler, ve bu bilgileri içeren bir giriş haritası oluşturarak kullanıcı girişi atamaları arasındaki oyunla ilgili bir sorun yoktur.

Başlamadan önce

Oyununuza Giriş SDK'sı eklemeden önce şunları desteklemeniz gerekir: klavye ve fare girişi kullanarak oyun motorunuzun giriş sistemi.

Giriş SDK'sı, PC Üzerinde Google Play Games'e şu konularla ilgili bilgi sağlar: kullanıcı tarafından görülebilecek şekilde oyununuzda neyin kullanıldığını kontrol eder. Ayrıca isteğe bağlı olarak kullanıcılar için klavyeyi yeniden eşlemeye izin verebilirsiniz.

Her kontrol bir InputAction’dir (ör. "Atlama" için "J"). InputGroups içine InputActions. InputGroup, farklı bir temsili modu (örneğin, "Araba kullanma" gibi) veya "Yürüyüş" veya "Ana Menü"yü seçin. Ayrıca transkriptinizi Farklı noktalarında etkin olan grupları belirtmek için InputContexts kullanın sorumluluklar var.

Klavye yeniden eşlemeyi sizin için otomatik olarak işlenmek üzere etkinleştirebilirsiniz, ancak kendi kontrol yeniden eşleme arayüzünüzü sağlamayı tercih ederseniz, SDK yeniden eşlemeyi girin.

Aşağıdaki sıra şemasında, Giriş SDK'sı API'sinin nasıl çalıştığı açıklanmaktadır:

Oyununuz Giriş SDK'sını uyguladığında kontrolleriniz gösterilir Google Play Games on PC yer paylaşımı.

PC Üzerinde Google Play Games yer paylaşımı

PC Üzerinde Google Play Games yer paylaşımı ("yer paylaşımı"), kontrolleri gösterir iyi bir örnektir. Kullanıcılar, yer paylaşımına istedikleri zaman Üst Karakter + Sekme tuşlarına basın.

Anahtar bağlamaları tasarlamak için en iyi uygulamalar

Anahtar bağlamalarınızı tasarlarken aşağıdaki en iyi uygulamaları göz önünde bulundurun:

• İyileştirmek için InputActions öğenizi mantıksal olarak alakalı InputGroups altında gruplandırın oyun sırasında gezinme ve kontrollerin keşfedilebilirliği.
• Her InputGroup için en fazla bir InputContext atayın. İnce taneli InputMap, kontrollerinizde gezinme için daha iyi bir deneyim sunar. yer paylaşımlı olarak kullanabilirsiniz.
• Oyununuzun her farklı sahne türü için bir InputContext oluşturun. Genellikle, tüm "menü benzeri" öğeleriniz için tek bir InputContext kullanabilirsiniz sahneler. Oyununuzdaki mini oyunlar veya diğer oyunlar için farklı InputContexts kullanın kontrol edebilirsiniz.
• Aynı anahtar altında aynı anahtar kullanılacak şekilde tasarlanmış iki işlem InputContext için "Etkileşim / Ateş" gibi bir etiket dizesi kullanın.
• İki anahtar aynı InputAction öğesine bağlanacak şekilde tasarlanmışsa 2 anahtar kullanın oyununuzda aynı işlemi gerçekleştiren farklı InputActions. her iki InputActions için de aynı etiket dizesini kullanır ancak kimliği olmalıdır yardımcı olur.
• Bir değiştirici tuş grubuna uygulandığında tek bir değiştirici tuş olması Birden çok InputActions yerine değiştirici tuşla InputAction değiştirici tuşu birleştirin (örneğin: Üst Karakter ve W, A, S, D tuşunu kullanın) Üst Karakter + W, Üst Karakter + A, Üst Karakter + S, Üst Karakter + D).
• Kullanıcı metne yazarken giriş yeniden eşleme otomatik olarak devre dışı bırakılır alanları. Android metin alanlarının kullanımına ilişkin en iyi uygulamaları takip edin. Böylece Android, oyununuzdaki metin alanlarını algılayabilir ve yeniden eşlenen tuşları engelleyebilir bir engeli olabilir. Oyununuzda geleneksel olmayan metinler kullanılması gerekiyorsa setInputContext() alanını, değeri içeren bir InputContext ile kullanabilirsiniz. boş InputGroups listesi oluşturarak yeniden eşlemeyi manuel olarak devre dışı bırakın.
• Oyununuz yeniden eşlemeyi destekliyorsa anahtar bağlamalarınızı güncelleyerek kullanıcıların kaydettiği sürümlerle çakışabilecek hassas bir işlemdir. Kullanılmasın Mümkün olduğunda mevcut kontrollerin kimliklerinin değiştirilmesi.

Yeniden eşleme özelliği

PC Üzerinde Google Play Games, tuşa göre klavye kontrolünü yeniden eşlemeyi destekler Giriş SDK'sını kullanarak oyununuzun sağladığı bağlamaları keşfedin. Bu, isteğe bağlıdır ve devre dışı bırakılabilir. Örneğin, kendi klavyenizi sunmak isteyebilirsiniz. yeniden eşleme arayüzü. Oyununuzda yeniden eşlemeyi devre dışı bırakmak için aşağıdakileri belirtmeniz yeterlidir yeniden eşleme seçeneği InputMap için devre dışı bırakıldı (bkz. Daha fazla bilgi için Giriş Haritası oluşturun).

Bu özelliğe erişmek için kullanıcıların yer paylaşımını açıp işlemi tıklaması gerekir yeniden eşlemek istiyorlar. Her yeniden eşleme etkinliğinden sonra PC Üzerinde Google Play Games haritaları kullanıcı tarafından yeniden eşlenen her kontrol, oyununuzun beklediği varsayılan kontrollere Bu nedenle, oyununuzun oyuncunun yeniden eşlediğinin farkında olmasına gerek yoktur. Siz isteğe bağlı olarak klavye kontrollerini görüntülemek için kullanılan öğeleri etkinlikleri yeniden eşlemek için bir geri çağırma ekleyerek oyununuza teşekkür edebilirsiniz.

PC Üzerinde Google Play Games, yeniden eşlenen kontrolleri her kullanıcı için yerel olarak depolar. Oyun oturumlarında kontrol kalıcılığını sağlama. Bu bilgiler, mobil deneyimi etkilemez. Kullanıcı PC Üzerinde Google Play Games'i kaldırdıktan veya yeniden yükledikten sonra kontrol verileri silinir. Bu veriler birden çok PC cihazında kalıcı değildir.

Oyununuzda yeniden eşleme özelliğini desteklemek için aşağıdaki kısıtlamalardan kaçının:

Yeniden eşleme kısıtlamaları

Tuş bağlamaları herhangi bir öğe içeriyorsa yeniden eşleme özellikleri oyununuzda devre dışı bırakılabilir aşağıdaki durumlardan biri söz konusu olabilir:

• Değiştirici tuş + a'dan oluşturulmayan çok tuşlu InputActions değiştirici olmayan tuşa basın. Örneğin, Üst Karakter + A geçerlidir ancak A + B Ctrl + Alt veya Üst Karakter + A + Sekme aynı değildir.
• InputMap, InputActions, InputGroups veya InputContexts değerini içeriyor benzersiz kimlikler içerir.

Yeniden eşlemeyle ilgili sınırlamalar

Yeniden eşlemek için anahtar bağlamalarınızı tasarlarken aşağıdakileri göz önünde bulundurun sınırlamalar:

• Tuş kombinasyonlarıyla yeniden eşleme desteklenmiyor. Örneğin, kullanıcılar Üst Karakter + A'yı Ctrl + B'ye veya A'yı Üst Karakter + A'ya yeniden eşleyin.
• InputActions için yeniden eşleme, fare düğmeleriyle desteklenmiyor. Örneğin, örneğin, Üst Karakter + Sağ tıklama yeniden eşlenemez.

Anahtarları yeniden eşlemeyi PC Üzerinde Google Play Games emülatöründe test edin

PC Üzerinde Google Play Games Emülatörü'ndeki yeniden eşleme özelliğini dilediğiniz zaman etkinleştirebilirsiniz aşağıdaki adb komutunu verin:

adb shell dumpsys input_mapping_service --set RemappingFlagValue true

Yer paylaşımı, aşağıdaki resimde olduğu gibi değişir:

SDK'yı ekleme

Geliştirme platformunuza göre Giriş SDK'sını yükleyin.

Java ve Kotlin

modül düzeyindeki build.gradle dosyası:

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

Üçlü

Giriş SDK'sı, çeşitli bağımlılıkları olan standart bir Unity paketidir.

Tüm bağımlılıkları içeren paketin yüklenmesi gerekir. Birkaç şekilde yükleyin.

.unitypackage uygulamasını yükle

Giriş SDK'sı unitypackage dosyasını indirin bir arada kullanmayı tercih edebilir. Şu seçeneği belirleyerek .unitypackage uygulamasını yükleyebilirsiniz: Öğeler > Paketi içe aktar > Özel Paket'i tıklayın ve indirdiğiniz dosyanın yerini belirleyin.

UPM kullanarak yükle

Alternatif olarak, Unity'nin Paket Yöneticisi .tgz dosyasını indirip bağımlılarını yükleyin:

• com.google.external-dependency-manager-1.2.172
• com.google.librarysortper.java-0.2.0
• com.google.librarysortper.openjdk8-0.2.0
• com.google.android.libraries.play.games.inputmapping-1.1.0-beta

OpenUPM kullanarak yükle

Paketi, Google Etiket Yöneticisi'ni kullanarak OpenUPM'yi tıklayın.

$ openupm add com.google.android.libraries.play.games.inputmapping

Örnek oyunlar

Giriş SDK'sı ile nasıl entegrasyon sağlanacağıyla ilgili örnekler için bkz. AGDK Tüneli oyunlar için kotlin ya da Trivial Kart hoşuma gidiyor.

Anahtar bağlamalarınızı oluşturun

Bir InputMap oluşturup bunu bir InputMappingProvider. Aşağıdaki örnekte, InputMappingProvider:

class InputSDKProvider : InputMappingProvider {
  override fun onProvideInputMap(): InputMap {
    TODO("Not yet implemented")
  }
}

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

    @Override
    @NonNull
    public InputMap onProvideInputMap() {
        // TODO: return an InputMap
    }
}

#if PLAY_GAMES_PC
using Java.Lang;
using Java.Util;
using Google.Android.Libraries.Play.Games.Inputmapping;
using Google.Android.Libraries.Play.Games.Inputmapping.Datamodel;

public class InputSDKProvider : InputMappingProviderCallbackHelper
{
    public static readonly string INPUT_MAP_VERSION = "1.0.0";

    public override InputMap OnProvideInputMap()
    {
        // TODO: return an InputMap
    }
}
#endif

Giriş işlemlerinizi tanımlayın

InputAction sınıfı, bir tuş veya tuş kombinasyonunu bir oyunla eşlemek için kullanılır eyleme dökülebilir. InputActions, tüm InputActions genelinde benzersiz kimliklere sahip olmalıdır.

Yeniden eşlemeyi destekliyorsanız InputActions özelliğinin ne olabileceğini tanımlayabilirsiniz. yeniden eşlendi. Oyununuz yeniden eşlemeyi desteklemiyorsa yeniden eşlemeyi ayarlamanız gerekir. seçeneği tüm InputActions öğeleriniz için devre dışı bırakıldı, ancak Giriş SDK'sı yeniden eşlemeyi devre dışı bırakacak kadar akıllı olabilir. InputMap.

Bu örnekte, boşluk tuşu Drive işlemiyle eşlenir.

companion object {
  private val driveInputAction = InputAction.create(
    "Drive",
    InputActionsIds.DRIVE.ordinal.toLong(),
    InputControls.create(listOf(KeyEvent.KEYCODE_SPACE), emptyList()),
    InputEnums.REMAP_OPTION_ENABLED)
}

private static final InputAction driveInputAction = InputAction.create(
    "Drive",
    InputEventIds.DRIVE.ordinal(),
    InputControls.create(
            Collections.singletonList(KeyEvent.KEYCODE_SPACE),
            Collections.emptyList()),
    InputEnums.REMAP_OPTION_ENABLED
);

private static readonly InputAction driveInputAction = InputAction.Create(
    "Drive",
    (long)InputEventIds.DRIVE,
    InputControls.Create(
        new[] { new Integer(AndroidKeyCode.KEYCODE_SPACE) }.ToJavaList(),
        new ArrayList<Integer>()),
    InputEnums.REMAP_OPTION_ENABLED
);

İşlemler fare girişlerini de temsil edebilir. Bu örnekte Sol tıklama seçeneği Taşı işlemi:

companion object {
  private val mouseInputAction = InputAction.create(
    "Move",
    InputActionsIds.MOUSE_MOVEMENT.ordinal.toLong(),
    InputControls.create(emptyList(), listOf(InputControls.MOUSE_LEFT_CLICK)),
    InputEnums.REMAP_OPTION_DISABLED)
}

private static final InputAction mouseInputAction = InputAction.create(
    "Move",
    InputActionsIds.MOUSE_MOVEMENT.ordinal(),
    InputControls.create(
            Collections.emptyList(),
            Collections.singletonList(InputControls.MOUSE_LEFT_CLICK)
    ),
    InputEnums.REMAP_OPTION_DISABLED
);

private static readonly InputAction mouseInputAction = InputAction.Create(
    "Move",
    (long)InputEventIds.MOUSE_MOVEMENT,
    InputControls.Create(
        new ArrayList<Integer>(),
        new[] { new Integer((int)PlayMouseAction.MouseLeftClick) }.ToJavaList()
    ),
    InputEnums.REMAP_OPTION_DISABLED
);

Tuş kombinasyonları, InputAction Bu örnekte boşluk + üst karakter Turbo işlemi, Alan Drive ile eşlendiğinde bile çalışır.

companion object {
  private val turboInputAction = InputAction.create(
    "Turbo",
    InputActionsIds.TURBO.ordinal.toLong(),
    InputControls.create(
      listOf(KeyEvent.KEYCODE_SHIFT_LEFT, KeyEvent.KEYCODE_SPACE),
      emptyList()),
    InputEnums.REMAP_OPTION_ENABLED)
}

private static final InputAction turboInputAction = InputAction.create(
    "Turbo",
    InputActionsIds.TURBO.ordinal(),
    InputControls.create(
            Arrays.asList(KeyEvent.KEYCODE_SHIFT_LEFT, KeyEvent.KEYCODE_SPACE),
            Collections.emptyList()
    ),
    InputEnums.REMAP_OPTION_ENABLED
);

private static readonly InputAction turboInputAction = InputAction.Create(
    "Turbo",
    (long)InputEventIds.TURBO,
    InputControls.Create(
        new[]
        {
            new Integer(AndroidKeyCode.KEYCODE_SHIFT_LEFT),
            new Integer(AndroidKeyCode.KEYCODE_SPACE)
        }.ToJavaList(),
        new ArrayList<Integer>()),
    InputEnums.REMAP_OPTION_ENABLED
);

Giriş SDK'sı, giriş yapmak için fare ve tuş düğmelerini bir arada kullanmanıza tek bir işlemle. Bu örnekte, üst karakter ve sağ tıklama şu örnek oyunda bir ara nokta ekler:

companion object {
  private val addWaypointInputAction = InputAction.create(
    "Add waypoint",
    InputActionsIds.ADD_WAYPOINT.ordinal.toLong(),
    InputControls.create(
      listOf(KeyEvent.KeyEvent.KEYCODE_TAB),
      listOf(InputControls.MOUSE_RIGHT_CLICK)),
    InputEnums.REMAP_OPTION_DISABLED)
}

private static final InputAction addWaypointInputAction = InputAction.create(
    "Add waypoint",
    InputActionsIds.ADD_WAYPOINT.ordinal(),
    InputControls.create(
            Collections.singletonList(KeyEvent.KEYCODE_TAB),
            Collections.singletonList(InputControls.MOUSE_RIGHT_CLICK)
    ),
    InputEnums.REMAP_OPTION_DISABLED
);

private static readonly InputAction addWaypointInputAction = InputAction.Create(
    "Add waypoint",
    (long)InputEventIds.ADD_WAYPOINT,
    InputControls.Create(
        new[] { new Integer(AndroidKeyCode.KEYCODE_SPACE) }.ToJavaList(),
        new[] { new Integer((int)PlayMouseAction.MouseRightClick) }.ToJavaList()
    ),
    InputEnums.REMAP_OPTION_DISABLED
);

Girişİşlemi'nde aşağıdaki alanlar bulunur:

• ActionLabel: Kullanıcı arayüzünde bu işlemi temsil eden dize. Yerelleştirme otomatik olarak yapılmadığından tüm yerelleştirmeleri yapın .
• InputControls: Bu işlemin kullandığı giriş denetimlerini tanımlar. İlgili içeriği oluşturmak için kullanılan kontroller, yer paylaşımındaki tutarlı karakterlerle eşleşir.
• InputActionId: Sayı kimliğini ve sürümünü depolayan InputIdentifier nesnesi InputAction değerine ait (daha fazla bilgi için İzleme Anahtarı Kimlikleri'ne bakın.) ) ekleyin.
• InputRemappingOption: biri InputEnums.REMAP_OPTION_ENABLED veya InputEnums.REMAP_OPTION_DISABLED. İşlemin şunun için etkinleştirilip etkinleştirilmediğini tanımlar: gözden geçirin. Oyununuz yeniden eşlemeyi desteklemiyorsa bu alanı atlayabilirsiniz veya devre dışı bırakmanız yeterlidir.
• RemappedInputControls: Okumak için kullanılan salt okunur InputControls nesnesi yeniden eşleme etkinliklerinde kullanıcı tarafından yeniden eşlenen anahtar ( yeniden eşleme etkinlikleri hakkında bildirim alma).

InputControls, bir işlemle ilişkili girişleri temsil eder ve şu alanları kullanın:

• AndroidKeycodes: Klavye girişlerini temsil eden tam sayılardan oluşan bir listedir bir eylemle ilişkilidir. Bunlar, KeyEvent sınıfını veya Unity için AndroidKeycode sınıfını kullanmanızı öneririz.
• MouseActions: Fare girişlerini temsil eden MouseAction değerlerinin listesidir bu işlemle ilişkili.

Giriş gruplarınızı tanımlayın

InputActions, mantıksal olarak ilişkili işlemlerle InputGroups kullanılarak gruplandırılır. gezinmeyi iyileştirir ve yer paylaşımında keşfedilebilirliği kontrol eder. Her biri InputGroup kimliğinin, oyununuzdaki tüm InputGroups genelinde benzersiz olması gerekir.

Giriş işlemlerinizi gruplar halinde düzenleyerek oyuncuların şunları yapmasını kolaylaştırırsınız: mevcut bağlamları için doğru tuş bağlamasını bulmalıdır.

Yeniden eşlemeyi destekliyorsanız InputGroups özelliğinin ne olabileceğini tanımlayabilirsiniz. yeniden eşlendi. Oyununuz yeniden eşlemeyi desteklemiyorsa yeniden eşlemeyi ayarlamanız gerekir. seçeneği tüm InputGroups öğeleriniz için devre dışı bırakıldı, ancak Giriş SDK'sı yeniden eşlemeyi devre dışı bırakacak kadar akıllı olabilir. InputMap.

companion object {
  private val menuInputGroup = InputGroup.create(
    "Menu keys",
    listOf(
      navigateUpInputAction,
      navigateLeftInputAction,
      navigateDownInputAction,
      navigateRightInputAction,
      openMenuInputAction,
      returnMenuInputAction),
    InputGroupsIds.MENU_ACTION_KEYS.ordinal.toLong(),
    InputEnums.REMAP_OPTION_ENABLED
  )
}

private static final InputGroup menuInputGroup = InputGroup.create(
    "Menu keys",
    Arrays.asList(
           navigateUpInputAction,
           navigateLeftInputAction,
           navigateDownInputAction,
           navigateRightInputAction,
           openMenuInputAction,
           returnMenuInputAction),
    InputGroupsIds.MENU_ACTION_KEYS.ordinal(),
    REMAP_OPTION_ENABLED
);

private static readonly InputGroup menuInputGroup = InputGroup.Create(
    "Menu keys",
    new[]
    {
        navigateUpInputAction,
        navigateLeftInputAction,
        navigateDownInputAction,
        navigateRightInputAction,
        openMenuInputAction,
        returnMenuInputAction,
    }.ToJavaList(),
    (long)InputGroupsIds.MENU_ACTION_KEYS,
    InputEnums.REMAP_OPTION_ENABLED
);

Aşağıdaki örnekte Yol kontrolleri ve Menü kontrolleri gösterilmektedir yer paylaşımındaki giriş grupları:

InputGroup alanında şu alanlar bulunur:

• GroupLabel: yer paylaşımında görüntülenecek ve şu işlemler için kullanılabilecek bir dize: mantıksal olarak gruplandırmaktır. Bu dize otomatik olarak yerelleştiriliyor.
• InputActions: Önceki öğede tanımladığınız InputAction nesnenin listesi adımına geçelim. Bu işlemlerin tümü görsel olarak grup başlığı altında gösterilir.
• InputGroupId: InputIdentifier numara kimliğini ve sayısal değeri depolayan nesne InputGroup sürümü için kullanılıyor. Aşağıdakiler için İzleme Anahtarı Kimlikleri bölümüne bakın: daha fazla bilgi edinin.
• InputRemappingOption: biri InputEnums.REMAP_OPTION_ENABLED veya InputEnums.REMAP_OPTION_DISABLED. Devre dışı bırakılırsa tüm InputAction bu gruba ait olan nesnelerin yeniden eşlenmesi, devre dışı bırakılsa bile yeniden eşleme seçeneğinin etkin olduğunu belirtmelidir. Etkinleştirilirse, hesaba ait tüm işlemler kullanıcı tarafından devre dışı bırakılmadığı sürece yeniden eşlenebilir işlemlerdir.

Giriş bağlamlarınızı tanımlayın

InputContexts, oyununuzun şu işlemler için farklı klavye kontrolleri kullanmasına izin verir: sahneler oluşturabilirsiniz. Örnek:

• Menülerde gezinme ve gezinme için farklı giriş grupları belirtebilirsiniz. elde etti.
• Hareket moduna bağlı olarak farklı giriş grupları belirtebilirsiniz dikkatinizi çekebilir.
• Hesabınızın geçerli durumuna bağlı olarak farklı giriş grupları belirtebilirsiniz. örneğin bir dünyada gezinme veya bireysel seviyede oynama gibi oyuna dahildir.

InputContexts kullanılırken yer paylaşımı önce bağlam gruplarını gösterir kullanım durumu. Bu davranışı etkinleştirmek için setInputContext() öğesini çağırarak farklı bir sahneye girdiğinde bağlam bilgisi ekleyin. Aşağıdaki resim , şu davranışı gösterir: "arabayla" Yol kontrolleri işlemler yer paylaşımının üst kısmında gösterilir. "Mağaza"yı açarken menüsünde, "Menü kontrolleri" işlemler yer paylaşımının üst kısmında görüntülenir.

Bu yer paylaşımı güncellemeleri, aşağıdaki konumda farklı bir InputContext ayarlanarak gerçekleştirilir daha fazla puan kazanacaksınız. Bunu yapmak için:

1. InputGroups kullanarak InputActions öğenizi mantıksal olarak ilişkili işlemlerle gruplandırın
2. Bu InputGroups öğesini, farklı bölümleri için bir InputContext öğesine atayın oyununuza

Aynıya ait InputGroupsInputContextçakışamaz InputActions. Her bir ekip üyesine InputGroup tek bir InputContext öğesine.

Aşağıdaki örnek kodda InputContext mantığı gösterilmektedir:

companion object {
  val menuSceneInputContext = InputContext.create(
    "Menu",
    InputIdentifier.create(
      INPUTMAP_VERSION,
      InputContextIds.MENU_SCENE.ordinal.toLong()),
    listOf(basicMenuNavigationInputGroup, menuActionsInputGroup))

  val gameSceneInputContext = InputContext.create(
    "Game",
    InputIdentifier.create(
      INPUTMAP_VERSION,
      InputContextIds.GAME_SCENE.ordinal.toLong()),
    listOf(
      movementInputGroup,
      mouseActionsInputGroup,
      emojisInputGroup,
      gameActionsInputGroup))
}

public static final InputContext menuSceneInputContext = InputContext.create(
        "Menu",
        InputIdentifier.create(
                INPUTMAP_VERSION,
                InputContextIds.MENU_SCENE.ordinal()),
        Arrays.asList(
                basicMenuNavigationInputGroup,
                menuActionsInputGroup
        )
);

public static final InputContext gameSceneInputContext = InputContext.create(
        "Game",
        InputIdentifier.create(
                INPUTMAP_VERSION,
                InputContextIds.GAME_SCENE.ordinal()),
        Arrays.asList(
                movementInputGroup,
                mouseActionsInputGroup,
                emojisInputGroup,
                gameActionsInputGroup
        )
);

public static readonly InputContext menuSceneInputContext = InputContext.Create(
    "Menu",
    InputIdentifier.Create(
        INPUT_MAP_VERSION,
        (long)InputContextsIds.MENU_SCENE),
    new[]
    {
        basicMenuNavigationInputGroup,
        menuActionsInputGroup
    }.ToJavaList()
);

public static readonly InputContext gameSceneInputContext = InputContext.Create(
    "Game",
    InputIdentifier.Create(
        INPUT_MAP_VERSION,
        (long)InputContextsIds.GAME_SCENE),
    new[]
    {
        movementInputGroup,
        mouseActionsInputGroup,
        emojisInputGroup,
        gameActionsInputGroup
    }.ToJavaList()
);

InputContext alanında şu alanlar bulunur:

• LocalizedContextLabel: gruba ait olan grupları açıklayan bir dize bağlam.
• InputContextId: Sayı kimliğini ve sürümünü depolayan InputIdentifier nesnesi InputContext değerine ait (daha fazla bilgi için İzleme Anahtarı Kimlikleri'ne bakın.) ) ekleyin.
• ActiveGroups: kullanılacak ve üstte görüntülenecek InputGroups listesi bu bağlam etkin olduğunda Google'a görünür.

Giriş haritası oluştur

InputMap, birInputGroup ve dolayısıyla bir oyuncunun görmeyi bekleyebileceği tüm InputAction nesneleri yardımcı olur.

Anahtar bağlamalarınızı bildirirken, tümInputMap Oyununuzda InputGroups kullanıldı.

Oyununuz yeniden eşlemeyi desteklemiyorsa yeniden eşleme seçeneğini devre dışı bırakın ve boş bırakın.

Aşağıdaki örnekte bir InputMap koleksiyonunu bildirmek için kullanılan InputMap derlenir InputGroups.

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

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

public static readonly InputMap gameInputMap = InputMap.Create(
    new[]
    {
        basicMenuNavigationInputGroup,
        menuActionKeysInputGroup,
        movementInputGroup,
        mouseMovementInputGroup,
        pauseMenuInputGroup,
    }.ToJavaList(),
    MouseSettings.Create(true, false),
    InputIdentifier.Create(INPUT_MAP_VERSION, INPUT_MAP_ID),
    InputEnums.REMAP_OPTION_ENABLED,
    // Use ESCAPE as reserved remapping key
    new[]
    {
        InputControls.Create(
            New[] {
            new Integer(AndroidKeyCode.KEYCODE_ESCAPE)
        }.ToJavaList(),
        new ArrayList<Integer>())
    }.ToJavaList()
);

InputMap alanında şu alanlar bulunur:

• InputGroups: Oyununuz tarafından bildirilen Giriş Grupları. Gruplar Mevcut gruplar belirtilmedikçe, yer paylaşımında sırayla gösterilir. setInputContext() aramasını kullanın.
• MouseSettings: MouseSettings nesnesi, fare hassasiyetinin ve farenin y ekseninde ters çevrilmiş olduğunu gösterir.
• InputMapId: Şu numara kimliğini ve sürümünü depolayan InputIdentifier nesnesi: InputMap (daha fazla bilgi için İzleme Anahtarı Kimlikleri bölümüne bakın ) ekleyin.
• InputRemappingOption: biri InputEnums.REMAP_OPTION_ENABLED veya InputEnums.REMAP_OPTION_DISABLED. Yeniden eşleme özelliğinin etkin.
• ReservedControls: Kullanıcıların yapmasına izin verilmeyecek InputControls listesi yeniden eşlemek için kullanır.

İzleme anahtarı kimlikleri

InputAction, InputGroup, InputContext ve InputMap nesneleri bir Benzersiz bir sayı kimliği ve dize sürümü kimliği depolayan InputIdentifier nesnesi. Nesnelerinizin dize sürümünü izlemek isteğe bağlıdır ancak InputMap sürümleri. Dize sürümü sağlanmazsa dizesi boş. InputMap nesne için dize sürümü gerekiyor.

Aşağıdaki örnek, InputActions veya InputGroups:

class InputSDKProviderKotlin : InputMappingProvider {
  companion object {
    const val INPUTMAP_VERSION = "1.0.0"
    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 val movementInputGroup  = InputGroup.create(
      "Basic movement",
      listOf(
        moveUpInputAction,
        moveLeftInputAction,
        moveDownInputAction,
        mouseGameInputAction),
      InputIdentifier.create(
        INPUTMAP_VERSION, InputGroupsIds.BASIC_MOVEMENT.ordinal.toLong()),
      InputEnums.REMAP_OPTION_ENABLED)
  }
}

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

    private static final InputAction enterMenuInputAction = InputAction.create(
            "Enter menu",
            InputControls.create(
                    Collections.singletonList(KeyEvent.KEYCODE_ENTER),
                    Collections.emptyList()),
            InputIdentifier.create(
                    INPUTMAP_VERSION, InputActionsIds.ENTER_MENU.ordinal()),
            InputEnums.REMAP_OPTION_ENABLED
    );

    private static final InputGroup movementInputGroup = InputGroup.create(
            "Basic movement",
            Arrays.asList(
                    moveUpInputAction,
                    moveLeftInputAction,
                    moveDownInputAction,
                    moveRightInputAction,
                    mouseGameInputAction
            ),
            InputIdentifier.create(
                    INPUTMAP_VERSION, InputGroupsIds.BASIC_MOVEMENT.ordinal()),
            InputEnums.REMAP_OPTION_ENABLED
    );
}

#if PLAY_GAMES_PC

using Java.Lang;
using Java.Util;
using Google.Android.Libraries.Play.Games.Inputmapping;
using Google.Android.Libraries.Play.Games.Inputmapping.Datamodel;

public class InputSDKMappingProvider : InputMappingProviderCallbackHelper
{
    public static readonly string INPUT_MAP_VERSION = "1.0.0";

    private static readonly InputAction enterMenuInputAction =
        InputAction.Create(
            "Enter menu",
            InputControls.Create(
                new[] { new Integer(AndroidKeyCode.KEYCODE_SPACE)}.ToJavaList(),
                new ArrayList<Integer>()),
            InputIdentifier.Create(
                INPUT_MAP_VERSION,
                (long)InputEventIds.ENTER_MENU),
            InputEnums.REMAP_OPTION_ENABLED
        );

    private static readonly InputGroup movementInputGroup = InputGroup.Create(
        "Basic movement",
        new[]
        {
            moveUpInputAction,
            moveLeftInputAction,
            moveDownInputAction,
            moveRightInputAction,
            mouseGameInputAction
        }.ToJavaList(),
        InputIdentifier.Create(
            INPUT_MAP_VERSION,
            (long)InputGroupsIds.BASIC_MOVEMENT),
        InputEnums.REMAP_OPTION_ENABLED
    );
}
#endif

InputAction nesne numara kimlikleri tüm InputActions içinde benzersiz olmalıdır InputMap cihazınız. Benzer şekilde, InputGroup nesne kimlikleri tüm cihazlarda benzersiz olmalıdır InputMap içinde InputGroups. Aşağıdaki örnekte, Nesnenizin benzersiz kimliklerini izlemek için enum:

enum class InputActionsIds {
    NAVIGATE_UP,
    NAVIGATE_DOWN,
    ENTER_MENU,
    EXIT_MENU,
    // ...
    JUMP,
    RUN,
    EMOJI_1,
    EMOJI_2,
    // ...
}

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
}

enum class InputContextIds {
    MENU_SCENE, // Basic menu navigation, menu actions
    GAME_SCENE, // Basic movement, mouse actions, emojis, game actions
}

const val INPUT_MAP_ID = 0

public enum InputActionsIds {
    NAVIGATE_UP,
    NAVIGATE_DOWN,
    ENTER_MENU,
    EXIT_MENU,
    // ...
    JUMP,
    RUN,
    EMOJI_1,
    EMOJI_2,
    // ...
}

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
}

public enum InputContextIds {
    MENU_SCENE, // Basic navigation, menu actions
    GAME_SCENE, // Basic movement, mouse actions, emojis, game actions
}

public static final long INPUT_MAP_ID = 0;

public enum InputActionsIds
{
    NAVIGATE_UP,
    NAVIGATE_DOWN,
    ENTER_MENU,
    EXIT_MENU,
    // ...
    JUMP,
    RUN,
    EMOJI_1,
    EMOJI_2,
    // ...
}

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
}

public enum InputContextIds
{
    MENU_SCENE, // Basic navigation, menu actions
    GAME_SCENE, // Basic movement, mouse actions, emojis, game actions
}

public static readonly long INPUT_MAP_ID = 0;

InputIdentifier alanında şu alanlar bulunur:

• UniqueId: Belirli bir giriş grubunu net bir şekilde tanımlamak için ayarlanmış benzersiz sayı kimliği verileri benzersizdir.
• VersionString: bir sürümü tanımlamak için ayarlanmış, okunabilir bir sürüm dizesi giriş verisi değişikliklerinin 2 sürümü arasındaki giriş verilerinin oranı.

Yeniden eşleme etkinlikleri hakkında bildirim alın (İsteğe bağlı)

Şu deneyimde kullanılan tuşlar hakkında bilgi almak için yeniden eşleme etkinlikleri hakkında bildirim alın: gösterir. Bu sayede oyununuz, oyun ekranında gösterilen öğeleri güncelleyebilir işlem kontrollerini görüntülemek için kullanılır.

Aşağıdaki resimde, G, P ve S tuşlarına basarak J, X'e gidin ve T sırasıyla oyunun kullanıcı arayüzü öğeleri kullanıcı tarafından ayarlanan tuşları gösterir.

Bu işlev, bir InputRemappingListener kaydettirilerek gerçekleştirilir geri arama. Bu özelliği uygulamak için, öncelikle bir InputRemappingListener örneği:

class InputSDKRemappingListener : InputRemappingListener {
  override fun onInputMapChanged(inputMap: InputMap) {
    Log.i(TAG, "Received update on input map changed.")
    if (inputMap.inputRemappingOption() == InputEnums.REMAP_OPTION_DISABLED) {
      return
    }
    for (inputGroup in inputMap.inputGroups()) {
      if (inputGroup.inputRemappingOption() == InputEnums.REMAP_OPTION_DISABLED) {
        continue
      }
      for (inputAction in inputGroup.inputActions()) {
        if (inputAction.inputRemappingOption() != InputEnums.REMAP_OPTION_DISABLED) {
          // Found InputAction remapped by user
          processRemappedAction(inputAction)
        }
      }
    }
  }

  private fun processRemappedAction(remappedInputAction: InputAction) {
    // Get remapped action info
    val remappedControls = remappedInputAction.remappedInputControls()
    val remappedKeyCodes = remappedControls.keycodes()
    val mouseActions = remappedControls.mouseActions()
    val version = remappedInputAction.inputActionId().versionString()
    val remappedActionId = remappedInputAction.inputActionId().uniqueId()
    val currentInputAction: Optional<InputAction>
    currentInputAction = if (version == null || version.isEmpty()
      || version == InputSDKProvider.INPUTMAP_VERSION
    ) {
      getCurrentVersionInputAction(remappedActionId)
    } else {
      Log.i(TAG,
            "Detected version of user-saved input action defers from current version")
      getCurrentVersionInputActionFromPreviousVersion(
        remappedActionId, version)
    }
    if (!currentInputAction.isPresent) {
      Log.e(TAG, String.format(
        "can't find remapped input action with id %d and version %s",
        remappedActionId, if (version == null || version.isEmpty()) "UNKNOWN" else version))
      return
    }
    val originalControls = currentInputAction.get().inputControls()
    val originalKeyCodes = originalControls.keycodes()
    Log.i(TAG, String.format(
      "Found input action with id %d remapped from key %s to key %s",
      remappedActionId,
      keyCodesToString(originalKeyCodes),
      keyCodesToString(remappedKeyCodes)))

    // TODO: make display changes to match controls used by the user
  }

  private fun getCurrentVersionInputAction(inputActionId: Long): Optional<InputAction> {
    for (inputGroup in InputSDKProvider.gameInputMap.inputGroups()) {
      for (inputAction in inputGroup.inputActions()) {
        if (inputAction.inputActionId().uniqueId() == inputActionId) {
          return Optional.of(inputAction)
        }
      }
    }
    return Optional.empty()
  }

  private fun getCurrentVersionInputActionFromPreviousVersion(
    inputActionId: Long, previousVersion: String
  ): Optional<InputAction7gt; {
    // TODO: add logic to this method considering the diff between the current and previous
    //  InputMap.
    return Optional.empty()
  }

  private fun keyCodesToString(keyCodes: List<Int>): String {
    val builder = StringBuilder()
    for (keyCode in keyCodes) {
      if (!builder.toString().isEmpty()) {
        builder.append(" + ")
      }
      builder.append(keyCode)
    }
    return String.format("(%s)", builder)
  }

  companion object {
    private const val TAG = "InputSDKRemappingListener"
  }
}

public class InputSDKRemappingListener implements InputRemappingListener {

    private static final String TAG = "InputSDKRemappingListener";

    @Override
    public void onInputMapChanged(InputMap inputMap) {
        Log.i(TAG, "Received update on input map changed.");
        if (inputMap.inputRemappingOption() ==
                InputEnums.REMAP_OPTION_DISABLED) {
            return;
        }
        for (InputGroup inputGroup : inputMap.inputGroups()) {
            if (inputGroup.inputRemappingOption() ==
                    InputEnums.REMAP_OPTION_DISABLED) {
                continue;
            }
            for (InputAction inputAction : inputGroup.inputActions()) {
                if (inputAction.inputRemappingOption() !=
                        InputEnums.REMAP_OPTION_DISABLED) {
                    // Found InputAction remapped by user
                    processRemappedAction(inputAction);
                }
            }
        }
    }

    private void processRemappedAction(InputAction remappedInputAction) {
        // Get remapped action info
        InputControls remappedControls =
            remappedInputAction.remappedInputControls();
        List<Integer> remappedKeyCodes = remappedControls.keycodes();
        List<Integer> mouseActions = remappedControls.mouseActions();
        String version = remappedInputAction.inputActionId().versionString();
        long remappedActionId = remappedInputAction.inputActionId().uniqueId();
        Optional<InputAction> currentInputAction;
        if (version == null || version.isEmpty()
                    || version.equals(InputSDKProvider.INPUTMAP_VERSION)) {
            currentInputAction = getCurrentVersionInputAction(remappedActionId);
        } else {
            Log.i(TAG, "Detected version of user-saved input action defers " +
                    "from current version");
            currentInputAction =
                    getCurrentVersionInputActionFromPreviousVersion(
                            remappedActionId, version);
        }
        if (!currentInputAction.isPresent()) {
            Log.e(TAG, String.format(
                    "input action with id %d and version %s not found",
                    remappedActionId, version == null || version.isEmpty() ?
                            "UNKNOWN" : version));
            return;
        }
        InputControls originalControls =
                currentInputAction.get().inputControls();
        List<Integer> originalKeyCodes = originalControls.keycodes();

        Log.i(TAG, String.format(
                "Found input action with id %d remapped from key %s to key %s",
                remappedActionId,
                keyCodesToString(originalKeyCodes),
                keyCodesToString(remappedKeyCodes)));

        // TODO: make display changes to match controls used by the user
    }

    private Optional<InputAction> getCurrentVersionInputAction(
            long inputActionId) {
        for (InputGroup inputGroup :
                    InputSDKProvider.gameInputMap.inputGroups()) {
            for (InputAction inputAction : inputGroup.inputActions()) {
                if (inputAction.inputActionId().uniqueId() == inputActionId) {
                    return Optional.of(inputAction);
                }
            }
        }
        return Optional.empty();
    }

    private Optional<InputAction>
            getCurrentVersionInputActionFromPreviousVersion(
                    long inputActionId, String previousVersion) {
        // TODO: add logic to this method considering the diff between your
        // current and previous InputMap.
        return Optional.empty();
    }

    private String keyCodesToString(List<Integer> keyCodes) {
        StringBuilder builder = new StringBuilder();
        for (Integer keyCode : keyCodes) {
            if (!builder.toString().isEmpty()) {
                builder.append(" + ");
            }
            builder.append(keyCode);
        }
        return String.format("(%s)", builder);
    }
}

#if PLAY_GAMES_PC

using System.Text;
using Java.Lang;
using Java.Util;
using Google.Android.Libraries.Play.Games.Inputmapping;
using Google.Android.Libraries.Play.Games.Inputmapping.Datamodel;
using UnityEngine;

public class InputSDKRemappingListener : InputRemappingListenerCallbackHelper
{
    public override void OnInputMapChanged(InputMap inputMap)
    {
        Debug.Log("Received update on remapped controls.");
        if (inputMap.InputRemappingOption() == InputEnums.REMAP_OPTION_DISABLED)
        {
            return;
        }
        List<InputGroup> inputGroups = inputMap.InputGroups();
        for (int i = 0; i < inputGroups.Size(); i ++)
        {
            InputGroup inputGroup = inputGroups.Get(i);
            if (inputGroup.InputRemappingOption()
                    == InputEnums.REMAP_OPTION_DISABLED)
            {
                continue;
            }
            List<InputAction> inputActions = inputGroup.InputActions();
            for (int j = 0; j < inputActions.Size(); j ++)
            {
                InputAction inputAction = inputActions.Get(j);
                if (inputAction.InputRemappingOption()
                        != InputEnums.REMAP_OPTION_DISABLED)
                {
                    // Found action remapped by user
                    ProcessRemappedAction(inputAction);
                }
            }
        }
    }

    private void ProcessRemappedAction(InputAction remappedInputAction)
    {
        InputControls remappedInputControls =
                remappedInputAction.RemappedInputControls();
        List<Integer> remappedKeycodes = remappedInputControls.Keycodes();
        List<Integer> mouseActions = remappedInputControls.MouseActions();
        string version = remappedInputAction.InputActionId().VersionString();
        long remappedActionId = remappedInputAction.InputActionId().UniqueId();
        InputAction currentInputAction;
        if (string.IsNullOrEmpty(version)
                || string.Equals(
                version, InputSDKMappingProvider.INPUT_MAP_VERSION))
        {
            currentInputAction = GetCurrentVersionInputAction(remappedActionId);
        }
        else
        {
            Debug.Log("Detected version of used-saved input action defers" +
                " from current version");
            currentInputAction =
                GetCurrentVersionInputActionFromPreviousVersion(
                    remappedActionId, version);
        }
        if (currentInputAction == null)
        {
            Debug.LogError(string.Format(
                "Input Action with id {0} and version {1} not found",
                remappedActionId,
                string.IsNullOrEmpty(version) ? "UNKNOWN" : version));
            return;
        }
        InputControls originalControls = currentInputAction.InputControls();
        List<Integer> originalKeycodes = originalControls.Keycodes();

        Debug.Log(string.Format(
            "Found Input Action with id {0} remapped from key {1} to key {2}",
            remappedActionId,
            KeyCodesToString(originalKeycodes),
            KeyCodesToString(remappedKeycodes)));
        // TODO: update HUD according to the controls of the user
    }

    private InputAction GetCurrentVersionInputAction(
            long inputActionId)
    {
        List<InputGroup> inputGroups =
            InputSDKMappingProvider.gameInputMap.InputGroups();
        for (int i = 0; i < inputGroups.Size(); i++)
        {
            InputGroup inputGroup = inputGroups.Get(i);
            List<InputAction> inputActions = inputGroup.InputActions();
            for (int j = 0; j < inputActions.Size(); j++)
            {
                InputAction inputAction = inputActions.Get(j);
                if (inputAction.InputActionId().UniqueId() == inputActionId)
                {
                    return inputAction;
                }
            }
        }
        return null;
    }

    private InputAction GetCurrentVersionInputActionFromPreviousVersion(
            long inputActionId, string version)
    {
        // TODO: add logic to this method considering the diff between your
        // current and previous InputMap.
        return null;
    }

    private string KeyCodesToString(List<Integer> keycodes)
    {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < keycodes.Size(); i ++)
        {
            Integer keycode = keycodes.Get(i);
            if (builder.Length > 0)
            {
                builder.Append(" + ");
            }
            builder.Append(keycode.IntValue());
        }
        return string.Format("({0})", builder.ToString());
    }
}
#endif

InputRemappingListener, yüklendikten sonra lansman anında bilgilendirilir kullanıcı tarafından kaydedilen yeniden eşlenen kontroller içerir.

Başlatma

InputContexts kullanıyorsanız her bir öğede bağlamı ayarlayın ilk sahnede kullanılan ilk bağlam da dahil olmak üzere yeni bir sahneye sahne. InputContext ayarlarını, InputMap.

Yeniden eşleme etkinlikleri hakkında bildirim almak için InputRemappingListeners kullanıyorsanız kayıt işlemini yapmadan önce InputRemappingListener InputMappingProvider, aksi takdirde oyununuz önemli etkinlikleri kaçırabilir. lansman zamanı.

Aşağıdaki örnekte, API'nin nasıl başlatılacağı gösterilmektedir:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    if (isGooglePlayGamesOnPC()) {
        val inputMappingClient = Input.getInputMappingClient(this)
        // Register listener before registering the provider
        inputMappingClient.registerRemappingListener(InputSDKRemappingListener())
        inputMappingClient.setInputMappingProvider(
                InputSDKProvider())
        // Set the context after you have registered the provider.
        inputMappingClient.setInputContext(InputSDKProvider.menuSceneInputContext)
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    if (isGooglePlayGamesOnPC()) {
        InputMappingClient inputMappingClient =
                Input.getInputMappingClient(this);
        // Register listener before registering the provider
        inputMappingClient.registerRemappingListener(
                new InputSDKRemappingListener());
        inputMappingClient.setInputMappingProvider(
                new InputSDKProvider());
        // Set the context after you have registered the provider
        inputMappingClient.setInputContext(InputSDKProvider.menuSceneInputContext);
    }
}

#if PLAY_GAMES_PC
using Google.Android.Libraries.Play.Games.Inputmapping;
using Google.Android.Libraries.Play.Games.InputMapping.ExternalType.Android.Content;
using Google.LibraryWrapper.Java;
#endif

public class GameManager : MonoBehaviour
{
#if PLAY_GAMES_PC
    private InputSDKMappingProvider _inputMapProvider =
        new InputSDKMappingProvider();
    private InputMappingClient _inputMappingClient;
#endif

    public void Awake()
    {
#if PLAY_GAMES_PC
        Context context = (Context)Utils.GetUnityActivity().GetRawObject();
        _inputMappingClient = Google.Android.Libraries.Play.Games.Inputmapping
            .Input.GetInputMappingClient(context);
        // Register listener before registering the provider.
        _inputMappingClient.RegisterRemappingListener(
            new InputSDKRemappingListener());
        _inputMappingClient.SetInputMappingProvider(_inputMapProvider);
        // Register context after you have registered the provider.
       _inputMappingClient.SetInputContext(
           InputSDKMappingProvider.menuSceneInputContext);
#endif
    }
}

Düzenle

InputMappingProvider örneğinizin ve tüm InputRemappingListener örneğinizin kaydını iptal edin Giriş SDK'sı akıllı olsa da oyununuzun kapalı olduğu durumlar kaynak sızıntısını önlemek için yeterli önlemleri almalısınız:

override fun onDestroy() {
    if (isGooglePlayGamesOnPC()) {
        val inputMappingClient = Input.getInputMappingClient(this)
        inputMappingClient.clearInputMappingProvider()
        inputMappingClient.clearRemappingListener()
    }

    super.onDestroy()
}

@Override
protected void onDestroy() {
    if (isGooglePlayGamesOnPC()) {
        InputMappingClient inputMappingClient =
                Input.getInputMappingClient(this);
        inputMappingClient.clearInputMappingProvider();
        inputMappingClient.clearRemappingListener();
    }

    super.onDestroy();
}

public class GameManager : MonoBehaviour
{
    private void OnDestroy()
    {
#if PLAY_GAMES_PC
        _inputMappingClient.ClearInputMappingProvider();
        _inputMappingClient.ClearRemappingListener();
#endif
    }
}

Test

Giriş SDK'sı uygulamanızı manuel olarak açarak test edebilirsiniz. Oynatıcı deneyimini görüntülemek için yer paylaşımını veya adb kabuğunu kullanarak otomatik test ve doğrulama için.

PC Üzerinde Google Play Games Emülatörü, giriş haritanızın doğruluğunu kontrol eder karşılaştırabilirsiniz. Farklı kimlikler kullanarak yinelenen benzersiz kimliklerin giriş eşlemeleri veya yeniden eşleme kurallarında başarısız olursa (yeniden eşleme etkinse) yer paylaşımı aşağıdaki gibi bir hata mesajı gösterir: .

Komut satırında adb kullanarak Giriş SDK'sı uygulamanızı doğrulayın. Geçerli giriş haritasını almak için aşağıdaki adb shell komutunu kullanın ( Oyununuzun adıyla MY.PACKAGE.NAME):

adb shell dumpsys input_mapping_service --get MY.PACKAGE.NAME

InputMap:

Getting input map for com.example.inputsample...
Successfully received the following inputmap:
# com.google.android.libraries.play.games.InputMap@d73526e1
input_groups {
  group_label: "Basic Movement"
  input_actions {
    action_label: "Jump"
    input_controls {
      keycodes: 51
      keycodes: 19
    }
    unique_id: 0
  }
  input_actions {
    action_label: "Left"
    input_controls {
      keycodes: 29
      keycodes: 21
    }
    unique_id: 1
  }
  input_actions {
    action_label: "Right"
    input_controls {
      keycodes: 32
      keycodes: 22
    }
    unique_id: 2
  }
  input_actions {
    action_label: "Use"
    input_controls {
      keycodes: 33
      keycodes: 66
      mouse_actions: MOUSE_LEFT_CLICK
      mouse_actions_value: 0
    }
    unique_id: 3
  }
}
input_groups {
  group_label: "Special Input"
  input_actions {
    action_label: "Jump"
    input_controls {
      keycodes: 51
      keycodes: 19
      keycodes: 62
      mouse_actions: MOUSE_LEFT_CLICK
      mouse_actions_value: 0
    }
    unique_id: 4
  }
  input_actions {
    action_label: "Duck"
    input_controls {
      keycodes: 47
      keycodes: 20
      keycodes: 113
      mouse_actions: MOUSE_RIGHT_CLICK
      mouse_actions_value: 1
    }
    unique_id: 5
  }
}
mouse_settings {
  allow_mouse_sensitivity_adjustment: true
  invert_mouse_movement: true
}

Yerelleştirme

Giriş SDK'sı, Android'in yerelleştirme sistemini kullanmaz. Kullanıcı sonuç olarak bir InputMap gönderirken yerelleştirilmiş dizeler sağlamanız gerekir. Siz oyun motorunuzun yerelleştirme sistemini de kullanabilir.

ProGuard

Oyununuzu küçültmek için ProGuard kullanırken aşağıdaki kuralları önleyici yapılandırma dosyasını, SDK'nın nihai paket:

-keep class com.google.android.libraries.play.hpe.** { *; }
-keep class com.google.android.libraries.play.games.inputmapping.** { *; }

Sırada ne var?

Giriş SDK'sını oyununuza entegre ettikten sonra devam edebilirsiniz geri kalan PC Üzerinde Google Play Games gereksinimleriyle. Daha fazla bilgi için PC Üzerinde Google Play Games'i kullanmaya başlama başlıklı makaleyi inceleyin.