इनपुट SDK टूल का इस्तेमाल शुरू करें

इस दस्तावेज़ में इनपुट SDK टूल को सेट अप और डिसप्ले करने का तरीका बताया गया है ऐसे गेम जो Google Play Games on PC के साथ काम करते हैं. टास्क में SDK टूल जोड़ना इनपुट मैप जनरेट कर सकता है, जिसमें गेम-कार्रवाई-से-उपयोगकर्ता-इनपुट असाइनमेंट.

शुरू करने से पहले

अपने गेम में इनपुट SDK टूल जोड़ने से पहले, आपको कीबोर्ड और माउस इनपुट के लिए अपने गेम इंजन के इनपुट सिस्टम.

इनपुट SDK टूल, Google Play Games on PC को इसके बारे में जानकारी देता है आपका गेम कौनसे कंट्रोल का इस्तेमाल करता है, ताकि वे लोगों को दिख सकें. यह काम भी कर सकता है यह विकल्प, उपयोगकर्ताओं के लिए कीबोर्ड को फिर से मैप करने की अनुमति देता है.

हर कंट्रोल एक InputAction है (जैसे, "जंप" के लिए "J") और आप अपने InputGroups में InputActions दिए. InputGroup, एआई से अलग जैसे, "ड्राइविंग" मोड या "पैदल चलना" या "मुख्य मेन्यू" पर टैप करें. आप यह भी कर सकते हैं InputContexts का इस्तेमाल करके बताएं कि कौनसे ग्रुप अलग-अलग समय पर चालू हैं से बचें.

अपने-आप हैंडल होने के लिए, कीबोर्ड रीमैपिंग को चालू किया जा सकता है. हालांकि, अगर आप अपना खुद का नियंत्रण रीमैपिंग इंटरफ़ेस उपलब्ध कराना चाहते हैं तो आप इसे अक्षम कर सकते हैं इनपुट SDK टूल को फिर से मैप करना.

नीचे दिए गए क्रम के डायग्राम में बताया गया है कि इनपुट SDK टूल का एपीआई कैसे काम करता है:

जब आपका गेम, इनपुट SDK टूल लागू करता है, तो आपके कंट्रोल दिखते हैं पर भी दिखेगा.

Google Play Games on PC ओवरले

Google Play Games on PC ओवरले ("ओवरले"), कंट्रोल दिखाता है तय करते हैं. उपयोगकर्ता किसी भी समय Shift + Tab दबाएं.

की बाइंडिंग डिज़ाइन करने के सबसे सही तरीके

की बाइंडिंग डिज़ाइन करते समय इन सबसे सही तरीकों को ध्यान में रखें:

• बेहतर बनाने के लिए, अपने InputActions को लॉजिक के हिसाब से मिलते-जुलते InputGroups के साथ ग्रुप करें गेमप्ले के दौरान कंट्रोल को खोजने लायक बनाने और उसे खोजने लायक बनाने में भी मदद करता है.
• हर InputGroup को ज़्यादा से ज़्यादा एक InputContext के लिए असाइन करें. बारीक दानेदार InputMap में कंट्रोल का इस्तेमाल करने पर बेहतर अनुभव मिलेगा ओवरले पर क्लिक करें.
• अपने गेम के हर अलग-अलग तरह के सीन के लिए, InputContext बनाएं. आम तौर पर, "मेन्यू से मिलते-जुलते सभी प्रॉडक्ट" के लिए एक ही InputContext का इस्तेमाल किया जा सकता है सीन. अपने गेम के किसी भी मिनीगेम के लिए याInputContexts किसी एक सीन के लिए अन्य कंट्रोल.
• अगर दो कार्रवाइयों को, एक ही दस्तावेज़ में, एक ही कुंजी का इस्तेमाल करने के लिए डिज़ाइन किया गया है InputContext, लेबल स्ट्रिंग का इस्तेमाल करें, जैसे कि "इंटरैक्शन / Fire".
• अगर दो कुंजियां एक ही InputAction से बाइंड करने के लिए डिज़ाइन की गई हैं, तो 2 का इस्तेमाल करें अलग-अलग InputActions जो आपके गेम में एक ही तरह की कार्रवाई करते हैं. आप InputActions दोनों के लिए एक ही लेबल स्ट्रिंग का इस्तेमाल करें, लेकिन इसका आईडी यह होना चाहिए अलग हैं.
• अगर कुंजियों के सेट पर कार्रवाई बदलने वाली कुंजी लागू की जाती है, तो एक ही कुंजी का इस्तेमाल करें कई InputActions के बजाय, कार्रवाई बदलने वाली कुंजी से InputAction कार्रवाई बदलने वाली कुंजी को जोड़ें (उदाहरण: इसके बजाय Shift और W, A, S, D का इस्तेमाल करें Shift + W, Shift + A, Shift + S, Shift + D).
• जब उपयोगकर्ता टेक्स्ट में लिखता है, तो इनपुट रीमैपिंग अपने-आप बंद हो जाता है फ़ील्ड. Android टेक्स्ट फ़ील्ड लागू करने के सबसे सही तरीके अपनाएं, ताकि यह पक्का किया जा सके कि इसकी मदद से, Android आपके गेम में टेक्स्ट फ़ील्ड का पता लगाता है और बटन को दोबारा मैप करने से रोकता है उन्हें हस्तक्षेप नहीं करना चाहिए. अगर आपके गेम में गैर-परंपरागत टेक्स्ट का इस्तेमाल करना है फ़ील्ड में setInputContext() का इस्तेमाल किया जा सकता है. InputContext में InputGroups की खाली सूची जोड़ें.
• अगर आपके गेम को रीमैप करने की सुविधा है, तो अपनी की बाइंडिंग को अपडेट करें संवेदनशील कार्रवाई की जा सकती है, जिसकी वजह से उपयोगकर्ता के सेव किए गए वर्शन से समस्या हो सकती है. बंद करें जब मुमकिन हो, तब मौजूदा कंट्रोल के आईडी बदलना.

रीमैपिंग की सुविधा

Google Play Games on PC पर, कीबोर्ड कंट्रोल को कुंजी के आधार पर रीमैप किया जा सकता है बाइंडिंग, जो आपका गेम, इनपुट SDK टूल का इस्तेमाल करके उपलब्ध कराता है. यह ज़रूरी नहीं है और पूरी तरह से बंद किया जा सकता है. उदाहरण के लिए, हो सकता है कि आप अपना खुद का कीबोर्ड उपलब्ध कराना चाहें इंटरफ़ेस रीमैपिंग. अपने गेम के लिए रीमैपिंग को बंद करने के लिए, आपको सिर्फ़ यह बताना होगा कि आपके InputMap के लिए रीमैपिंग विकल्प अक्षम है (देखें ज़्यादा जानकारी के लिए इनपुट मैप बनाएं).

इस सुविधा को ऐक्सेस करने के लिए, उपयोगकर्ताओं को ओवरले खोलना होगा. इसके बाद, 'कार्रवाई' पर क्लिक करना होगा उन्हें रीमैप करना है. हर इवेंट को रीमैप करने के बाद, Google Play Games on PC को मैप करें उपयोगकर्ता का रीमैप किया गया हर कंट्रोल, उन डिफ़ॉल्ट कंट्रोल के लिए सेट किया जाता है जिन्हें आपके गेम में लागू करना चाहिए पाएं, ताकि आपके गेम को खिलाड़ी के रीमैपिंग के बारे में जानकारी न रहे. आपने लोगों तक पहुंचाया मुफ़्त में कीबोर्ड कंट्रोल दिखाने के लिए इस्तेमाल होने वाली ऐसेट को विकल्प के तौर पर अपडेट कर सकता है इवेंट को रीमैप करने के लिए कॉलबैक जोड़कर, अपने गेम को फिर से मैप करें.

Google Play Games on PC हर उपयोगकर्ता के लिए, कंट्रोल को रीमैप किया गया स्थानीय तौर पर स्टोर करता है, इससे सभी गेमिंग सेशन पर कंट्रोल बना रहता है. यह जानकारी सेव की गई है का उपयोग करता है और मोबाइल अनुभव को प्रभावित नहीं करता है. जब उपयोगकर्ता Google Play Games on PC को अनइंस्टॉल या फिर से इंस्टॉल करता है, तब कंट्रोल डेटा मिट जाता है. यह डेटा, एक से ज़्यादा पीसी डिवाइसों पर लगातार नहीं दिखता.

अपने गेम में रीमैपिंग की सुविधा का इस्तेमाल करने के लिए, इन पाबंदियों से बचें:

रीमैपिंग से जुड़ी पाबंदियां

अगर कुंजी बाइंडिंग में कोई भी चीज़ शामिल है, तो आपके गेम में रीमैप करने की सुविधाएं बंद की जा सकती हैं नीचे दिए गए मामलों में:

• एक से ज़्यादा कुंजी वाला InputActions बटन, जिसे कार्रवाई बदलने वाली कुंजी + a से नहीं बनाया गया है गैर-मॉडिफ़ायर कुंजी. उदाहरण के लिए, Shift + A मान्य है लेकिन A + B, Ctrl + Alt या Shift + A + Tab को नहीं.
• InputMap में InputActions, InputGroups या InputContexts शामिल है इस्तेमाल करें.

रीमैपिंग की सीमाएं

रीमैप करने के लिए, की बाइंडिंग डिज़ाइन करते समय इन बातों का ध्यान रखें सीमाएं:

• कुंजी के कॉम्बिनेशन के लिए फिर से मैप नहीं किया जा सकता. उदाहरण के लिए, उपयोगकर्ता ये काम नहीं कर सकते Shift + A को Ctrl + B या A को Shift + A पर फिर से मैप करें.
• माउस बटन के साथ InputActions के लिए रीमैपिंग समर्थित नहीं है. इसके लिए उदाहरण के लिए, Shift + राइट क्लिक को रीमैप नहीं किया जा सकता.

Google Play Games on PC के एम्युलेटर पर, कुंजियों को फिर से मैप करने की सुविधा का इस्तेमाल करें

Google Play Games on PC एम्युलेटर में, रीमैप करने की सुविधा को किसी भी समय चालू किया जा सकता है निम्न adb आदेश जारी करके:

adb shell dumpsys input_mapping_service --set RemappingFlagValue true

ओवरले बदल गया है, जैसा कि नीचे दी गई इमेज में है:

SDK टूल जोड़ें

अपने डेवलपमेंट प्लैटफ़ॉर्म के हिसाब से इनपुट SDK टूल इंस्टॉल करें.

Java और Kotlin

अपनी डिपेंडेंसी जोड़कर Java या Kotlin के लिए, इनपुट SDK टूल पाएं मॉड्यूल-लेवल की build.gradle फ़ाइल:

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

यूनिटी

इनपुट SDK टूल, कई डिपेंडेंसी वाला एक स्टैंडर्ड Unity पैकेज है.

सभी डिपेंडेंसी के साथ पैकेज इंस्टॉल करना ज़रूरी है. इसके कई तरीके हैं पैकेज इंस्टॉल करने के लिए.

.unitypackage को इंस्टॉल करें

इनपुट SDK यूनिटीपैकेज फ़ाइल डाउनलोड करें काम करती हैं. .unitypackage को इंस्टॉल करने के लिए, ऐसेट > पैकेज आयात करें > कस्टम पैकेज और डाउनलोड की गई फ़ाइल को खोजना.

UPM का इस्तेमाल करके इंस्टॉल करें

इसके अलावा, आप पैकेज को इंस्टॉल करने के लिए, इसके ज़रिए, Unity's Package Manager .tgz डाउनलोड करना और इसकी डिपेंडेंसी इंस्टॉल करना:

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

OpenUPM का इस्तेमाल करके इंस्टॉल करना

आप इसका उपयोग करके पैकेज इंस्टॉल कर सकते हैं OpenUPM.

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

सैंपल गेम

इनपुट SDK के साथ एकीकृत करने के तरीकों के उदाहरणों के लिए, देखें एजीडीके टनल Kotlin या Java गेम के लिए और Trivial Kart Unity गेम के लिए.

की बाइंडिंग जनरेट करें

InputMap बनाकर और उसे किसी InputMappingProvider. नीचे दिए गए उदाहरण में 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

अपनी इनपुट कार्रवाइयां तय करें

InputAction क्लास का इस्तेमाल, किसी गेम में की या के कॉम्बिनेशन को मैप करने के लिए किया जाता है कार्रवाई. सभी InputActions में InputActions के यूनीक आईडी होने चाहिए.

अगर आप रीमैपिंग का समर्थन कर रहे हैं, तो आप तय कर सकते हैं कि InputActions क्या हो सकता है रीमैप किया गया. अगर आपके गेम में रीमैपिंग की सुविधा काम नहीं करती है, तो आपको रीमैपिंग सेट करनी चाहिए आपके सभी InputActions के लिए विकल्प बंद है, लेकिन इनपुट SDK टूल यदि आप रीमैपिंग का समर्थन नहीं करते हैं तो InputMap.

इस उदाहरण में, स्पेस बटन को Drive के ऐक्शन से मैप किया गया है.

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

कार्रवाइयों से माउस के इनपुट को भी दिखाया जा सकता है. यह उदाहरण लेफ़्ट-क्लिक को इस पर सेट करता है: ले जाएं कार्रवाई:

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

कुंजी संयोजन एक से अधिक कुंजी कोड को InputAction. इस उदाहरण में, space + shift को इससे मैप किया गया है Turbo कार्रवाई करने पर, यह तब भी काम करता है, जब Space को Drive के साथ मैप किया गया हो.

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

इनपुट SDK टूल की मदद से, माउस और कुंजी बटन को एक साथ मिलाया जा सकता है सिर्फ़ एक कार्रवाई का इस्तेमाल करें. इस उदाहरण में बताया गया है कि Shift और राइट-क्लिक करें इस सैंपल गेम में एक साथ दबाने से वेपॉइंट जुड़ जाता है:

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

InputAction में ये फ़ील्ड शामिल हैं:

• ActionLabel: इस कार्रवाई को दिखाने के लिए यूज़र इंटरफ़ेस (यूआई) में दिखाई गई स्ट्रिंग. स्थानीय भाषा के मुताबिक अनुवाद अपने-आप नहीं होता. इसलिए, सभी स्थानीय भाषा के अनुसार सामने.
• InputControls: इस कार्रवाई में इस्तेमाल किए जाने वाले इनपुट कंट्रोल के बारे में बताता है. कॉन्टेंट बनाने ओवरले में एक जैसे ग्लिफ़ के हिसाब से मैप को कंट्रोल करता है.
• InputActionId: InputIdentifier ऑब्जेक्ट, जिसमें नंबर आईडी और वर्शन सेव है InputAction की मेट्रिक (ज़्यादा जानकारी के लिए ट्रैकिंग कुंजी आईडी देखें) जानकारी).
• InputRemappingOption: InputEnums.REMAP_OPTION_ENABLED में से एक या InputEnums.REMAP_OPTION_DISABLED. यह बताता है कि कार्रवाई को रीमैप करें. अगर आपके गेम में रीमैप करने की सुविधा काम नहीं करती, तो इस फ़ील्ड को छोड़ दें या उसे अक्षम सेट कर सकते हैं.
• RemappedInputControls: रीड-ओनली InputControls ऑब्जेक्ट का इस्तेमाल इवेंट को रीमैप करने के लिए, उपयोगकर्ता की ओर से सेट की गई रीमैप की गई कुंजी (इसका इस्तेमाल किया जाता है इवेंट को रीमैप करने पर सूचना पाना).

InputControls किसी कार्रवाई से जुड़े इनपुट दिखाता है और इसमें ये फ़ील्ड शामिल होते हैं::

• AndroidKeycodes: कीबोर्ड इनपुट को दिखाने वाले पूर्णांकों की सूची है किसी कार्रवाई से जुड़ा होता है. इन्हें इसमें परिभाषित किया गया है: KeyEvent क्लास या Unity के लिए AndroidKeycode क्लास.
• MouseActions: माउस इनपुट को दिखाने वाली MouseAction वैल्यू की सूची है इस कार्रवाई से जुड़ा हुआ है.

अपने इनपुट ग्रुप तय करें

InputActions को InputGroups का इस्तेमाल करके, लॉजिकल तरीके से होने वाली कार्रवाइयों के साथ ग्रुप किया जाता है, ताकि ओवरले में खोज करने की सुविधा को बेहतर बनाने के साथ-साथ, इसे कंट्रोल करने के लिए भी किया जा सकता है. हर आपके गेम के सभी InputGroups में InputGroup आईडी का यूनीक होना ज़रूरी है.

अपनी इनपुट कार्रवाइयों को ग्रुप में व्यवस्थित करके, खिलाड़ी के लिए ये काम करना आसान हो जाता है उनके मौजूदा संदर्भ के हिसाब से सही की-बाइंडिंग ढूंढें.

अगर आप रीमैपिंग का समर्थन कर रहे हैं, तो आप तय कर सकते हैं कि InputGroups क्या हो सकता है रीमैप किया गया. अगर आपके गेम में रीमैपिंग की सुविधा काम नहीं करती है, तो आपको रीमैपिंग सेट करनी चाहिए आपके सभी InputGroups के लिए विकल्प बंद है, लेकिन इनपुट SDK टूल यदि आप रीमैपिंग का समर्थन नहीं करते हैं तो 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
);

नीचे दिए गए उदाहरण में, सड़क के कंट्रोल और मेन्यू कंट्रोल को दिखाया गया है ओवरले में इनपुट ग्रुप:

InputGroup में ये फ़ील्ड होते हैं:

• GroupLabel: ओवरले में दिखाई जाने वाली स्ट्रिंग है. इसका इस्तेमाल इन कामों के लिए किया जा सकता है कार्रवाइयों के सेट को लॉजिकल तरीके से ग्रुप करें. यह स्ट्रिंग अपने-आप नहीं बदलती है स्थानीय जगह के अनुसार.
• InputActions: InputAction ऑब्जेक्ट की ऐसी सूची जिसे आपने पिछले आइटम में तय किया था चरण पूरा करें. ये सभी कार्रवाइयां, ग्रुप के शीर्षक के नीचे विज़ुअल तौर पर दिखती हैं.
• InputGroupId: InputIdentifier ऑब्जेक्ट, जिसमें नंबर आईडी और InputGroup का वर्शन है. इनके लिए ट्रैकिंग कुंजी आईडी देखें ज़्यादा जानकारी देखें.
• InputRemappingOption: InputEnums.REMAP_OPTION_ENABLED में से एक या InputEnums.REMAP_OPTION_DISABLED. अगर यह नीति बंद है, तो सभी InputAction इस ग्रुप से जुड़े ऑब्जेक्ट को फिर से मैप करने की सुविधा बंद हो जाएगी. भले ही, वे और इसके रीमैपिंग विकल्प चालू हो जाए. अगर यह नीति चालू की गई है, तो इसमें इस ग्रुप को तब तक फिर से मैप किया जा सकता है, जब तक कि उस व्यक्ति ने इसे बंद न कर दिया हो कार्रवाइयां.

इनपुट का कॉन्टेक्स्ट तय करें

InputContexts, आपके गेम को इनके लिए कीबोर्ड कंट्रोल के अलग सेट का इस्तेमाल करने की अनुमति देता है अपने गेम के अलग-अलग सीन. उदाहरण के लिए:

• मेन्यू में नेविगेट करने और आइटम को एक जगह से दूसरी जगह ले जाने के लिए, इनपुट के अलग-अलग सेट तय किए जा सकते हैं को ट्रैक करने की सुविधा मिलती है.
• एक जगह से दूसरी जगह जाने के तरीके के आधार पर, इनपुट के अलग-अलग सेट तय किए जा सकते हैं जैसे कि ड्राइविंग बनाम पैदल चलना.
• अपनी मौजूदा स्थिति के आधार पर, इनपुट के अलग-अलग सेट तय किए जा सकते हैं गेम, जैसे कि सिर्फ़ एक लेवल खेलना.

InputContexts का इस्तेमाल करते समय, ओवरले में पहले कॉन्टेक्स्ट के ग्रुप दिखाए जाते हैं इस्तेमाल किया जा रहा है. इस व्यवहार को चालू करने के लिए, setInputContext() पर कॉल करके संदर्भ भी शामिल करें. यह इमेज इस व्यवहार को दिखाता है: "ड्राइविंग" में सड़क के कंट्रोल कार्रवाइयों को ओवरले में सबसे ऊपर दिखाया जाता है. "स्टोर" खोलते समय मेन्यू, "मेन्यू कंट्रोल" कार्रवाइयां, ओवरले पर सबसे ऊपर दिखती हैं.

ये ओवरले अपडेट पाने के लिए, यहां एक अलग InputContext सेट किया जाता है अलग-अलग पॉइंट सेट करें. ऐसा करने के लिए:

1. InputGroups का इस्तेमाल करके, लॉजिकल तरीके से बताई गई कार्रवाइयों की मदद से अपने InputActions का ग्रुप बनाएं
2. इन InputGroups को InputContext को असाइन करें. ऐसा इसके अलग-अलग हिस्सों के लिए किया जाएगा आपका गेम

जो InputGroups एक जैसे हैं, उनमेंInputContext कॉन्फ़्लिक्टिंग नहीं हो सकती InputActions जहां एक ही कुंजी का इस्तेमाल किया जाता है. हर किसी को असाइन करना बेहतर है. InputGroup से एक InputContext.

यह सैंपल कोड, InputContext लॉजिक के बारे में बताता है:

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 में ये फ़ील्ड होते हैं:

• LocalizedContextLabel: इस स्ट्रिंग से उन ग्रुप की जानकारी मिलती है जो संदर्भ.
• InputContextId: InputIdentifier ऑब्जेक्ट, जिसमें नंबर आईडी और वर्शन सेव है InputContext की मेट्रिक (ज़्यादा जानकारी के लिए ट्रैकिंग कुंजी आईडी देखें) जानकारी).
• ActiveGroups: इस्तेमाल किए जाने वाले और सबसे ऊपर दिखाए जाने वाले InputGroups की सूची का इस्तेमाल करें.

इनपुट मैप बनाएं

InputMap, इसमें उपलब्ध सभी InputGroup ऑब्जेक्ट का कलेक्शन होता है इस तरह के गेम में, वे सभी InputAction ऑब्जेक्ट शामिल होते हैं जिनकी एक खिलाड़ी उम्मीद कर सकता है करना.

की बाइंडिंग की रिपोर्ट करते समय, आप इन सभी के साथ एक InputMap बनाते हैं आपके गेम में InputGroups का इस्तेमाल किया गया.

अगर आपके गेम में रीमैपिंग की सुविधा काम नहीं करती, तो रीमैपिंग के विकल्प को बंद कर दें और आरक्षित कुंजियां खाली हैं.

नीचे दिया गया उदाहरण एक InputMap बनाता है, जिसका इस्तेमाल 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 में ये फ़ील्ड होते हैं:

• InputGroups: आपके गेम से रिपोर्ट किए गए InputGroups. ये ग्रुप हैं: ओवरले में क्रम से दिखाया जाता है, जब तक कि setInputContext() को कॉल करने की सुविधा इस्तेमाल करें.
• MouseSettings: MouseSettings ऑब्जेक्ट से पता चलता है कि माउस की संवेदनशीलता को एडजस्ट किया जा सकता है और यह कि माउस y ऐक्सिस पर उलटा हो.
• InputMapId: InputIdentifier ऑब्जेक्ट, जिसमें इसका नंबर आईडी और वर्शन सेव है InputMap (ज़्यादा जानकारी के लिए ट्रैकिंग कुंजी आईडी देखें जानकारी).
• InputRemappingOption: InputEnums.REMAP_OPTION_ENABLED में से एक या InputEnums.REMAP_OPTION_DISABLED. तय करता है कि रीमैपिंग सुविधा चालू किया गया.
• ReservedControls: InputControls की वह सूची जिसे उपयोगकर्ता नहीं कर पाएंगे रीमैप करें.

ट्रैक कुंजी के आईडी

InputAction, InputGroup, InputContext, और InputMap ऑब्जेक्ट में एक InputIdentifier ऑब्जेक्ट जिसमें यूनीक नंबर आईडी और स्ट्रिंग वर्शन आईडी सेव होता है. ऑब्जेक्ट के स्ट्रिंग वर्शन को ट्रैक करना ज़रूरी नहीं है. हालांकि, हमारा सुझाव है कि आप इन्हें ट्रैक करें आपके InputMap के वर्शन. अगर स्ट्रिंग वर्शन नहीं दिया गया है, तो स्ट्रिंग खाली है. InputMap ऑब्जेक्ट के लिए, स्ट्रिंग का वर्शन होना ज़रूरी है.

नीचे दिया गया उदाहरण InputActions को एक स्ट्रिंग वर्शन असाइन करता है या 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

इसमें मौजूद सभी InputActions के लिए, InputAction ऑब्जेक्ट नंबर आईडी यूनीक होने चाहिए InputMap. इसी तरह, सभी यूआरएल के लिए InputGroup ऑब्जेक्ट आईडी यूनीक होने चाहिए InputMap में InputGroups. नीचे दिए गए उदाहरण में, अपने ऑब्जेक्ट के यूनीक आईडी ट्रैक करने के लिए 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 में ये फ़ील्ड होते हैं:

• UniqueId: एक यूनीक नंबर आईडी, जो दिए गए इनपुट के सेट की साफ़ तौर पर पहचान करने के लिए सेट किया जाता है डेटा को इकट्ठा और इस्तेमाल करने के लिए किया जा सकता है.
• VersionString: वर्शन की ऐसी स्ट्रिंग जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है इनपुट डेटा में बदलाव के दो वर्शन के बीच इनपुट डेटा का.

इवेंट को फिर से मैप करने पर सूचना पाएं (ज़रूरी नहीं)

इसमें इस्तेमाल की जा रही कुंजियों के बारे में जानकारी पाने के लिए, रीमैप इवेंट से जुड़ी सूचनाएं पाएं आपका गेम. इससे आपका गेम, गेम स्क्रीन पर दिखने वाली ऐसेट को अपडेट कर पाएगा इसका इस्तेमाल, ऐक्शन कंट्रोल दिखाने के लिए किया जाता है.

निम्न चित्र इस व्यवहार का एक उदाहरण दिखाता है, जहां G, P, और S से J, X बटन और T, दोनों गेम के यूज़र इंटरफ़ेस (यूआई) एलिमेंट इस तरह अपडेट होते हैं: उपयोगकर्ता की सेट की गई कुंजियां दिखती हैं.

यह सुविधा, InputRemappingListener को रजिस्टर करने पर मिलती है कॉलबैक. इस सुविधा को लागू करने के लिए, InputRemappingListener इंस्टेंस:

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 को सूचना दी जाती है रीमैप किए गए उपयोगकर्ता के सेव किए गए कंट्रोल और हर बार उपयोगकर्ता अपनी कुंजियों को दोबारा मैप करने के बाद उन्हें उपलब्ध कराता है.

प्रोसेस शुरू करना

अगर InputContexts का इस्तेमाल किया जा रहा है, तो हर किसी नए सीन पर जाना. इसमें, आपके शुरुआती वाक्य के लिए इस्तेमाल किया गया पहला कॉन्टेक्स्ट भी शामिल है सीन. रजिस्टर करने के बाद आपको InputContext सेट करना होगा InputMap.

अगर आप इवेंट को रीमैप करने की सूचना पाने के लिए, InputRemappingListeners का इस्तेमाल कर रहे हैं रजिस्टर करने से पहले अपने InputRemappingListener को रजिस्टर करें InputMappingProvider ऐसा न करने पर, हो सकता है कि आपका गेम इस दौरान अहम इवेंट से न छूटे लॉन्च का समय.

नीचे दिया गया सैंपल, एपीआई को शुरू करने का तरीका बताता है:

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

व्यवस्थित करें

अपने InputMappingProvider इंस्टेंस और किसी भी InputRemappingListener का रजिस्ट्रेशन रद्द करें ऐसे मामले जब आपका गेम बंद हो जाता है, लेकिन इनपुट SDK टूल स्मार्ट है बिना किसी रुकावट के, संसाधनों को लीक होने से बचाने के लिए काफ़ी है:

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

टेस्ट

आपके पास मैन्युअल तरीके से ओवरले से प्लेयर का अनुभव या adb शेल की जानकारी देखें का इस्तेमाल किया जा सकता है.

Google Play Games on PC एम्युलेटर, आपके इनपुट मैप के सटीक होने की जांच करता है सामान्य गड़बड़ियों के ख़िलाफ़ है. डुप्लीकेट यूनीक आईडी जैसे मामलों के लिए, मैप इनपुट करने या रीमैपिंग के नियमों को पूरा न करने (अगर रीमैपिंग चालू है), तो ओवरले एक गड़बड़ी का मैसेज दिखाता है, जैसा कि यहां दिखाया गया है: अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

कमांड लाइन पर adb का इस्तेमाल करके, पुष्टि करें कि आपने इनपुट SDK टूल लागू किया है. वर्तमान इनपुट मैप प्राप्त करने के लिए, निम्न adb shell आदेश का उपयोग करें (बदलें आपके गेम के नाम के साथ 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
}

स्थानीय भाषा के अनुसार

इनपुट SDK टूल, Android के स्थानीय भाषा के अनुसार सिस्टम का इस्तेमाल नहीं करता. बतौर नतीजे के तौर पर, InputMap सबमिट करते समय आपको स्थानीय भाषा में स्ट्रिंग उपलब्ध करानी होगी. आपने लोगों तक पहुंचाया मुफ़्त में गेम इंजन के लोकलाइज़ेशन सिस्टम का इस्तेमाल भी किया जा सकता है.

प्रोगार्ड

अपने गेम को छोटा करने के लिए ProGuard का इस्तेमाल करते समय, अपने ProGuard कॉन्फ़िगरेशन फ़ाइल, ताकि यह पक्का किया जा सके कि SDK टूल के आपके फ़ाइनल पैकेज:

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

अगला कदम क्या है

इनपुट SDK टूल को अपने गेम में इंटिग्रेट करने के बाद, गेम जारी रखा जा सकता है Google Play Games on PC की बाकी सभी ज़रूरी शर्तों को पूरा करना होगा. ज़्यादा जानकारी के लिए, Google Play Games on PC का इस्तेमाल शुरू करना लेख पढ़ें.