Suporte a entradas

Embora muitos dispositivos ChromeOS tenham telas sensíveis ao toque, a melhor experiência de interação em jogos nesses dispositivos de tela grande geralmente é oferecida por mouse, teclado e gamepad. O mundo dos jogos para dispositivos móveis geralmente é focado no toque, e é preciso pensar em como oferecer a melhor experiência para usuários que não usam essa função.

Comece conferindo as práticas recomendadas para adicionar compatibilidade com teclado, mouse e controles de jogos. Preste atenção especial ao caso em que os usuários mantêm as teclas pressionadas ou pressionam várias teclas.

As ações baseadas em toque são adequadas para Chromebooks com tela sensível ao toque, mas é importante incluir controles físicos bem pensados para uma ótima experiência. Por exemplo, a entrada do mouse é ótima para ajustar a visualização ou mirar, mas não deve ser necessária para realizar ações. Se um jogo para dispositivos móveis tiver um menu na tela que permita ao usuário usar uma tocha, uma espada ou um escudo pressionando um botão com o polegar, exigir que ele clique nesses botões com um mouse vai proporcionar uma experiência ruim. Em vez disso, as teclas do teclado precisam ser designadas para acionar cada ação substituindo onKeyUp ou onKeyDown. Consulte a página de compatibilidade de entrada para detalhes e código.

Captura do mouse

Os jogos em primeira pessoa ficam melhores no computador quando implementam a captura do mouse. Isso oculta o ponteiro do mouse e permite que o usuário mova o ponto de vista, mire, dirija etc. usando o mouse. Confira abaixo uma demonstração básica de captura de mouse que grava a posição do ponteiro e os estados do botão depois que o usuário clica em uma visualização de texto chamada text_clickme. Consulte a documentação de captura de ponteiro do Android para mais informações.

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

Os recursos de chat podem ser um componente importante dos jogos multijogador. Pense em como os usuários vão interagir com o recurso de chat do jogo enquanto jogam. Em especial, se estiverem jogando com o teclado, não será necessário usar o mouse ou a tela sensível ao toque para acessar o chat ou enviar mensagens.

Um padrão pode ser ter uma tecla de teclado que foca a caixa de chat e processa a tecla "Enter" para enviar mensagens.

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

Confira a documentação do teclado na página de compatibilidade de entrada do Android.

Compatibilidade com stylus

Apps de desenho e jogos baseados em deslizar podem aproveitar a entrada da stylus em dispositivos ChromeOS. Consulte a página entrada de stylus para mais detalhes.

Controles de jogos

Os Chromebooks são compatíveis com até quatro controles de jogos. Os desenvolvedores precisam usar as APIs de controle de jogos padrão do Android para oferecer suporte a eles.

Os botões são mapeados para valores comuns após um mapeamento comum. Infelizmente, nem todos os fabricantes de controles de jogos seguem as mesmas convenções de mapeamento. Permitir que os usuários escolham entre diferentes mapeamentos de controles mais usados pode proporcionar uma experiência muito melhor.