Manipulação de eventos

1. Introdução

Um mecanismo de jogo seria de pouca utilidade se pudéssemos usá-lo apenas para desenhar algo na tela. Para escrever um jogo completo, precisamos que ele interaja com o usuário! Para ser mais preciso, nosso programa deve rastrear as ações do usuário e responder a elas.

Para fazer isso, o mecanismo de jogo CodeGym possui métodos especiais que são chamados quando o usuário clica nos botões do mouse ou nas teclas do teclado.

O objetivo da classe é que você mesmo escreva esses métodos e, em seguida, o mecanismo de jogo CodeGym será responsável por chamá-los. Tudo que você precisa é declarar esses métodos em seu código. Isso é mais fácil de fazer do que parece.

2. Trabalhando com o mouse

O motor de jogo tem dois métodos para trabalhar com o mouse:

void onMouseLeftClick(int x, int y)

void onMouseRightClick(int x, int y)

Você simplesmente declara esses métodos em sua própria classe que herda a Gameclasse. E, em seguida, escreva o código que desejar nesses métodos. O mecanismo do jogo chamará esses métodos quando o usuário clicar nos botões do mouse.

onMouseLeftClick(int x, int y)é chamado pelo mecanismo quando o botão esquerdo do mouse é clicado. Seus parâmetros são as coordenadas da célula do campo de jogo onde ocorreu o clique. As coordenadas da célula superior esquerda são (0,0). Para usar este método, você precisa sobrescrevê-lo, colocando a @Overrideanotação antes do nome do método.

onMouseRightClick(int x, int y)é chamado quando o botão direito do mouse é clicado. Funciona de forma semelhante ao onMouseLeftClick(int x, int y)método.

Exemplos de uso desses métodos:

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;
import com.codegym.engine.cell.Key;

public class MySuperGame extends Game {
   @Override
   public void initialize() {
      // Set the size of the playing field to 3x3
      setScreenSize(3, 3);

      // Paint the playing field white
      for (int x = 0; x < 3; x++) {
         for (int y = 0; y < 3; y++) {
            setCellColor(x, y, Color.WHITE);
         }
      }
   }

   @Override
   public void onMouseLeftClick(int x, int y) {
      // Put a "X" in the cell that was clicked with the left mouse button
      setCellValue(x, y, "X");
   }

   @Override
   public void onMouseRightClick(int x, int y) {
      // Clear the cell that was clicked with the right mouse button
      setCellValue(x, y, "");
   }
}

No exemplo acima, declaramos os dois métodos: onMouseLeftClick()e onMouseRightClick(). O primeiro método será chamado quando o usuário clicar com o botão esquerdo do mouse nas células do campo de jogo. O segundo método será chamado quando o botão direito do mouse for clicado.

Como argumentos, o motor de jogo CodeGym passará as (x, y)coordenadas da célula do campo de jogo onde o mouse foi clicado.

3. Trabalhando com o teclado

O motor do jogo tem dois métodos para trabalhar com o teclado:

void onKeyPress(Key key);

void onKeyReleased(Key key);

Se você deseja fazer algo quando o usuário pressiona uma tecla, basta declarar esses métodos em sua classe que herda a Gameclasse.

Você escreve seu código nesses métodos e o mecanismo do jogo os chamará quando o usuário pressionar (ou liberar) uma tecla.

onKeyPress(Key key)é chamado quando qualquer tecla é pressionada . O valor da tecla pressionada (ou ) é passado para o método como parâmetro. Para usar este método, você precisa sobrescrevê-lo, colocando a anotação antes do nome do método.Key.UNKNOWNkey@Override

onKeyReleased(Key key)é chamado quando qualquer tecla é liberada . O valor da chave correspondente (ou ) é atribuído ao parâmetro. Para usar este método, você precisa sobrescrevê-lo, colocando a anotação antes do nome do método.Key.UNKNOWNkey@Override

Exemplos de uso desses métodos:

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;
import com.codegym.engine.cell.Key;

public class MySuperGame extends Game {
   @Override
   public void initialize() {
      // Set the size of the playing field to 3x3
      setScreenSize(3, 3);

      // Paint the playing field white
      for (int x = 0; x < 3; x++) {
         for (int y = 0; y < 3; y++) {
            setCellColor(x, y, Color.WHITE);
         }
      }
   }

   @Override
   public void onKeyPress(Key key) {
      // When the spacebar is pressed, the center cell turns yellow
      if (key == Key.SPACE) {
         setCellColor(1, 1, Color.YELLOW);
      }
   }

   @Override
   public void onKeyReleased(Key key) {
      // When the spacebar is released, the center cell returns to white
      if (key == Key.SPACE) {
         setCellColor(1, 1, Color.WHITE);
      }
   }
}

4. Lista de todas as chaves suportadas

Quando o mecanismo CodeGym chama os métodos onKeyPress()e onKeyReleased(), ele passa informações para eles sobre a tecla pressionada (liberada). Para fazer isso, o mecanismo CodeGym possui um tipo especial chamado Key.

Na versão atual do mecanismo, o Keytipo suporta apenas um conjunto limitado de 9 valores:

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Se o jogador pressionar a barra de espaço, o onKeyPress()método será chamado com Key.SPACEo parâmetro. Se o usuário pressionar a seta para a esquerda, o parâmetro será Key.LEFT. Se o usuário pressionar qualquer tecla que não esteja na lista acima, o onKeyPress()método será chamado com Key.UNKNOWNo parâmetro.

A questão aqui é que os jogos CodeGym existentes foram projetados para rodar em um telefone. Ao invés do teclado padrão, temos 8 botões virtuais:

5. Trabalhando com um cronômetro

Muitos jogos acontecem em tempo real, ou seja, o usuário pode não fazer nada, mas certos eventos ainda ocorrem no jogo. Para permitir que você implemente esses jogos, adicionamos um cronômetro ao mecanismo do jogo.

Funciona assim: você liga o cronômetro e define o tempo após o qual ele deve ser acionado. Por exemplo, 500 ms. Então, a cada meio segundo, o mecanismo de jogo CodeGym chamará o onTurn()método. Um número infinito de vezes - até que o cronômetro seja desligado.

Como você usa um temporizador?

1. Ligue o cronômetro

Para ligar o timer, temos o void setTurnTimer(int timeMs)método. O método recebe como argumento a duração (em milissegundos ou 1/1000s de segundo) do intervalo entre os retornos de chamada. Você só precisa chamar esse método uma vez e o mecanismo do jogo começará a chamar o onTurn()método a cada timeMsmilissegundos.

2. Substitua o onTurn(int)método

Para fazer isso, você deve declarar um void onTurn(int step)método em uma classe que herda a Gameclasse. O mecanismo do jogo chamará esse método. A cada chamada, o engine passa um número sequencial que identifica a chamada do método ( 1, 2, 3, ...).

3. Desligue o cronômetro

Se o cronômetro não for mais necessário, por exemplo, porque o usuário terminou o jogo, ele pode ser desligado. Para fazer isso, basta chamar o stopTurnTimer()método.

4 Acelerar/alterar o temporizador

Em alguns jogos, a frequência dos eventos aumenta regularmente, por isso seria conveniente poder acelerar nosso cronômetro, ou seja, reduzir o tempo entre as chamadas de retorno. E nada poderia ser mais fácil — basta ligar setTurnTimer(int timeMs)novamente com o novo valor e o tempo entre as chamadas para onTurn()mudará.

Exemplo:

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
   ...
   @Override
   public void initialize() {
      // Create a 3x3 playing field
      setScreenSize(3, 3);
      showGrid(false);
      setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);

      setTurnTimer(500); // Turn on the timer. The interval between callbacks is 500ms.
   }

   @Override
   public void onTurn(int step) {
      if (step == 100) {
         stopTurnTimer(); // If this is the 100th callback, then turn off the timer
      }

      if (step % 2 == 1) {
         // If this is an odd calllback, then set the cell background to red
         setCellColor(1, 1, Color.RED);
      } else {
         // If this is an even callback, then set the cell background to blue
         setCellColor(1, 1, Color.BLUE);
      }
   }
   ...
}

Neste exemplo simples, criamos um campo com 3 células por 3 células. Em seguida, ativamos um cronômetro que chamará o onTurn()método a cada meio segundo.

Aqui, a cor da célula central mudará a cada meio segundo. O texto da célula não será alterado. Após 50 segundos (100 retornos de chamada), a cor parará de mudar e o cronômetro será desligado.