Entrées compatibles

Bien que de nombreux appareils ChromeOS soient équipés d'écrans tactiles, la meilleure expérience d'interaction pour les jeux sur ces appareils à grand écran est souvent obtenue avec une souris, un clavier et une manette de jeu. Le monde du jeu mobile est souvent axé sur le tactile. Il est donc important de réfléchir à la manière de proposer la meilleure expérience aux utilisateurs qui n'utilisent pas le tactile.

Commencez par consulter les bonnes pratiques pour ajouter la prise en charge du clavier, de la souris et des manettes de jeu. Vous devez porter une attention particulière au cas où les utilisateurs maintiennent des touches enfoncées ou appuient sur plusieurs touches.

Les actions tactiles sont acceptables pour les Chromebooks dotés d'écrans tactiles, mais il est important d'inclure également des commandes physiques bien pensées pour une expérience optimale. Par exemple, la saisie à la souris est idéale pour ajuster la vue ou viser, mais ne devrait pas être nécessaire pour effectuer des actions. Si un jeu mobile dispose d'un menu à l'écran qui permet à un utilisateur d'utiliser une torche, une épée ou un bouclier en appuyant sur un bouton avec son pouce, l'obliger à cliquer sur ces boutons avec une souris lui offrira une mauvaise expérience. Au lieu de cela, les touches du clavier doivent être désignées pour déclencher chaque action en remplaçant onKeyUp ou onKeyDown. Pour en savoir plus et obtenir le code, consultez la page Compatibilité des entrées.

Capture de la souris

Les jeux à la première personne sont plus agréables sur ordinateur lorsqu'ils implémentent la capture de la souris. Cela masque le pointeur de la souris et permet à l'utilisateur de déplacer le point de vue, de viser, de diriger, etc., à l'aide de la souris. Vous trouverez ci-dessous une démo de capture de la souris de base qui enregistre la position du pointeur et l'état des boutons après que l'utilisateur a cliqué sur une vue de texte nommée text_clickme. Pour en savoir plus, consultez la documentation Android sur la capture du pointeur.

class MainActivity : AppCompatActivity() {
    var mouse_x: Float = 0f
    var mouse_y: Float = 0f
    var mouse_left_pressed = false
    var mouse_center_pressed = false
    var mouse_right_pressed = false
    var mouse_scrolling = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        text_clickme.setOnClickListener {
            text_clickme.requestPointerCapture()
        }

        text_clickme.setOnCapturedPointerListener { view, motionEvent ->
            // Get the coordinates required by your app
            mouse_x = motionEvent.x
            mouse_y = motionEvent.y

            when (motionEvent.action) {
                ACTION_DOWN -> {
                    when (motionEvent.buttonState) {
                        BUTTON_PRIMARY -> mouse_left_pressed = true
                        BUTTON_SECONDARY -> mouse_right_pressed = true
                        BUTTON_TERTIARY -> mouse_center_pressed = true
                    }
                    mouse_scrolling = false
                }

                ACTION_CANCEL,
                ACTION_UP -> {
                    when (motionEvent.actionButton) {
                        BUTTON_PRIMARY -> mouse_left_pressed = false
                        BUTTON_SECONDARY -> mouse_right_pressed = false
                        BUTTON_TERTIARY -> mouse_center_pressed = false
                        0 -> {
                            mouse_left_pressed = false
                            mouse_right_pressed = false
                            mouse_center_pressed = false
                        }
                    }
                    mouse_scrolling = false
                }
                ACTION_SCROLL -> {
                    mouse_scrolling = true
                }
                else -> {
                    mouse_scrolling = false
                }
            }

            // Indicate event was consumed
            true
        }
    }

    // Release pointer capture when escape pressed
    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
        if (keyCode == KEYCODE_ESCAPE) {
            text_clickme.releasePointerCapture()
            return true;
        }
        return super.onKeyUp(keyCode, event)
    }
}

Chat

Les fonctionnalités de chat peuvent être un élément important des jeux multijoueurs. Prenez le temps de réfléchir à la manière dont les utilisateurs interagiront avec la fonctionnalité de chat de votre jeu pendant qu'ils jouent. En particulier, s'ils jouent avec le clavier, ils ne devraient pas avoir à utiliser la souris ou l'écran tactile pour accéder au chat ou envoyer des messages.

Un modèle pourrait consister à faire en sorte qu'une touche du clavier sélectionne la zone de chat et que la touche Entrée envoie les messages.

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
  return when(keyCode) {
    KeyEvent.KEYCODE_C -> {
      edittext_chatbox.requestFocus()
      true
    }
    KeyEvent.KEYCODE_ENTER -> {
      submitChatMessage()
      true
    }
    else -> super.onKeyUp(keyCode, event)
  }
}

Consultez la documentation sur le clavier sur la page de compatibilité des entrées Android.

Compatible avec les stylets

Les applications de dessin et les jeux basés sur le balayage peuvent tirer parti de la saisie au stylet sur les appareils ChromeOS. Pour en savoir plus, consultez la page sur les saisies au stylet.

Manettes de jeu

Les Chromebooks acceptent jusqu'à quatre manettes de jeu. Les développeurs doivent utiliser les API de manette de jeu Android standards pour les prendre en charge.

Les boutons sont mis en correspondance avec des valeurs communes suivant un mappage commun. Malheureusement, tous les fabricants de manettes de jeu ne suivent pas les mêmes conventions de mappage. Vous offrirez une bien meilleure expérience si vous autorisez les utilisateurs à sélectionner différents mappages de manettes populaires.