Mauseingabe

In diesem Thema wird die Mauseingabe für Google Play Spiele auf dem PC für Spiele, bei denen der Eingabeübersetzungsmodus kein ideales Spielererlebnis bietet.

PC-Spieler haben normalerweise eine Tastatur und eine Maus anstelle eines Touchscreens. sollten Sie sich überlegen, ob Ihr Spiel Mauseingaben unterstützt. Standardmäßig Google Play Spiele auf dem PC wandelt jeden Klick auf der linken Seite in ein einzelnes virtuelles Tippereignis. Dies wird als „Eingabeübersetzungsmodus“ bezeichnet.

Obwohl Ihr Spiel durch diesen Modus funktioniert wird, müssen Sie nur PC-Spielern ein nativ anmutendes Spielerlebnis bieten. Dafür empfehlen wir, implementieren Sie Folgendes:

• Hover-Zustände für Kontextmenüs, anstatt Aktionen bei gedrückter Maustaste gedrückt zu halten
• Klicke mit der rechten Maustaste, um alternative Aktionen anzuzeigen, die durch langes Drücken oder in einem Kontext erfolgen Menü
• Mauserkennung für First- oder Third-Person-Actionspiele anstelle von Drücken und Drag-Event

Zur Unterstützung von auf PCs üblichen UI-Mustern müssen Sie die Eingabe deaktivieren Übersetzungsmodus.

Die Eingabeverarbeitung für Google Play Spiele auf dem PC ist identisch mit der von ChromeOS: Die Änderungen, die PCs unterstützen, um dein Spiel für alle Android-Spieler zu verbessern.

Eingabeübersetzungsmodus deaktivieren

Gehen Sie in der Datei AndroidManifest.xml so vor: deklarieren: android.hardware.type.pc-Funktion. Das bedeutet, dass dein Spiel PC-Hardware verwendet und die Eingabeübersetzung deaktiviert ist . Wenn du required="false" hinzufügst, kann dein Spiel auf Smartphones und Tablets ohne Maus installiert werden können. Beispiel:

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

Die Produktionsversion von Google Play Spiele auf dem PC wird zur richtigen Version wenn ein Spiel gestartet wird. Bei Ausführung im Entwickleremulator müssen Sie Klicken Sie mit der rechten Maustaste auf das Symbol in der Taskleiste, wählen Sie Developer Options (Entwickleroptionen) aus und klicken Sie dann PC-Modus(KiwiMouse) verwenden, um unformatierte Mauseingaben zu empfangen.

Danach wird die Mausbewegung von View.onGenericMotionEvent mit der Quelle SOURCE_MOUSE erfasst. was darauf hinweist, dass es sich um ein Mausereignis handelt.

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

Weitere Informationen zur Verarbeitung der Mauseingabe finden Sie in der ChromeOS-Dokumentation

Mausbewegungen verarbeiten

Wenn Sie Mausbewegungen erkennen möchten, hören Sie sich ACTION_HOVER_ENTER, ACTION_HOVER_EXIT und ACTION_HOVER_MOVE Ereignisse.

Diese Funktion eignet sich am besten, um zu erkennen, wie Nutzende der Mauszeiger auf Schaltflächen oder Spiel, bei dem ein Hinweisfeld angezeigt oder ein Mouseover-Zustand implementiert werden kann um anzugeben, was ein Spieler auswählen wird. Beispiel:

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

Maustasten handhaben

PCs verfügen schon lange über die linke und die rechte Maustaste, wodurch interaktive Elemente primäre und sekundäre Aktionen. Tippen Sie in einem Spiel auf Aktionen wie Tippen auf ein am besten einem Linksklick zugeordnet, wo Touch- und andere Elemente Warteschleifenaktionen fühlt sich am mit der rechten Maustaste. Bei Echtzeit-Strategiespielen gibt es klicken Sie mit der linken Maustaste, um ein Element auszuwählen, und klicken Sie mit der rechten Maustaste, um es zu verschieben. Ego-Shooter weisen möglicherweise primäre und sekundäre Fire-to-Left- und Rechtsklick-Taste. Ein Endlos-Runner könnte klicken Sie mit der linken Maustaste, um zu springen, und mit der rechten Maustaste, um zu springen. Wir haben keine Unterstützung hinzugefügt für das Middle-Click-Ereignis.

Verwende für das Drücken von Tasten ACTION_DOWN und ACTION_UP. Verwenden Sie dann getActionButton, um zu ermitteln, welche Schaltfläche die Aktion ausgelöst hat, oder getButtonState, um den Status aller Schaltflächen abzurufen.

In diesem Beispiel wird ein enum-Wert verwendet, um das Ergebnis eines getActionButton:

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

In diesem Beispiel wird die Aktion ähnlich wie die Hover-Ereignisse behandelt:

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

Scrollen mit dem Mausrad

Wir empfehlen, zum Zoomen das Scrollrad der Maus anstelle von Auseinander- und Zusammenziehen zu verwenden. Touch-Gesten verwenden oder Scrollbereiche berühren und ziehen.

Zum Lesen der Scrollrad-Werte warten Sie auf das ACTION_SCROLL-Ereignis. Das Delta da der letzte Frame mit getAxisValue und AXIS_VSCROLL abgerufen werden kann. für den vertikalen Versatz und AXIS_HSCROLL für den horizontalen Versatz. Beispiel:

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

Mauseingabe erfassen

Einige Spiele benötigen die volle Kontrolle über den Mauszeiger, z. B. 1. oder 3. Actionspiele für Personen, bei denen Mausbewegungen der Kamera zugeordnet werden. Zu nehmen exklusive Steuerung der Maus: View.requestPointerCapture() aufrufen.

requestPointerCapture() funktioniert nur, wenn die Ansichtshierarchie mit Ihren fokussiert ist. Aus diesem Grund können Sie keine Zeigeraufnahme in der onCreate-Callback. Sie sollten entweder warten, bis eine Spielerinteraktion erfasst wird, den Mauszeiger (z. B. beim Interagieren mit dem Hauptmenü) oder die Funktion onWindowFocusChanged Callback des Nutzers an. Beispiel:

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

Von requestPointerCapture() erfasste Ereignisse werden an die fokussierbare Ansicht weitergeleitet, OnCapturedPointerListener. Beispiel:

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

Um exklusive Mausaufnahmen zu veröffentlichen, etwa, damit Spieler Pausemenü öffnen: View.releasePointerCapture() aufrufen