A livello di sistema, Android segnala i codici evento inseriti dai controller di gioco come codici chiave e valori degli assi di Android. Nel tuo gioco puoi ricevere questi codici e i relativi valori, convertendoli in azioni in-game specifiche.
Quando i giocatori si connettono fisicamente o accoppiano in modalità wireless un controller di gioco
sui loro dispositivi Android, il sistema rileva automaticamente il controller
come dispositivo di input e inizia a segnalare i suoi eventi di input. Il gioco può ricevere
a questi eventi di input implementando i seguenti metodi di callback
Activity
o View
concentrato (dovresti
i callback per Activity
o
View
, ma non entrambi):
- Da
Activity
:dispatchGenericMotionEvent(android.view. MotionEvent)
Chiamato per elaborare eventi di movimento generici, come i movimenti del joystick.
dispatchKeyEvent(android.view.KeyEvent)
Chiamato per elaborare eventi chiave come la stampa o il comunicato di un Pulsante gamepad o D-pad.
- Da
View
:onGenericMotionEvent(android.view.MotionEvent)
Chiamato per elaborare eventi di movimento generici, come i movimenti del joystick.
onKeyDown(int, android.view.KeyEvent)
Chiamato per elaborare la pressione di un tasto fisico, ad esempio un gamepad o Pulsante D-pad.
onKeyUp(int, android.view.KeyEvent)
Chiamato per elaborare il rilascio di una chiave fisica, ad esempio un gamepad o Pulsante D-pad.
L'approccio consigliato è acquisire gli eventi
oggetto View
specifico con cui interagisce l'utente.
Esamina i seguenti oggetti forniti dai callback per ottenere informazioni
sul tipo di evento di input ricevuto:
KeyEvent
- Un oggetto che descrive
Eventi relativi ai pulsanti del pad (D-pad) e del gamepad. Gli eventi chiave sono accompagnati da una
codice chiave che indica il pulsante specifico attivato, ad esempio
DPAD_DOWN
oBUTTON_A
. Puoi ottenere codice della chiave chiamandogetKeyCode()
o dalla chiave come il callbackonKeyDown()
. MotionEvent
- Un oggetto che descrive l'input proveniente dal joystick e dal trigger di spallamento
movimenti. Gli eventi di movimento sono accompagnati da un codice di azione e da una serie di
valori dell'asse. Il codice di azione specifica la modifica dello stato che si è verificata
ad esempio lo spostamento di un joystick. I valori dell'asse descrivono la posizione e altre
proprietà del movimento per un controllo fisico specifico, come
AXIS_X
oAXIS_RTRIGGER
. Puoi ottenere il codice di azione richiamandogetAction()
e il valore dell'asse chiamata al numerogetAxisValue()
.
Questa lezione spiega come gestire l'input dei tipi più comuni di
controlli fisici (pulsanti del gamepad, d-pad e
joystick) nella schermata di un gioco mediante l'implementazione del suddetto
View
metodi di callback ed elaborazione
KeyEvent
e MotionEvent
oggetti.
Verificare che un controller di gioco sia collegato
Quando segnala gli eventi di input, Android non distingue
tra gli eventi provenienti da un dispositivo diverso da un controller di gioco e gli eventi che si sono verificati
da un controller di gioco. Ad esempio, un'azione touchscreen genera un
Evento AXIS_X
che rappresenta la X
coordinata della superficie touch, ma un joystick genera una
Evento AXIS_X
che rappresenta la posizione X del joystick. Se
il tuo gioco è interessato alla gestione dell'input del controller di gioco, devi prima controllare
che l'evento di input provenga da un tipo di origine pertinente.
Per verificare che un dispositivo di input collegato sia un controller di gioco, chiama
getSources()
per ottenere un campo di bit combinato
tipi di origini di ingresso supportati su quel dispositivo. Puoi quindi verificare se
vengono impostati i seguenti campi:
- Un tipo di origine
SOURCE_GAMEPAD
indica Che il dispositivo di input abbia pulsanti del gamepad (ad esempio,BUTTON_A
). Tieni presente che questa fonte "type" non indica rigorosamente se il controller di gioco ha i pulsanti D-pad, sebbene la maggior parte dei gamepad in genere abbia controlli direzionali. - Un tipo di origine
SOURCE_DPAD
indica che il dispositivo di input dispone di pulsanti D-pad (ad esempio,DPAD_UP
). - Un tipo di origine
SOURCE_JOYSTICK
indica che il dispositivo di input è dotato di stick di controllo analogici (ad esempio, joystick che registra i movimenti lungoAXIS_X
eAXIS_Y
).
Il seguente snippet di codice mostra un metodo di supporto che ti consente di verificare se i dispositivi di input collegati sono controller di gioco. In tal caso, il metodo recupera gli ID dispositivo dei controller di gioco. Dopodiché potrai associare ogni dispositivo ID con un giocatore nel tuo gioco, ed elabora le azioni di gioco per ogni collegamento separatamente. Per scoprire di più sul supporto di più controller di gioco collegati simultaneamente sullo stesso dispositivo Android, vedi Supporta più controller di gioco.
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; }
Inoltre, puoi controllare le funzionalità di input individuali supportato da un controller di gioco collegato. Questo può essere utile, ad esempio, se vuoi che il gioco utilizzi solo l'input dell'insieme di controlli fisici comprende.
Per rilevare se un codice chiave o un codice asse specifico è supportato da un per un controller di gioco, utilizza queste tecniche:
- In Android 4.4 (livello API 19) o versioni successive, puoi determinare se un codice chiave è
supportata su un controller di gioco collegato chiamando
hasKeys(int...)
. - In Android 3.1 (livello API 12) o versioni successive, puoi trovare tutti gli assi disponibili
supportata su un controller di gioco connesso tramite la prima chiamata
getMotionRanges()
. Poi, su ogni OggettoInputDevice.MotionRange
restituito, chiamatagetAxis()
per ottenerne l'ID asse.
Elabora pressioni dei pulsanti del gamepad
La Figura 1 mostra come Android mappa i codici chiave e i valori degli assi alla posizione fisica disponibili sulla maggior parte dei controller di gioco.
![](https://developer.android.google.cn/static/images/training/game-controller-profiles.png?authuser=9&hl=it)
Figura 1. Profilo di un controller di gioco generico.
I callout nella figura si riferiscono a quanto segue:
I codici chiave comuni generati dalla pressione dei pulsanti del gamepad includono:
BUTTON_A
,
BUTTON_B
,
BUTTON_SELECT
,
e BUTTON_START
. Un po' di gioco
Attivano il codice tasto DPAD_CENTER
anche quando viene premuto il centro della barra trasversale del D-pad. Il tuo
il gioco può esaminare il codice chiave chiamando getKeyCode()
o dai callback di eventi chiave
onKeyDown()
,
Se rappresenta un evento pertinente per il tuo gioco, elaboralo come
un'azione di gioco. La tabella 1 elenca le azioni di gioco consigliate per le più comuni
Pulsanti del gamepad.
Tabella 1. Azioni di gioco consigliate per il gamepad pulsanti.
Azione di gioco | Codice chiave pulsante |
---|---|
Inizia a giocare nel menu principale oppure metti in pausa e riattiva durante la partita | BUTTON_START * |
Visualizza menu | BUTTON_SELECT *
e KEYCODE_MENU * |
Come il comportamento di navigazione Indietro di Android descritto nella sezione Design di navigazione guida. | KEYCODE_BACK |
Tornare a un elemento precedente in un menu | BUTTON_B |
Conferma la selezione o esegui l'azione di gioco principale | BUTTON_A e
DPAD_CENTER |
* Il tuo gioco non deve dipendere dalla presenza dei pulsanti Start, Seleziona o Menu. pulsanti.
Suggerimento : valuta la possibilità di fornire una schermata di configurazione nel tuo gioco per consentire agli utenti di personalizzare le mappature dei controller di gioco azioni di gioco.
Il seguente snippet mostra come eseguire l'override
Da onKeyDown()
a
associare BUTTON_A
e
DPAD_CENTER
pressioni pulsante
con un'azione di gioco.
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; } }
Nota: su Android 4.2 (API
livello 17) e in basso, il sistema tratta
BUTTON_A
come Android
il tasto Indietro per impostazione predefinita. Se la tua app supporta questi dispositivi Android
versioni, assicurati di considerare
BUTTON_A
come gioco principale
un'azione. Per determinare l'SDK Android corrente
versione sul dispositivo, consulta
Valore Build.VERSION.SDK_INT
.
Elabora l'input del d-pad
Il pad direzionale a 4 vie (D-pad) è un controllo fisico comune in molti giochi
controller. Android segnala le pressioni dei tasti D-pad SU e GIÙ come
AXIS_HAT_Y
eventi con un intervallo
da -1.0 (su) a 1.0 (giù), e il D-pad LEFT o RIGHT preme
AXIS_HAT_X
eventi con un intervallo da -1,0
(sinistra) a 1,0 (destra).
Alcuni controller invece segnalano le pressioni del D-pad con un codice tasto. Se il tuo gioco interessa le pressioni del D-pad, dovresti trattare gli eventi dell'asse del cappello e il D-pad degli stessi eventi di input, come consigliato nella tabella 2.
Tabella 2. Azioni di gioco predefinite consigliate per il tasto D-pad e i valori dell'asse con accento circonflesso.
Azione di gioco | Codice tasto D-pad | Codice asse del cappello |
---|---|---|
Sposta su | KEYCODE_DPAD_UP |
AXIS_HAT_Y (per valori da 0 a -1,0) |
Sposta giù | KEYCODE_DPAD_DOWN |
AXIS_HAT_Y (per valori da 0 a 1,0) |
Sposta a sinistra | KEYCODE_DPAD_LEFT |
AXIS_HAT_X (per valori da 0 a -1,0) |
Sposta a destra | KEYCODE_DPAD_RIGHT |
AXIS_HAT_X (per valori da 0 a 1,0) |
Lo snippet di codice riportato di seguito mostra una classe helper che ti consente di controllare il cappello i valori degli assi e dei codici chiave di un evento di input per determinare la direzione del D-pad.
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; } } }
Puoi utilizzare questo corso di supporto nel tuo gioco ovunque tu voglia elaborare
Input con il D-pad (ad esempio, nel
onGenericMotionEvent()
o
onKeyDown()
richiamate).
Ad esempio:
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. ... }
Elabora i movimenti del joystick
Quando i giocatori muovono un joystick sui controller di gioco, Android segnala
MotionEvent
che contiene
Codice di azione ACTION_MOVE
e aggiornamento
le posizioni degli assi del joystick. Il gioco può utilizzare i dati forniti
MotionEvent
per determinare se si tratta di un movimento del joystick
è successo.
Tieni presente che gli eventi di movimento del joystick possono raggruppare più campioni di movimento
all'interno di un singolo oggetto. L'oggetto MotionEvent
contiene
la posizione corrente di ciascun asse del joystick, nonché più dati storici
posizioni per ogni asse. Quando segnali eventi di movimento con il codice di azione ACTION_MOVE
(ad esempio movimenti del joystick), Android raggruppa in blocco
i valori dell'asse per l'efficienza. I valori storici di un asse sono costituiti da:
insieme di valori distinti antecedenti al valore dell'asse corrente e più recenti di
valori riportati in eventuali eventi di movimento precedenti. Consulta le
Riferimento MotionEvent
per i dettagli.
Puoi usare i dati storici per visualizzare un gioco in modo più accurato
movimento dell'oggetto in base all'input del joystick. A
recupera i valori attuali e storici, richiama
getAxisValue()
o getHistoricalAxisValue()
. Puoi anche trovare il numero di dati storici
punti nell'evento del joystick richiamando
getHistorySize()
.
Il seguente snippet mostra come eseguire l'override
Callback onGenericMotionEvent()
per elaborare l'input del joystick. Dovresti prima
Elabora i valori storici di un asse, poi elabora la sua posizione corrente.
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); } }
Prima di utilizzare l'input del joystick, devi stabilire se quest'ultimo è centrata, verrà calcolata di conseguenza gli spostamenti dell'asse. In genere i joystick avere un'area piatta, ovvero un intervallo di valori vicino alla coordinata (0,0) in cui l'asse viene considerato centrato. Se il valore dell'asse riportato da Android rientra nell'area piana, il controller dovrebbe trovarsi riposo (ovvero, immobile su entrambi gli assi).
Lo snippet di seguito mostra un metodo di supporto che calcola il movimento lungo
ogni asse. Richiami questo helper nel metodo processJoystickInput()
descritti più avanti.
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; }
Riassumendo, ecco come puoi elaborare i movimenti del joystick il tuo gioco:
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 }
Per supportare i controller di gioco più sofisticati funzioni al di là di un singolo joystick, segui queste best practice:
- Impugna le levette del doppio controller. Molti controller di gioco
joystick sinistro e destro. Per la levetta sinistra, Android
segnala i movimenti orizzontali come eventi
AXIS_X
e movimenti verticali come eventi diAXIS_Y
. Per la levetta destra, Android segnala i movimenti orizzontali comeAXIS_Z
eventi e movimenti verticali comeAXIS_RZ
eventi. Assicurati di gestire entrambe le levette del codice. - Impugna le pressioni del grilletto a spalla (ma fornisci input alternativi
). Alcuni controller hanno spalla destra e sinistra
trigger. Se questi attivatori sono presenti, Android segnala la pressione del attivatore a sinistra
come evento
AXIS_LTRIGGER
e premi il tasto destro del mouse EventoAXIS_RTRIGGER
. Su Android 4.3 (livello API 18), un controller che produce unaAXIS_LTRIGGER
segnala anche un valore identico per l'asseAXIS_BRAKE
. La lo stesso vale perAXIS_RTRIGGER
eAXIS_GAS
. Android segnala tutti i trigger analogici con valore normalizzato da 0.0 (rilasciato) a 1.0 (completamente premuto). No tutti i controller hanno dei trigger, quindi considera l'idea di consentire ai giocatori di eseguirli azioni di gioco con altri pulsanti.