Seção de jogos no CodeGym: mecanismo de jogo

"Jogos" do CodeGym é uma nova seção com grandes tarefas que envolvem escrever jogos de computador populares. Eles são mais fáceis de criar do que parece: cada projeto é dividido em vinte subtarefas. Completando as tarefas passo a passo, você escreverá seu próprio jogo e poderá adicionar recursos exclusivos e compartilhá-lo com amigos. Os jogos usam o mecanismo de jogo CodeGym simples . Neste artigo, descreveremos seus principais recursos e como é o processo de criação do jogo.

1. Introdução

Para o desenvolvedor, existem três etapas para a implementação de um jogo de computador:

1. Inicialização do jogo — Esta etapa consiste em ações preparatórias: definir o tamanho do campo de jogo, desenhar o campo de jogo, criar os objetos do jogo e colocá-los em suas posições iniciais e outras ações que devem ser executadas no início do jogo.

2. Processo do jogo. Este estágio inclui mover objetos do jogo, ações do jogador, manter a pontuação e outras ações que devem ser executadas com uma certa frequência ou quando os botões são pressionados.

3. Conclusão do jogo. Esta etapa inclui interromper a animação, relatar uma vitória ou derrota e outras ações que devem ser executadas no final do jogo.

2. Inicialização do jogo

A inicialização do jogo consiste em apenas duas etapas: Etapa 1: Criar a classe principal do jogo. Para desenvolver seu próprio jogo usando o mecanismo de jogo CodeGym, você precisa criar uma classe que herde a Gameclasse (com.codegym.engine.cell.Game). Isso dá à sua classe a capacidade de chamar os métodos do mecanismo de jogo e dá ao mecanismo a capacidade de chamar seus métodos. Por exemplo:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Etapa 2: substitua o método de inicialização (). Todas as ações necessárias para iniciar o jogo acontecerão neste método: criar o campo de jogo, criar objetos do jogo, etc. Basta declarar este método na classe que herda a classe Game. Por exemplo:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
        // Here we perform all actions to initialize the game and its objects
    }
}

O initialize()método é análogo ao main()método: é o ponto de partida para todo o código escrito para o jogo.

3. Criando um campo de jogo

A criação de um campo de jogo também consiste em apenas duas etapas. Passo 1: Divida o campo de jogo em células. Todo o campo de jogo é dividido em células pelo mecanismo do jogo. O tamanho mínimo é 3x3; o máximo é 100x100. As dimensões da tela do jogo são constantes. Pode ser dividido em diferentes números de células. Por exemplo, 7 células de largura por 9 células de altura: observe que as células são numeradas a partir do canto superior esquerdo. Para definir o tamanho do campo de jogo, use o void setScreenSize(int width, int height)método. Ele define o tamanho do campo de jogo. Seus parâmetros representam o número de células na horizontal (largura) e na vertical (altura). Geralmente é chamado uma vez quando o jogo é iniciado. Por exemplo:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
       // Set the field size to 7 cells x 9 cells
       setScreenSize(7, 9);
        ...
    }
}

Ao escrever um jogo, pode ser necessário obter a largura e a altura atuais do campo de jogo. Para fazer isso, os métodos int getScreenWidth()e int getScreenHeight()serão úteis. Etapa 2: ligue ou desligue a grade (opcional). Se você não gosta da grade preta que separa as células no campo de jogo, pode desativá-la. O void showGrid(boolean isShow)método ativa e desativa a grade. Por padrão, a grade é exibida. Para desativá-lo, chame este método com false como argumento:

showGrid(false);

Resultado: para reativar a grade, chame:

showGrid(true);

4. Um programa primitivo

Aqui está um exemplo de um programa:

public class MySuperGame extends Game {

    @Override
    public void initialize() {

        // Create a playing field that is 3 cells x 3 cells
        setScreenSize(3, 3);
        // Turn off the grid
        showGrid(false);
        // Change the background of the center cell to blue, and display an "X" in it.
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);
    }
}

Neste exemplo, o campo do jogo é definido como 3x3, a grade é desativada e um "X" laranja com metade do tamanho da célula é definido em um fundo azul na célula central. Esta será a primeira coisa que o jogador verá quando o jogo começar.

5. Trabalhando com células do campo de jogo

O fato de podermos dividir o campo de jogo em células é ótimo, mas o que podemos fazer com as próprias células? Você pode definir as seguintes propriedades para cada célula do campo de jogo:

• cor da célula (cor de fundo da célula);
• texto (texto ou número);
• cor do texto;
• tamanho do texto como uma porcentagem do tamanho da célula.

Vejamos os métodos para trabalhar com as células do campo de jogo :

1. void setCellColor(int x, int y, Color color)— define a cor da célula com as coordenadas (x, y):

   
   setCellColor(0, 0, Color.RED);
   setCellColor(3, 6, Color.BLACK);
   setCellColor(6, 8, Color.NONE);
   




2. Color getCellColor(int x, int y)— retorna a cor da célula com as coordenadas (x, y):

   
   Color myColor = getCellColor(2, 0);
   




3. void setCellValue(int x, int y, String value)— define o texto da célula com coordenadas (x, y) iguais à string no parâmetro de valor:

   
   setCellValue(3, 3, "text");
   setCellValue(0, 8, "W");
   setCellValue(4, 1, "2222");
   setCellValue(6, 6, "");
   




4. String getCellValue(int x, int y)— retorna o texto contido na célula com as coordenadas (x, y):

   
   String s = getCellValue(3, 3);
   System.out.println(getCellValue(4, 1));
   




5. void setCellTextSize(int x, int y, int size)— define o tamanho do conteúdo da célula com as coordenadas (x, y). O parâmetro de tamanho é a altura do texto como uma porcentagem da altura da célula:

   
   setCellTextSize(2 , 0, 70); // 70% of the cell height
   




6. int getCellTextSize(int x, int y)— retorna o tamanho do conteúdo da célula com coordenadas (x, y):

   
   int size = getCellTextSize(2 , 0);
   




7. void setCellNumber(int x, int y, int value)— define o texto da célula com coordenadas (x, y) iguais ao número no parâmetro de valor:

   
   setCellNumber(3, 3, 40);
   setCellNumber(0, 8, -8);
   setCellNumber(4, 1, 2222);
   setCellNumber(6, 6, 0);
   




8. int getCellNumber(int x, int y)— retorna o número contido na célula com coordenadas (x, y). Se a célula não contiver um número, retorna 0:

   
   int i = getCellNumber(3, 3);
   System.out.println(getCellNumber(4, 1));
   




9. void setCellTextColor(int x, int y, Color color)— define a cor do conteúdo (texto) da célula com coordenadas (x, y):

   
   setCellTextColor(2, 1, Color.GREEN);
   setCellTextColor(0, 1, Color.NONE);
   




10. Color getCellTextColor(int x, int y)— retorna a cor do conteúdo (texto) da célula com coordenadas (x, y):

    
    Color textColor = getCellTextColor(1, 3);
    

Por conveniência, existem vários setCellValueEx()métodos com diferentes conjuntos de parâmetros:

1. void setCellValueEx(int x, int y, Color cellColor, String value)— define a cor de fundo (cellColor) e o conteúdo (valor) da célula com as coordenadas (x, y):

   
   setCellValueEx(0, 2, Color.BLUE, "56");
   




2. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— define a cor de fundo (cellColor), conteúdo (valor) e cor do texto (textColor) da célula com coordenadas (x, y):

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);
   




3. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)— define a cor de fundo (cellColor), conteúdo (valor), cor do texto (textColor) e tamanho do texto (textSize) da célula com coordenadas (x, y):

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);
   

6. Trabalhando com cores

O Color enumé responsável pelas cores no mecanismo do jogo. Tem valores únicos para 148 cores. Ele também possui um valor especial (NONE) que não representa nenhuma cor. Aqui está um exemplo de como trabalhar com cores:

Color myColor = Color.WHITE;  // The myColor variable is set to white.
Color redColor = Color.RED;  // The redColor variable is set to red.
Color blueColor = Color.BLUE;  // The blueColor variable is set to light blue.

Às vezes, pode ser necessário obter uma matriz de todas as cores existentes. Para fazer isso, use o values()método. Por exemplo:

Color[] colors = Color.values();  // The colors variable is assigned an array containing all available colors.

É muito fácil obter o índice de uma cor na paleta:

Color color = Color.RED;
int redIndex = color.ordinal();  // Index of red

int blueIndex = Color.BLUE.ordinal();  // Index of blue

Você também pode obter uma cor por seu índice:

Color color = Color.values()[10];  // The color variable is assigned the color with index 10 in the Color enum.

7. Caixas de diálogo

No final do jogo, você precisa relatar uma vitória ou derrota ao jogador. Para fazer isso, existe um método especial que exibe uma caixa de diálogo na tela do jogo:

void showMessageDialog(Color cellColor, String message, Color textColor, int textSize)

Aqui:

• cellColoré a cor de fundo da caixa de diálogo;
• messageé o texto da mensagem;
• textColoré a cor do texto da mensagem;
• textSizeé o tamanho do texto da mensagem.

A caixa de diálogo fecha sozinha se o usuário pressionar a barra de espaço.

8. Métodos utilitários

Ao escrever jogos, números aleatórios são muito usados. Para facilitar a obtenção de números aleatórios, você pode usar os seguintes métodos utilitários fornecidos pelo mecanismo do jogo:

1. int getRandomNumber(int max)— retorna um número inteiro aleatório de 0 a (max-1) inclusive.

2. int getRandomNumber(int min, int max)— retorna um número inteiro aleatório de min a (max-1) inclusive.

É tudo por agora! Se você quiser saber mais sobre a seção "Jogos", aqui está uma documentação útil que pode ajudar: