Au niveau du système, Android signale les codes d'événement d'entrée des manettes de jeu comme les codes clés Android et les valeurs des axes. Dans votre jeu, vous pouvez recevoir ces codes et des valeurs, et les convertir en actions spécifiques dans le jeu.
Lorsque les joueurs se connectent physiquement ou
associent sans fil une manette de jeu
ses appareils Android, le système détecte automatiquement la manette
en tant que périphérique d'entrée et commence
à signaler ses événements d'entrée. Votre jeu peut recevoir
ces événements d'entrée en implémentant les méthodes de rappel suivantes dans votre classe active
Activity
ou sélectionné View
(vous devez
implémenter les rappels pour Activity
ou
View
, mais pas les deux):
- De
Activity
: <ph type="x-smartling-placeholder">- </ph>
dispatchGenericMotionEvent(android.view. MotionEvent)
Appelées pour traiter les événements de mouvement génériques, tels que les mouvements du joystick.
dispatchKeyEvent(android.view.KeyEvent)
Appelées pour traiter des événements clés, tels qu'une presse ou un communiqué de la manette de jeu ou du bouton directionnel.
- De
View
: <ph type="x-smartling-placeholder">- </ph>
onGenericMotionEvent(android.view.MotionEvent)
Appelées pour traiter les événements de mouvement génériques, tels que les mouvements du joystick.
onKeyDown(int, android.view.KeyEvent)
Appelée pour traiter l'appui sur une touche physique telle qu'une manette de jeu ou Bouton du pavé directionnel.
onKeyUp(int, android.view.KeyEvent)
Appelée pour traiter la libération d'une touche physique telle qu'une manette de jeu ou Bouton du pavé directionnel.
L'approche recommandée consiste à capturer les événements
un objet View
spécifique avec lequel l'utilisateur interagit.
Inspectez les objets suivants fournis par les rappels pour obtenir des informations
sur le type d'événement d'entrée reçu:
KeyEvent
- Objet décrivant une direction
du pavé directionnel et des boutons de la manette de jeu. Les événements clés sont accompagnés d'un
code de touche qui indique le bouton spécifique déclenché, par exemple
DPAD_DOWN
ouBUTTON_A
. Vous pouvez obtenir la valeur code de touche en appelantgetKeyCode()
ou à partir de la touche des rappels d'événement tels queonKeyDown()
MotionEvent
- Objet qui décrit les données saisies par le joystick et le déclencheur d'épaule
mouvements. Les événements de mouvement sont accompagnés d'un code d'action et d'un ensemble
valeurs des axes. Le code d'action spécifie le changement d'état qui s'est produit
comme un joystick en train d'être déplacé. Les valeurs des axes décrivent la position et d'autres
des propriétés de mouvement pour un contrôle physique spécifique, comme
AXIS_X
ouAXIS_RTRIGGER
Vous pouvez obtenir le code d'action en appelantgetAction()
et la valeur de l'axe Appel degetAxisValue()
en cours.
Cette leçon explique comment gérer les entrées des types les plus courants
des commandes physiques (boutons de manette de jeu, pavés directionnels et
joysticks) dans un écran de jeu en appliquant les fonctionnalités
Méthodes de rappel et traitement de View
Objets KeyEvent
et MotionEvent
.
Vérifier qu'une manette de jeu est connectée
Lors du reporting des événements d'entrée, Android ne fait pas la distinction
entre les événements provenant d'une manette qui n'est pas une manette de jeu et les événements qui surviennent
à partir d'une manette de jeu. Par exemple, une action sur l'écran tactile génère une
Événement AXIS_X
qui représente le X
coordonnées de la surface tactile, mais un joystick génère
Événement AXIS_X
qui représente la position X du joystick. Si
que votre jeu se soucie de gérer l'entrée du contrôleur, vous devez d'abord vérifier
que l'événement d'entrée provienne
d'un type de source pertinent.
Pour vérifier qu'un périphérique d'entrée connecté est une manette de jeu, appelez
getSources()
pour obtenir un champ de bits combiné de
types de sources d'entrée compatibles avec cet appareil. Vous pouvez ensuite tester
les champs suivants sont définis:
- Le type de source
SOURCE_GAMEPAD
indique que le périphérique d'entrée est doté de boutons de manette de jeu (par exemple,BUTTON_A
). Notez que cette source n'indique pas strictement si la manette de jeu est dotée de boutons du pavé directionnel, bien que la plupart des manettes de jeu disposent généralement de commandes directionnelles. - Le type de source
SOURCE_DPAD
indique Le périphérique d'entrée est doté de boutons du pavé directionnel (par exemple,DPAD_UP
). - Un type de source de
SOURCE_JOYSTICK
indique que le périphérique d'entrée est doté de clés de commande analogiques (par exemple, joystick qui enregistre les mouvements le long deAXIS_X
etAXIS_Y
).
L'extrait de code suivant montre une méthode d'assistance qui vous permet de vérifier si les périphériques d'entrée connectés sont des manettes de jeu. Si c'est le cas, la méthode récupère les ID des appareils pour les manettes de jeu. Vous pouvez ensuite associer chaque appareil Identifiez un joueur dans votre jeu et traitez les actions du jeu pour chaque joueur associé séparément. Pour savoir comment prendre en charge plusieurs manettes de jeu connectés simultanément sur le même appareil Android, consultez Assurer la compatibilité avec plusieurs manettes de jeu.
Kotlin
fun getGameControllerIds(): List<Int> { val gameControllerDeviceIds = mutableListOf<Int>() val deviceIds = InputDevice.getDeviceIds() deviceIds.forEach { deviceId -> InputDevice.getDevice(deviceId).apply { // Verify that the device has gamepad buttons, control sticks, or both. if (sources and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD || sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK) { // This device is a game controller. Store its device ID. gameControllerDeviceIds .takeIf { !it.contains(deviceId) } ?.add(deviceId) } } } return gameControllerDeviceIds }
Java
public ArrayList<Integer> getGameControllerIds() { ArrayList<Integer> gameControllerDeviceIds = new ArrayList<Integer>(); int[] deviceIds = InputDevice.getDeviceIds(); for (int deviceId : deviceIds) { InputDevice dev = InputDevice.getDevice(deviceId); int sources = dev.getSources(); // Verify that the device has gamepad buttons, control sticks, or both. if (((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) || ((sources & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK)) { // This device is a game controller. Store its device ID. if (!gameControllerDeviceIds.contains(deviceId)) { gameControllerDeviceIds.add(deviceId); } } } return gameControllerDeviceIds; }
Vous pouvez également vérifier les capacités d'entrée individuelles compatible avec une manette de jeu connectée. Cela peut être utile, par exemple, vous voulez que votre jeu n'utilise que les entrées de l'ensemble des commandes physiques qu'il comprend.
Pour détecter si un code de clé ou d'axe spécifique est pris en charge par un manette de jeu, utilisez les techniques suivantes:
- Dans Android 4.4 (niveau d'API 19) ou version ultérieure, vous pouvez déterminer si un code de clé est
sur une manette de jeu connectée en appelant
hasKeys(int...)
- Sous Android 3.1 (niveau d'API 12) ou version ultérieure, vous pouvez trouver tous les axes disponibles
sur une manette de jeu connectée en appelant d'abord
getMotionRanges()
Puis, à chaque ObjetInputDevice.MotionRange
renvoyé, appelgetAxis()
pour obtenir son ID d'axe.
Traiter les pressions sur les boutons de la manette de jeu
La figure 1 montre comment Android mappe les codes clés et les valeurs d'axe avec la couche physique sur la plupart des manettes de jeu.
![](https://developer.android.com/static/images/training/game-controller-profiles.png?authuser=9&hl=fr)
Figure 1 : Profil pour une manette de jeu générique.
Les légendes de la figure font référence aux éléments suivants:
Voici les codes de touches courants générés lorsque vous appuyez sur les boutons d'une manette de jeu
BUTTON_A
,
BUTTON_B
,
BUTTON_SELECT
,
et BUTTON_START
. Un jeu
les manettes de jeu déclenchent également le code de touche DPAD_CENTER
lorsque l'utilisateur appuie au centre de la barre transversale du pavé directionnel. Votre
jeu peut inspecter le code de touche en appelant getKeyCode()
ou depuis des rappels d'événements clés tels que
onKeyDown()
,
et, s'il représente un événement pertinent pour votre jeu, traitez-le comme
l'action dans les jeux. Le tableau 1 liste les actions de jeu recommandées pour les actions les plus courantes
boutons de la manette de jeu.
Tableau 1. Actions de jeu recommandées pour la manette de jeu .
Action dans le jeu | Code de la touche du bouton |
---|---|
Lancez le jeu dans le menu principal ou mettez-le en pause/reprenez sa lecture pendant le jeu | BUTTON_START * |
Afficher le menu | BUTTON_SELECT *
et KEYCODE_MENU * |
Identique au comportement de navigation vers l'arrière d'Android décrit dans le Conception de la navigation . | KEYCODE_BACK |
Revenir à l'élément précédent d'un menu | BUTTON_B |
Confirmer la sélection ou effectuer l'action principale du jeu | BUTTON_A et
DPAD_CENTER |
* Votre jeu ne doit pas reposer sur la présence des boutons "Démarrer", "Sélectionner" ou "Menu" boutons.
Conseil : Pensez à fournir un écran de configuration. dans votre jeu pour permettre aux utilisateurs de personnaliser leurs mappages de manette de jeu pour les actions de jeu.
L'extrait de code suivant montre comment remplacer
onKeyDown()
jusqu'à
associer BUTTON_A
et
Appui sur le bouton DPAD_CENTER
avec une action dans le jeu.
Kotlin
class GameView(...) : View(...) { ... override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean { var handled = false if (event.source and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD) { if (event.repeatCount == 0) { when (keyCode) { // Handle gamepad and D-pad button presses to navigate the ship ... else -> { keyCode.takeIf { isFireKey(it) }?.run { // Update the ship object to fire lasers ... handled = true } } } } if (handled) { return true } } return super.onKeyDown(keyCode, event) } // Here we treat Button_A and DPAD_CENTER as the primary action // keys for the game. private fun isFireKey(keyCode: Int): Boolean = keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_BUTTON_A }
Java
public class GameView extends View { ... @Override public boolean onKeyDown(int keyCode, KeyEvent event) { boolean handled = false; if ((event.getSource() & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) { if (event.getRepeatCount() == 0) { switch (keyCode) { // Handle gamepad and D-pad button presses to // navigate the ship ... default: if (isFireKey(keyCode)) { // Update the ship object to fire lasers ... handled = true; } break; } } if (handled) { return true; } } return super.onKeyDown(keyCode, event); } private static boolean isFireKey(int keyCode) { // Here we treat Button_A and DPAD_CENTER as the primary action // keys for the game. return keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_BUTTON_A; } }
Remarque : Sur Android 4.2 (API
niveau 17) et inférieurs, le système traite
BUTTON_A
pour Android
Retour par défaut. Si votre application est compatible avec ces
versions, assurez-vous de traiter
BUTTON_A
comme jeu principal
action. Pour déterminer le SDK Android actuel
version de l'appareil, consultez la
Valeur Build.VERSION.SDK_INT
.
Traiter la saisie du pavé directionnel
Le pavé directionnel à quatre directions est une commande physique courante dans de nombreux jeux
contrôleurs. Android signale les appuis sur les boutons Haut et Bas du pavé directionnel comme
AXIS_HAT_Y
événements avec une plage
de -1,0 (vers le haut) à 1,0 (bas), et le pavé directionnel appuie sur GAUCHE ou DROITE
Événements AXIS_HAT_X
dont la plage est comprise entre -1.0
(gauche) sur 1.0 (droite).
À la place, certaines manettes indiquent les pressions sur le pavé directionnel avec un code de touche. Si votre jeu concerne les pressions du pavé directionnel, vous devez traiter les événements de l'axe du chapeau et le pavé directionnel. codes de touche que les mêmes événements d'entrée, comme recommandé dans le tableau 2.
Tableau 2. Actions de jeu par défaut recommandées pour la touche du pavé directionnel les codes et les valeurs de l'axe du chapeau.
Action dans le jeu | Code des touches du pavé directionnel | Code pour l'axe du chapeau |
---|---|---|
Monter | KEYCODE_DPAD_UP |
AXIS_HAT_Y (pour les valeurs comprises entre 0 et -1,0) |
Descendre | KEYCODE_DPAD_DOWN |
AXIS_HAT_Y (pour les valeurs comprises entre 0 et 1,0) |
Déplacer à gauche | KEYCODE_DPAD_LEFT |
AXIS_HAT_X (pour les valeurs comprises entre 0 et -1,0) |
Déplacer à droite | KEYCODE_DPAD_RIGHT |
AXIS_HAT_X (pour les valeurs comprises entre 0 et 1,0) |
L'extrait de code suivant montre une classe d'assistance qui vous permet de vérifier le chapeau les valeurs des axes et des codes de touche à partir d'un événement d'entrée pour déterminer la direction du pavé directionnel.
Kotlin
class Dpad { private var directionPressed = -1 // initialized to -1 fun getDirectionPressed(event: InputEvent): Int { if (!isDpadDevice(event)) { return -1 } // If the input event is a MotionEvent, check its hat axis values. (event as? MotionEvent)?.apply { // Use the hat axis value to find the D-pad direction val xaxis: Float = event.getAxisValue(MotionEvent.AXIS_HAT_X) val yaxis: Float = event.getAxisValue(MotionEvent.AXIS_HAT_Y) directionPressed = when { // Check if the AXIS_HAT_X value is -1 or 1, and set the D-pad // LEFT and RIGHT direction accordingly. xaxis.compareTo(-1.0f) == 0 -> Dpad.LEFT xaxis.compareTo(1.0f) == 0 -> Dpad.RIGHT // Check if the AXIS_HAT_Y value is -1 or 1, and set the D-pad // UP and DOWN direction accordingly. yaxis.compareTo(-1.0f) == 0 -> Dpad.UP yaxis.compareTo(1.0f) == 0 -> Dpad.DOWN else -> directionPressed } } // If the input event is a KeyEvent, check its key code. (event as? KeyEvent)?.apply { // Use the key code to find the D-pad direction. directionPressed = when(event.keyCode) { KeyEvent.KEYCODE_DPAD_LEFT -> Dpad.LEFT KeyEvent.KEYCODE_DPAD_RIGHT -> Dpad.RIGHT KeyEvent.KEYCODE_DPAD_UP -> Dpad.UP KeyEvent.KEYCODE_DPAD_DOWN -> Dpad.DOWN KeyEvent.KEYCODE_DPAD_CENTER -> Dpad.CENTER else -> directionPressed } } return directionPressed } companion object { internal const val UP = 0 internal const val LEFT = 1 internal const val RIGHT = 2 internal const val DOWN = 3 internal const val CENTER = 4 fun isDpadDevice(event: InputEvent): Boolean = // Check that input comes from a device with directional pads. event.source and InputDevice.SOURCE_DPAD != InputDevice.SOURCE_DPAD } }
Java
public class Dpad { final static int UP = 0; final static int LEFT = 1; final static int RIGHT = 2; final static int DOWN = 3; final static int CENTER = 4; int directionPressed = -1; // initialized to -1 public int getDirectionPressed(InputEvent event) { if (!isDpadDevice(event)) { return -1; } // If the input event is a MotionEvent, check its hat axis values. if (event instanceof MotionEvent) { // Use the hat axis value to find the D-pad direction MotionEvent motionEvent = (MotionEvent) event; float xaxis = motionEvent.getAxisValue(MotionEvent.AXIS_HAT_X); float yaxis = motionEvent.getAxisValue(MotionEvent.AXIS_HAT_Y); // Check if the AXIS_HAT_X value is -1 or 1, and set the D-pad // LEFT and RIGHT direction accordingly. if (Float.compare(xaxis, -1.0f) == 0) { directionPressed = Dpad.LEFT; } else if (Float.compare(xaxis, 1.0f) == 0) { directionPressed = Dpad.RIGHT; } // Check if the AXIS_HAT_Y value is -1 or 1, and set the D-pad // UP and DOWN direction accordingly. else if (Float.compare(yaxis, -1.0f) == 0) { directionPressed = Dpad.UP; } else if (Float.compare(yaxis, 1.0f) == 0) { directionPressed = Dpad.DOWN; } } // If the input event is a KeyEvent, check its key code. else if (event instanceof KeyEvent) { // Use the key code to find the D-pad direction. KeyEvent keyEvent = (KeyEvent) event; if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_LEFT) { directionPressed = Dpad.LEFT; } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_RIGHT) { directionPressed = Dpad.RIGHT; } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_UP) { directionPressed = Dpad.UP; } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_DOWN) { directionPressed = Dpad.DOWN; } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER) { directionPressed = Dpad.CENTER; } } return directionPressed; } public static boolean isDpadDevice(InputEvent event) { // Check that input comes from a device with directional pads. if ((event.getSource() & InputDevice.SOURCE_DPAD) != InputDevice.SOURCE_DPAD) { return true; } else { return false; } } }
Vous pouvez utiliser cette classe d'assistance dans votre jeu partout où vous souhaitez traiter
d'un pavé directionnel (par exemple,
onGenericMotionEvent()
ou
onKeyDown()
(les rappels automatiques sont activés).
Exemple :
Kotlin
private val dpad = Dpad() ... override fun onGenericMotionEvent(event: MotionEvent): Boolean { if (Dpad.isDpadDevice(event)) { when (dpad.getDirectionPressed(event)) { Dpad.LEFT -> { // Do something for LEFT direction press ... return true } Dpad.RIGHT -> { // Do something for RIGHT direction press ... return true } Dpad.UP -> { // Do something for UP direction press ... return true } ... } } // Check if this event is from a joystick movement and process accordingly. ... }
Java
Dpad dpad = new Dpad(); ... @Override public boolean onGenericMotionEvent(MotionEvent event) { // Check if this event if from a D-pad and process accordingly. if (Dpad.isDpadDevice(event)) { int press = dpad.getDirectionPressed(event); switch (press) { case LEFT: // Do something for LEFT direction press ... return true; case RIGHT: // Do something for RIGHT direction press ... return true; case UP: // Do something for UP direction press ... return true; ... } } // Check if this event is from a joystick movement and process accordingly. ... }
Exécuter les mouvements du joystick
Lorsque les joueurs déplacent un joystick sur leur manette de jeu, Android signale une
MotionEvent
contenant les
le code d'action ACTION_MOVE
et le code
la position des axes du joystick. Votre jeu peut utiliser les données fournies par
MotionEvent
pour déterminer si un mouvement de joystick
s'inquiète de ce qui se passe.
Notez que les événements de mouvement du joystick peuvent regrouper plusieurs échantillons de mouvement
dans un même objet. L'objet MotionEvent
contient
la position actuelle de chaque axe du joystick, ainsi que plusieurs
pour chaque axe. Lorsque vous signalez des événements de mouvement avec le code d'action ACTION_MOVE
(par exemple, les mouvements du joystick), Android regroupe les
pour plus d'efficacité. Les valeurs historiques d'un axe sont constituées
ensemble de valeurs distinctes antérieures à la valeur actuelle de l'axe et plus récentes que
signalées par les événements de mouvement précédents. Consultez le
Documentation de référence sur MotionEvent
pour en savoir plus.
Vous pouvez utiliser les informations historiques pour afficher un jeu plus précisément
mouvement de l'objet en fonction des données saisies par le joystick. À
récupérer les valeurs actuelles et historiques, appeler
getAxisValue()
ou getHistoricalAxisValue()
. Vous pouvez également consulter le nombre
l'événement de joystick en appelant
getHistorySize()
L'extrait de code suivant montre comment remplacer
Rappel onGenericMotionEvent()
pour traiter l'entrée via le joystick. Vous devez d'abord
traiter les valeurs historiques d'un axe, puis traiter sa position actuelle.
Kotlin
class GameView(...) : View(...) { override fun onGenericMotionEvent(event: MotionEvent): Boolean { // Check that the event came from a game controller return if (event.source and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK && event.action == MotionEvent.ACTION_MOVE) { // Process the movements starting from the // earliest historical position in the batch (0 until event.historySize).forEach { i -> // Process the event at historical position i processJoystickInput(event, i) } // Process the current movement sample in the batch (position -1) processJoystickInput(event, -1) true } else { super.onGenericMotionEvent(event) } } }
Java
public class GameView extends View { @Override public boolean onGenericMotionEvent(MotionEvent event) { // Check that the event came from a game controller if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK && event.getAction() == MotionEvent.ACTION_MOVE) { // Process all historical movement samples in the batch final int historySize = event.getHistorySize(); // Process the movements starting from the // earliest historical position in the batch for (int i = 0; i < historySize; i++) { // Process the event at historical position i processJoystickInput(event, i); } // Process the current movement sample in the batch (position -1) processJoystickInput(event, -1); return true; } return super.onGenericMotionEvent(event); } }
Avant d'utiliser la saisie à l'aide du joystick, vous devez déterminer si le joystick est centrer, puis calculer les mouvements de ses axes en conséquence. Les joysticks sont généralement avoir une zone plate, c'est-à-dire une plage de valeurs proche de la coordonnée (0,0) ; à laquelle l'axe est considéré comme centré. Si la valeur d'axe rapportée par Android se trouve dans la zone plane, vous devez considérer le contrôleur comme étant (c'est-à-dire sans mouvement le long des deux axes).
L'extrait de code ci-dessous montre une méthode d'assistance permettant de calculer le mouvement
chaque axe. Vous appelez cet assistant dans la méthode processJoystickInput()
.
décrits ci-dessous.
Kotlin
private fun getCenteredAxis( event: MotionEvent, device: InputDevice, axis: Int, historyPos: Int ): Float { val range: InputDevice.MotionRange? = device.getMotionRange(axis, event.source) // A joystick at rest does not always report an absolute position of // (0,0). Use the getFlat() method to determine the range of values // bounding the joystick axis center. range?.apply { val value: Float = if (historyPos < 0) { event.getAxisValue(axis) } else { event.getHistoricalAxisValue(axis, historyPos) } // Ignore axis values that are within the 'flat' region of the // joystick axis center. if (Math.abs(value) > flat) { return value } } return 0f }
Java
private static float getCenteredAxis(MotionEvent event, InputDevice device, int axis, int historyPos) { final InputDevice.MotionRange range = device.getMotionRange(axis, event.getSource()); // A joystick at rest does not always report an absolute position of // (0,0). Use the getFlat() method to determine the range of values // bounding the joystick axis center. if (range != null) { final float flat = range.getFlat(); final float value = historyPos < 0 ? event.getAxisValue(axis): event.getHistoricalAxisValue(axis, historyPos); // Ignore axis values that are within the 'flat' region of the // joystick axis center. if (Math.abs(value) > flat) { return value; } } return 0; }
En résumé, voici comment vous pourriez traiter les mouvements du joystick dans votre jeu:
Kotlin
private fun processJoystickInput(event: MotionEvent, historyPos: Int) { val inputDevice = event.device // Calculate the horizontal distance to move by // using the input value from one of these physical controls: // the left control stick, hat axis, or the right control stick. var x: Float = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_X, historyPos) if (x == 0f) { x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_X, historyPos) } if (x == 0f) { x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Z, historyPos) } // Calculate the vertical distance to move by // using the input value from one of these physical controls: // the left control stick, hat switch, or the right control stick. var y: Float = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Y, historyPos) if (y == 0f) { y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_Y, historyPos) } if (y == 0f) { y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_RZ, historyPos) } // Update the ship object based on the new x and y values }
Java
private void processJoystickInput(MotionEvent event, int historyPos) { InputDevice inputDevice = event.getDevice(); // Calculate the horizontal distance to move by // using the input value from one of these physical controls: // the left control stick, hat axis, or the right control stick. float x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_X, historyPos); if (x == 0) { x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_X, historyPos); } if (x == 0) { x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Z, historyPos); } // Calculate the vertical distance to move by // using the input value from one of these physical controls: // the left control stick, hat switch, or the right control stick. float y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Y, historyPos); if (y == 0) { y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_Y, historyPos); } if (y == 0) { y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_RZ, historyPos); } // Update the ship object based on the new x and y values }
Pour prendre en charge les manettes de jeu plus sophistiquées au-delà d'un seul joystick, suivez ces bonnes pratiques:
- Gérez deux manettes de manette de jeu. De nombreuses manettes de jeu ont
à la fois un joystick
gauche et droit. Pour le stick gauche, Android
signale les mouvements horizontaux en tant qu'événements
AXIS_X
et les mouvements verticaux en tant qu'événementsAXIS_Y
. Pour le stick de droite, Android signale les mouvements horizontaux commeAXIS_Z
événements et mouvements verticaux en tant queAXIS_RZ
événements. Veillez à gérer les deux manettes dans votre code. - Gérer les pressions sur la gâchette d'épaule (mais fournir une autre méthode d'entrée)
méthodes). Certaines manettes ont des épaules gauche et droite
déclencheurs. Si ces déclencheurs sont présents, Android signale un appui sur la gâchette gauche
en tant qu'événement
AXIS_LTRIGGER
et en tant qu'événement sur la gâchette droiteAXIS_RTRIGGER
. Sur Android 4.3 (niveau d'API 18), un contrôleur qui produit unAXIS_LTRIGGER
signale également une valeur identique pour l'axeAXIS_BRAKE
. La il en va de même pourAXIS_RTRIGGER
.AXIS_GAS
Android signale tous les déclencheurs analogiques d'appuis avec une valeur normalisée comprise entre 0.0 (relâcher) et 1.0 (complètement). Non Toutes les manettes ont des déclencheurs. Pensez à autoriser les joueurs à les utiliser des actions de jeu avec d'autres boutons.