Assurer la compatibilité avec plusieurs manettes de jeu

Alors que la plupart des jeux sont conçus pour n'accepter qu'un seul utilisateur par appareil Android, Il est également possible de prendre en charge plusieurs utilisateurs avec des manettes de jeu connectés simultanément sur le même appareil Android.

Cette leçon présente quelques techniques de base pour gérer les entrées dans votre jeu multijoueur sur appareil à partir de plusieurs manettes connectées. Cela inclut maintenir un mappage entre les avatars des joueurs et chaque manette et traiter les événements d'entrée du contrôleur de manière appropriée.

Mapper les joueurs avec les ID de manette

Lorsqu'une manette de jeu est connectée à un appareil Android, le système lui attribue un ID d'appareil sous forme de nombre entier. Vous pouvez obtenir les ID des appareils connectés des manettes de jeu en appelant InputDevice.getDeviceIds(), comme indiqué dans la section Vérifier qu'une manette de jeu est connectée. Vous pouvez ensuite associer chaque ID d'appareil avec un joueur dans votre jeu, et traitez les actions du jeu pour chaque joueur séparément.

Remarque : Sur les appareils équipés d'Android 4.1 (API niveau 16) et supérieurs, vous pouvez obtenir le descripteur d'un périphérique d'entrée en utilisant getDescriptor(), qui renvoie une valeur valeur de chaîne persistante pour le périphérique d'entrée. Contrairement à un ID d'appareil, le descripteur ne change pas, même si le périphérique d'entrée est déconnecté, reconnecté ou reconfigurée.

L'extrait de code ci-dessous montre comment utiliser un SparseArray pour associer l'avatar d'un joueur à une manette spécifique. Dans cet exemple, La variable mShips stocke une collection d'objets Ship. Une nouvelle l'avatar du joueur est créé dans le jeu lorsqu'un utilisateur y associe une nouvelle manette. et supprimé lorsque la manette associée est retirée.

Le rappel onInputDeviceAdded() et onInputDeviceRemoved() font partie de la couche d'abstraction introduite <ph type="x-smartling-placeholder"></ph> Prise en charge des contrôleurs sur les différentes versions d'Android. En implémentant ces d'écouteurs, votre jeu peut identifier l'ID d'appareil de la manette de jeu la manette de jeu est ajoutée ou supprimée. Cette détection est compatible avec Android 2.3 (niveau d'API 9) ou version ultérieure.

private val ships = SparseArray<Ship>()

override fun onInputDeviceAdded(deviceId: Int) {
    getShipForID(deviceId)
}

override fun onInputDeviceRemoved(deviceId: Int) {
    removeShipForID(deviceId)
}

private fun getShipForID(shipID: Int): Ship {
    return ships.get(shipID) ?: Ship().also {
        ships.append(shipID, it)
    }
}

private fun removeShipForID(shipID: Int) {
    ships.remove(shipID)
}

private final SparseArray<Ship> ships = new SparseArray<Ship>();

@Override
public void onInputDeviceAdded(int deviceId) {
    getShipForID(deviceId);
}

@Override
public void onInputDeviceRemoved(int deviceId) {
    removeShipForID(deviceId);
}

private Ship getShipForID(int shipID) {
    Ship currentShip = ships.get(shipID);
    if ( null == currentShip ) {
        currentShip = new Ship();
        ships.append(shipID, currentShip);
    }
    return currentShip;
}

private void removeShipForID(int shipID) {
    ships.remove(shipID);
}

Traiter les entrées de plusieurs manettes

Votre jeu doit exécuter la boucle suivante pour traiter provenant de plusieurs manettes:

1. Détecter si un événement d'entrée s'est produit.
2. Identifiez la source d'entrée et son ID d'appareil.
3. En fonction de l'action indiquée par le code de touche de l'événement d'entrée ou la valeur de l'axe, modifier l'avatar du joueur associé à cet ID d'appareil.
4. Affichez et mettez à jour l'interface utilisateur.

Entrées KeyEvent et MotionEvent sont associés à des ID d'appareil. Votre jeu peut exploiter pour déterminer de quel contrôleur provient l'événement d'entrée et mettre à jour associé à cette manette.

L'extrait de code suivant montre comment obtenir une référence à l'avatar d'un joueur. correspondant à l'ID d'une manette de jeu, et mettez à jour le jeu en fonction appuyer sur le bouton de cette manette.

override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
    if (event.source and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD) {
        event.deviceId.takeIf { it != -1 }?.also { deviceId ->
            val currentShip: Ship = getShipForID(deviceId)
            // Based on which key was pressed, update the player avatar
            // (e.g. set the ship headings or fire lasers)
            return true
        }
    }
    return super.onKeyDown(keyCode, event)
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if ((event.getSource() & InputDevice.SOURCE_GAMEPAD)
                == InputDevice.SOURCE_GAMEPAD) {
        int deviceId = event.getDeviceId();
        if (deviceId != -1) {
            Ship currentShip = getShipForId(deviceId);
            // Based on which key was pressed, update the player avatar
            // (e.g. set the ship headings or fire lasers)
            ...
            return true;
        }
    }
    return super.onKeyDown(keyCode, event);
}

Remarque : Nous vous recommandons de suivre la manette de jeu se déconnecte, vous devez mettre le jeu en pause et demander à l'utilisateur veut se reconnecter.