Seção "Jogos" no JavaRush: mecanismo de jogo

“Jogos” do JavaRush é uma nova seção que contém grandes projetos de tarefas para escrever jogos de computador populares. Fazê-los é mais fácil do que parece: cada projeto é dividido em duas dúzias de subtarefas. Ao completar as tarefas passo a passo, você escreverá seu jogo e poderá adicionar “recursos” exclusivos a ele e compartilhá-lo com amigos. Os jogos usam o mecanismo de jogo simples JavaRush . Neste artigo falaremos sobre seus principais recursos e como é o processo de escrita de um jogo.

1. Introdução
2. Inicialização do jogo
3. Criando um campo de jogo
4. Programa primitivo
5. Trabalhando com as células do campo de jogo
6. Trabalhando com cores
7. Caixa de diálogo
8. Métodos utilitários
9. Limitações do mecanismo de jogo

1. Introdução

Existem três etapas na implementação de um jogo de computador por parte do desenvolvedor:

1. A inicialização do jogo consiste em ações preparatórias: definir o tamanho e desenho do campo de jogo, criar e instalar objetos do jogo na posição inicial, entre outras ações que devem ser realizadas no início do jogo.


2. Processo do jogo. Isso inclui o movimento dos objetos do jogo, as ações do jogador, a contabilização dos pontos ganhos, bem como outras ações que devem ser realizadas em determinados intervalos ou pressionando botões.


3. Terminando o jogo. Isso inclui interromper animações, anunciar vitória ou derrota e outras ações que precisam ser realizadas no final do jogo.

2. Inicialização do jogo

A inicialização do jogo consiste em apenas duas etapas:

Passo 1: crie a classe principal do jogo.

Para desenvolver seu jogo baseado no motor de jogo JavaRush, você precisa criar uma classe e herdá-la da classe Game (com.javarush.engine.cell.Game). Isso dará à sua classe a capacidade de chamar métodos no mecanismo de jogo e a capacidade do mecanismo chamar seus métodos. Exemplo:

import com.javarush.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Etapa 2: substitua o método inicialize().

Neste método ocorrerão todas as ações necessárias para iniciar o jogo: criação do campo de jogo, criação de objetos do jogo, etc. Você só precisa declarar esse método em uma classe que herda da classe Game . Exemplo:

import com.javarush.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
        //  Тут выполняем все действия по инициализации игры и ее an objectов
    }
}

O método inicialize() é análogo ao método main() : é onde todo o código escrito para o jogo começa a ser executado.

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 motor de jogo. O tamanho mínimo é 3x3, o máximo é 100x100. A tela do jogo tem um tamanho constante. Pode ser dividido em diferentes números de células. Por exemplo, largura 7 e altura 9: Observe que a numeração das células começa no canto superior esquerdo. Para definir o tamanho do campo de jogo, use o método void setScreenSize(int width, int height) . Ele define o tamanho do campo de jogo. Toma como parâmetros o número de células horizontalmente (largura) e verticalmente (altura). Geralmente é chamado uma vez quando o jogo começa. Exemplo:

import com.javarush.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
       //  задали размер поля 7x9 клеток
       setScreenSize(7, 9);
        ...
    }
}

Ao escrever um jogo, pode ser necessário obter a largura e a altura atuais do campo de jogo. Os métodos int getScreenWidth() e int getScreenHeight() são úteis para isso .

Passo 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 método void showGrid(boolean isShow) ativa e desativa a grade que separa as células. Por padrão, a grade é exibida. Para desligá-lo, chame este método com o parâmetro false:

showGrid(false);

Resultado: Para reativar a grade, ligue:

showGrid(true);

4. Programa primitivo

Exemplo de programa:

public class MySuperGame extends Game {

    @Override
    public void initialize() {

        //  Создаем игровое поле 3x3 клетки
        setScreenSize(3, 3);
        //  Выключаем отображение сетки
        showGrid(false);
        //  Меняем фон центральной клетки на синий, и отображаем в ней “Х”
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);
    }
}

Neste exemplo, o tamanho do campo de jogo é definido como 3x3, a exibição da grade está desativada e um símbolo “X” laranja do tamanho de meia célula é definido no centro em um fundo azul. Esta será a primeira coisa que o jogador verá ao iniciar o jogo.

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? Cada célula do campo de jogo pode ser definida:

• cor da célula (cor de fundo da célula);
• texto (texto ou número);
• cor do texto;
• tamanho do texto como uma porcentagem em relação ao tamanho da célula.

Consideremos métodos para trabalhar com células do campo de jogo :

1. void setCellColor(int x, int y, Color color) — define a cor da célula com 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 coordenadas (x, y):

   Color myColor = getCellColor(2, 0);




3. void setCellValue(int x, int y, String value) - coloca o valor do texto na célula com coordenadas (x, y):

   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 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 coordenadas (x, y). size – altura do texto como uma porcentagem da altura da célula:

   setCellTextSize(2 , 0, 70); //  70% высоты клетки




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) - coloca o valor do número na célula com coordenadas (x, y):

   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) na 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) em uma célula com coordenadas (x, y):

    Color textColor = getCellTextColor(1, 3);

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

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

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




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

   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 célula com coordenadas (x, y), cor de fundo cellColor, valor do conteúdo, cor do conteúdo textColor e tamanho do conteúdo textSize:

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

6. Trabalhando com cores

As cores no mecanismo de jogo são controladas pela enumeração Color , que contém valores exclusivos para 148 cores. E também o valor especial NENHUMA – ausência de cor. Exemplo de trabalho com cores:

Color myColor = Color.WHITE;  //  переменной myColor присваивается белый цвет.
Color redColor = Color.RED; //  переменной redColor присваивается красный цвет.
Color blueColor = Color.BLUE; //  переменной blueColor присваивается синий цвет.

Às vezes você pode querer obter uma matriz de todas as cores existentes. Para fazer isso, use o método valores() . Por exemplo:

//  переменной colors присваивается массив, содержащий все доступные цвета.
Color[] colors = Color.values();

Obter o número da cor na paleta é muito simples:

Color color = Color.RED;
int redIndex = color.ordinal(); //  Номер красного цвета

int blueIndex = Color.BLUE.ordinal(); //  Номер синего цвета

Você também pode obter uma cor pelo seu número:

//  переменной color присваивается цвет с индексом 10 из enum Color.
Color color = Color.values()[10];

7. Caixas de diálogo

Ao final do jogo, o jogador deve ser informado da vitória ou derrota. Existe um método especial para isso que exibe uma caixa de diálogo na tela do jogo:

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

Aqui:

• cellColor — cor de fundo da caixa de diálogo;
• mensagem — texto da mensagem;
• textColor — cor do texto da mensagem;
• textSize — 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

Números aleatórios são frequentemente usados ​​ao escrever jogos. Para facilitar a obtenção de números aleatórios, você pode usar métodos de mecanismo de sucata:

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.

9. Limitações do motor de jogo

Para rodar os jogos no site, eles são traduzidos para JavaScript no servidor. A este respeito, surgem algumas restrições. Em particular, ao escrever jogos usando o mecanismo JavaRush, você não pode trabalhar com arquivos, nem usar todos os métodos da classe System , exceto currentTimeMillis() , setOut() , setErr() , arrayscopy() . Você também pode usar os campos err e out . Ao violar essas restrições, o jogo, é claro, poderá ser compilado e executado, mas não será possível publicar. Você também não poderá publicar um jogo com loops infinitos. Isso é tudo! Se você quiser saber mais sobre a seção Jogos, aqui estão algumas documentações úteis que podem ajudar:

• Seção "Jogos" no JavaRush: perguntas populares
• Seção "Jogos" no JavaRush: Manipulação de Eventos
• Seção "Jogos" no JavaRush: teoria útil