इस पेज का अनुवाद Cloud Translation API से किया गया है.

माउस इनपुट

इस विषय में, पीसी पर Google Play Games के लिए माउस इनपुट को लागू करने का तरीका बताया गया है. ऐसा उन गेम के लिए किया जाता है जिनमें इनपुट का अनुवाद करने वाले मोड से, खिलाड़ी को बेहतर अनुभव नहीं मिलता.

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

इस मोड की मदद से, कुछ बदलाव करके आपके गेम को काम करने लायक बनाया जा सकता है. हालांकि, इससे पीसी पर गेम खेलने वाले लोगों को नैटिव गेम जैसा अनुभव नहीं मिलता. इसके लिए, हमारा सुझाव है कि आप नीचे दिया गया तरीका अपनाएं:

दबाकर रखने की कार्रवाइयों के बजाय, कॉन्टेक्स्ट मेन्यू के लिए कर्सर घुमाने की सुविधा
दबाकर रखने या संदर्भ मेन्यू में होने वाली अन्य कार्रवाइयों के लिए, राइट क्लिक करें
प्रेस और खींचें और छोड़ें इवेंट के बजाय, फ़र्स्ट या थर्ड पर्सन ऐक्शन गेम के लिए माउसलूक

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

Google Play Games on PC के लिए इनपुट मैनेज करने की सुविधा, ChromeOS डिवाइसों पर दी गई जानकारी जैसी ही है. पीसी पर काम करने वाले बदलावों से, सभी Android प्लेयर के लिए आपके गेम को बेहतर बनाया जा सकता है.

इनपुट का अनुवाद करने की सुविधा बंद करना

अपनी AndroidManifest.xml फ़ाइल में, android.hardware.type.pc सुविधा का एलान करें. इससे पता चलता है कि आपका गेम पीसी हार्डवेयर का इस्तेमाल करता है और इनपुट का अनुवाद करने वाले मोड को बंद करता है. इसके अलावा, required="false" जोड़ने से यह पक्का करने में मदद मिलती है कि आपका गेम, माउस के बिना भी फ़ोन और टैबलेट पर इंस्टॉल किया जा सकता है. उदाहरण के लिए:

<manifest ...>
  <uses-feature
      android:name="android.hardware.type.pc"
      android:required="false" />
  ...
</manifest>

Google Play Games on PC का प्रोडक्शन वर्शन, गेम लॉन्च होने पर सही मोड पर स्विच हो जाता है. डेवलपर एमुलेटर में चलाते समय, आपको टास्क बार आइकॉन पर दायां क्लिक करना होगा. इसके बाद, डेवलपर के विकल्प चुनें. इसके बाद, माउस का रॉ इनपुट पाने के लिए, पीसी मोड(KiwiMouse) चुनें.

संदर्भ मेन्यू में चुने गए "पीसी मोड(KiwiMouse)" का स्क्रीनशॉट

ऐसा करने के बाद, View.onजेनेरिकMotionEvent से माउस की गतिविधि की रिपोर्ट मिलती है. सोर्स SOURCE_MOUSE से पता चलता है कि यह एक माउस इवेंट है.

KotlinJava

gameView.setOnGenericMotionListener { _, motionEvent ->
    var handled = false
    if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
        // handle the mouse event here
        handled = true
    }
    handled
}

gameView.setOnGenericMotionListener((view, motionEvent) -> {
    if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
        // handle the mouse event here
        return true;
    }
    return false;
});

माउस इनपुट को मैनेज करने के बारे में ज़्यादा जानने के लिए, ChromeOS दस्तावेज़ देखें.

माउस को घुमाना

माउस की मूवमेंट का पता लगाने के लिए, ACTION_HOVER_ENTER, ACTION_HOVER_EXIT, और ACTION_HOVER_MOVE इवेंट को सुनें.

इसका सबसे अच्छा इस्तेमाल, गेम में बटन या ऑब्जेक्ट पर कर्सर घुमाने वाले उपयोगकर्ता का पता लगाने के लिए किया जाता है. इससे आपको खिलाड़ी के चुने जाने वाले आइटम को हाइलाइट करने के लिए, हिंट बॉक्स दिखाने या माउस घुमाने की स्थिति लागू करने का मौका मिलता है. उदाहरण के लिए:

KotlinJava

gameView.setOnGenericMotionListener { _, motionEvent ->
   var handled = false
   if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
       when(motionEvent.action) {
           MotionEvent.ACTION_HOVER_ENTER -> Log.d("MA", "Mouse entered at ${motionEvent.x}, ${motionEvent.y}")
           MotionEvent.ACTION_HOVER_EXIT -> Log.d("MA", "Mouse exited at ${motionEvent.x}, ${motionEvent.y}")
           MotionEvent.ACTION_HOVER_MOVE -> Log.d("MA", "Mouse hovered at ${motionEvent.x}, ${motionEvent.y}")
       }
       handled = true
   }

   handled
}

gameView.setOnGenericMotionListener((view, motionEvent) -> {
    if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
        switch (motionEvent.getAction()) {
            case MotionEvent.ACTION_HOVER_ENTER:
                Log.d("MA", "Mouse entered at " + motionEvent.getX() + ", " + motionEvent.getY());
                break;
            case MotionEvent.ACTION_HOVER_EXIT:
                Log.d("MA", "Mouse exited at " + motionEvent.getX() + ", " + motionEvent.getY());
                break;
            case MotionEvent.ACTION_HOVER_MOVE:
                Log.d("MA", "Mouse hovered at " + motionEvent.getX() + ", " + motionEvent.getY());
                break;
        }
        return true;
    }
    return false;
});

माउस के बटन इस्तेमाल करना

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

बटन दबाने की कार्रवाई को मैनेज करने के लिए, ACTION_DOWN और ACTION_UP का इस्तेमाल करें. इसके बाद, यह तय करने के लिए कि किस बटन ने कार्रवाई को ट्रिगर किया है, getActionButton का इस्तेमाल करें. इसके अलावा, सभी बटन की स्थिति जानने के लिए, getButtonState का इस्तेमाल करें.

इस उदाहरण में, enum का इस्तेमाल getActionButton का नतीजा दिखाने के लिए किया गया है:

KotlinJava

enum class MouseButton {
   LEFT,
   RIGHT,
   UNKNOWN;
   companion object {
       fun fromMotionEvent(motionEvent: MotionEvent): MouseButton {
           return when (motionEvent.actionButton) {
               MotionEvent.BUTTON_PRIMARY -> LEFT
               MotionEvent.BUTTON_SECONDARY -> RIGHT
               else -> UNKNOWN
           }
       }
   }
}

enum MouseButton {
    LEFT,
    RIGHT,
    MIDDLE,
    UNKNOWN;
    static MouseButton fromMotionEvent(MotionEvent motionEvent) {
        switch (motionEvent.getActionButton()) {
            case MotionEvent.BUTTON_PRIMARY:
                return MouseButton.LEFT;
            case MotionEvent.BUTTON_SECONDARY:
                return MouseButton.RIGHT;
            default:
                return MouseButton.UNKNOWN;
        }
    }
}

इस उदाहरण में, कार्रवाई को हॉवर इवेंट की तरह ही मैनेज किया जाता है:

KotlinJava

// Handle the generic motion event
gameView.setOnGenericMotionListener { _, motionEvent ->
   var handled = false
   if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
       when (motionEvent.action) {
           MotionEvent.ACTION_BUTTON_PRESS -> Log.d(
               "MA",
               "${MouseButton.fromMotionEvent(motionEvent)} pressed at ${motionEvent.x}, ${motionEvent.y}"
           )
           MotionEvent.ACTION_BUTTON_RELEASE -> Log.d(
               "MA",
               "${MouseButton.fromMotionEvent(motionEvent)} released at ${motionEvent.x}, ${motionEvent.y}"
           )
       }
       handled = true
   }

   handled
}

gameView.setOnGenericMotionListener((view, motionEvent) -> {
    if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
        switch (motionEvent.getAction()) {
            case MotionEvent.ACTION_BUTTON_PRESS:
                Log.d("MA", MouseButton.fromMotionEvent(motionEvent) + " pressed at " + motionEvent.getX() + ", " + motionEvent.getY());
                break;
            case MotionEvent.ACTION_BUTTON_RELEASE:
                Log.d("MA", MouseButton.fromMotionEvent(motionEvent) + " released at " + motionEvent.getX() + ", " + motionEvent.getY());
                break;
        }
        return true;
    }
    return false;
});

माउस व्हील से स्क्रोल करने की सुविधा

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

स्क्रोल व्हील की वैल्यू पढ़ने के लिए, ACTION_SCROLL इवेंट को सुनें. डेल्टा, क्योंकि पिछले फ़्रेम को वर्टिकल ऑफ़सेट के लिए AXIS_VSCROLL और हॉरिज़ॉन्टल ऑफ़सेट के लिए AXIS_HSCROLL के साथ getAxisValue का इस्तेमाल करके वापस पाया जा सकता है. उदाहरण के लिए:

KotlinJava

gameView.setOnGenericMotionListener { _, motionEvent ->
   var handled = false
   if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
       when (motionEvent.action) {
           MotionEvent.ACTION_SCROLL -> {
               val scrollX = motionEvent.getAxisValue(MotionEvent.AXIS_HSCROLL)
               val scrollY = motionEvent.getAxisValue(MotionEvent.AXIS_VSCROLL)
               Log.d("MA", "Mouse scrolled $scrollX, $scrollY")
           }
       }
       handled = true
   }
   handled
}

gameView.setOnGenericMotionListener((view, motionEvent) -> {
    if (motionEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
        switch (motionEvent.getAction()) {
            case MotionEvent.ACTION_SCROLL:
                float scrollX = motionEvent.getAxisValue(MotionEvent.AXIS_HSCROLL);
                float scrollY = motionEvent.getAxisValue(MotionEvent.AXIS_VSCROLL);
                Log.d("MA", "Mouse scrolled " + scrollX + ", " + scrollY);
                break;
        }
        return true;
    }
    return false;
});

माउस इनपुट कैप्चर करें

कुछ गेम में माउस कर्सर को पूरी तरह कंट्रोल करना ज़रूरी होता है. जैसे, पहले या तीसरे व्यक्ति के ऐक्शन गेम, जो माउस की गति को कैमरे की गति से मैप करते हैं. माउस का पूरा कंट्रोल पाने के लिए, View.requestPointerCapture() को दबाएं.

requestPointerCapture() सिर्फ़ तब काम करता है, जब आपके व्यू वाली हैरारकी पर फ़ोकस हो. इस वजह से, onCreate कॉलबैक में पॉइंटर कैप्चर हासिल नहीं किया जा सकता. आपको माउस पॉइंटर को कैप्चर करने के लिए, खिलाड़ी के इंटरैक्शन का इंतज़ार करना चाहिए, जैसे कि मुख्य मेन्यू से इंटरैक्ट करते समय या onWindowFocusChanged कॉलबैक का इस्तेमाल करना. उदाहरण के लिए:

KotlinJava

override fun onWindowFocusChanged(hasFocus: Boolean) {
   super.onWindowFocusChanged(hasFocus)

   if (hasFocus) {
       gameView.requestPointerCapture()
   }
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);

    if (hasFocus) {
        View gameView = findViewById(R.id.game_view);
        gameView.requestPointerCapture();
    }
}

requestPointerCapture() से कैप्चर किए गए इवेंट, रजिस्टर किए गए फ़ोकस किए जा सकने वाले व्यू पर भेजे जाते हैं OnCapturedPointerListener. उदाहरण के लिए:

KotlinJava

gameView.focusable = View.FOCUSABLE
gameView.setOnCapturedPointerListener { _, motionEvent ->
    Log.d("MA", "${motionEvent.x}, ${motionEvent.y}, ${motionEvent.actionButton}")
    true
}

gameView.setFocusable(true);
gameView.setOnCapturedPointerListener((view, motionEvent) -> {
    Log.d("MA", motionEvent.getX() + ", " + motionEvent.getY() + ", " + motionEvent.getActionButton());
    return true;
});

माउस कैप्चर को रिलीज़ करने के लिए, View.releasePointerCapture() को दबाएं. इससे, खिलाड़ियों को रोकने के लिए उपलब्ध मेन्यू के साथ इंटरैक्ट करने की अनुमति मिलती है.