Gérer les actions de la manette

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

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 ou BUTTON_A. Vous pouvez obtenir la valeur code de touche en appelant getKeyCode() ou à partir de la touche des rappels d'événement tels que onKeyDown()
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 ou AXIS_RTRIGGER Vous pouvez obtenir le code d'action en appelant getAction() et la valeur de l'axe Appel de getAxisValue() 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 de AXIS_X et AXIS_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 Objet InputDevice.MotionRange renvoyé, appel getAxis() 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.

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énements AXIS_Y. Pour le stick de droite, Android signale les mouvements horizontaux comme AXIS_Z événements et mouvements verticaux en tant que AXIS_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 droite AXIS_RTRIGGER. Sur Android 4.3 (niveau d'API 18), un contrôleur qui produit un AXIS_LTRIGGER signale également une valeur identique pour l'axe AXIS_BRAKE. La il en va de même pour AXIS_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.