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 Game
classe. 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 @Override
anotaçã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 Game
classe.
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.UNKNOWN
key
@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.UNKNOWN
key
@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 Key
tipo suporta apenas um conjunto limitado de 9 valores:
Valor | O que o usuário pressionou |
---|---|
|
O usuário pressionou a tecla Enter |
|
O usuário pressionou a tecla Esc |
|
O usuário pressionou a tecla Pause |
|
O usuário pressionou a tecla de espaço |
|
O usuário pressionou a tecla de seta para a esquerda |
|
O usuário pressionou a tecla de seta para a direita |
|
O usuário pressionou a tecla Seta para cima |
|
O usuário pressionou a tecla Seta para baixo |
|
Qualquer chave diferente das listadas acima |
Se o jogador pressionar a barra de espaço, o onKeyPress()
método será chamado com Key.SPACE
o 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.UNKNOWN
o 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 timeMs
milissegundos.
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 Game
classe. 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.
GO TO FULL VERSION