Sezione giochi su CodeGym: motore di gioco

"Giochi" di CodeGym è una nuova sezione con grandi compiti che comportano la scrittura di famosi giochi per computer. Sono più facili da creare di quanto sembri: ogni progetto è suddiviso in venti sottoattività. Completando le attività passo dopo passo, scriverai il tuo gioco, quindi potrai aggiungere funzionalità uniche e condividerlo con gli amici. I giochi utilizzano il semplice motore di gioco CodeGym . In questo articolo, descriveremo le sue caratteristiche principali e come si presenta il processo di scrittura del gioco.

1. Introduzione

Per lo sviluppatore, ci sono tre fasi per l'implementazione di un gioco per computer:

1. Inizializzazione del gioco — Questa fase consiste in azioni preparatorie: impostare le dimensioni del campo di gioco, disegnare il campo di gioco, creare oggetti di gioco e metterli nelle loro posizioni iniziali e altre azioni che devono essere eseguite all'inizio del gioco.

2. Processo di gioco. Questa fase include lo spostamento di oggetti di gioco, le azioni del giocatore, il mantenimento del punteggio e altre azioni che devono essere eseguite a una certa frequenza o quando vengono premuti i pulsanti.

3. Completamento del gioco. Questa fase include l'interruzione dell'animazione, la segnalazione di una vittoria o di una sconfitta e altre azioni che devono essere eseguite alla fine del gioco.

2. Inizializzazione del gioco

L'inizializzazione del gioco consiste in due sole fasi: Fase 1: creare la classe principale del gioco. Per sviluppare il tuo gioco utilizzando il motore di gioco CodeGym, devi creare una classe che erediti la Gameclasse (com.codegym.engine.cell.Game). Questo dà alla tua classe la possibilità di chiamare i metodi del motore di gioco e dà al motore la possibilità di chiamare i tuoi metodi. Per esempio:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Passaggio 2: eseguire l'override del metodo initialize(). Tutte le azioni necessarie per avviare il gioco avverranno in questo metodo: creazione del campo di gioco, creazione di oggetti di gioco, ecc. Devi semplicemente dichiarare questo metodo nella classe che eredita la Gameclasse. Per esempio:

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

Il initialize()metodo è analogo al main()metodo: è il punto di partenza per tutto il codice scritto per il gioco.

3. Creazione di un campo di gioco

Anche la creazione di un campo di gioco consiste in due soli passaggi. Passaggio 1: dividere il campo di gioco in celle. L'intero campo di gioco è diviso in celle dal motore di gioco. La dimensione minima è 3x3; il massimo è 100x100. Le dimensioni dello schermo di gioco sono costanti. Può essere diviso in diversi numeri di celle. Ad esempio, 7 celle di larghezza per 9 celle di altezza: si noti che le celle sono numerate a partire dall'angolo in alto a sinistra. Per impostare la dimensione del campo di gioco, utilizzare il void setScreenSize(int width, int height)metodo. Imposta la dimensione del campo di gioco. I suoi parametri rappresentano il numero di celle orizzontalmente (larghezza) e verticalmente (altezza). Di solito viene chiamato una volta all'inizio del gioco. Per esempio:

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

Quando si scrive un gioco, potrebbe essere necessario ottenere la larghezza e l'altezza attuali del campo di gioco. Per fare ciò, i metodi int getScreenWidth()e int getScreenHeight()torneranno utili. Passaggio 2: attiva o disattiva la griglia (facoltativo). Se non ti piace la griglia nera che separa le celle sul campo di gioco, puoi disattivarla. Il void showGrid(boolean isShow)metodo attiva e disattiva la griglia. Per impostazione predefinita, viene visualizzata la griglia. Per disattivarlo, chiama questo metodo con false come argomento:

showGrid(false);

Risultato: per riattivare la rete, chiamare:

showGrid(true);

4. Un programma primitivo

Ecco un esempio di programma:

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

In questo esempio, il campo di gioco è impostato su 3x3, la griglia è disattivata e una "X" arancione pari a metà della dimensione della cella è impostata su uno sfondo blu nella cella centrale. Questa sarà la prima cosa che il giocatore vedrà all'inizio del gioco.

5. Lavorare con le cellule del campo di gioco

Il fatto che possiamo dividere il campo di gioco in celle è fantastico, ma cosa possiamo fare con le celle stesse? Puoi impostare le seguenti proprietà per ogni cella del campo di gioco:

• colore della cella (colore di sfondo della cella);
• testo (testo o numero);
• colore del testo;
• dimensione del testo come percentuale della dimensione della cella.

Diamo un'occhiata ai metodi per lavorare con le celle del campo di gioco :

1. void setCellColor(int x, int y, Color color)— imposta il colore della cella con le coordinate (x, y):

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




2. Color getCellColor(int x, int y)— restituisce il colore della cella con coordinate (x, y):

   Color myColor = getCellColor(2, 0);




3. void setCellValue(int x, int y, String value)— imposta il testo della cella con coordinate (x, y) uguale alla stringa nel parametro value:

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




4. String getCellValue(int x, int y)— restituisce il testo contenuto nella cella con coordinate (x, y):

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




5. void setCellTextSize(int x, int y, int size)— imposta la dimensione del contenuto della cella con coordinate (x, y). Il parametro size è l'altezza del testo come percentuale dell'altezza della cella:

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




6. int getCellTextSize(int x, int y)— restituisce la dimensione del contenuto della cella con coordinate (x, y):

   int size = getCellTextSize(2 , 0);




7. void setCellNumber(int x, int y, int value)— imposta il testo della cella con coordinate (x, y) uguale al numero nel parametro value:

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




8. int getCellNumber(int x, int y)— restituisce il numero contenuto nella cella con coordinate (x, y). Se la cella non contiene un numero, restituisce 0:

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




9. void setCellTextColor(int x, int y, Color color)— imposta il colore del contenuto (testo) della cella con coordinate (x, y):

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




10. Color getCellTextColor(int x, int y)— restituisce il colore del contenuto (testo) della cella con coordinate (x, y):

    Color textColor = getCellTextColor(1, 3);

Per comodità, esistono diversi setCellValueEx()metodi con diversi set di parametri:

1. void setCellValueEx(int x, int y, Color cellColor, String value)— imposta il colore di sfondo (cellColor) e il contenuto (valore) della cella con le coordinate (x, y):

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




2. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— imposta il colore di sfondo (cellColor), il contenuto (value) e il colore del testo (textColor) della cella con le coordinate (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)— imposta il colore di sfondo (cellColor), il contenuto (value), il colore del testo (textColor) e la dimensione del testo (textSize) della cella con le coordinate (x, y):

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

6. Lavorare con il colore

è Color enumresponsabile dei colori nel motore di gioco. Ha valori univoci per 148 colori. Ha anche un valore speciale (NESSUNO) che non rappresenta alcun colore. Ecco un esempio di come lavorare con il colore:

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.

A volte potrebbe essere necessario ottenere una matrice di tutti i colori esistenti. Per fare questo, usa il values()metodo. Per esempio:

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

È molto facile ottenere l'indice di un colore nella tavolozza:

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

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

Puoi anche ottenere un colore dal suo indice:

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

7. Finestre di dialogo

Alla fine del gioco, devi segnalare una vittoria o una sconfitta al giocatore. Per fare ciò, esiste un metodo speciale che visualizza una finestra di dialogo sullo schermo del gioco:

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

Qui:

• cellColorè il colore di sfondo della finestra di dialogo;
• messageè il testo del messaggio;
• textColorè il colore del testo del messaggio;
• textSizeè la dimensione del testo del messaggio.

La finestra di dialogo si chiude da sola se l'utente preme la barra spaziatrice.

8. Metodi di utilità

Quando si scrivono giochi, i numeri casuali vengono usati molto. Per semplificare l'ottenimento di numeri casuali, puoi utilizzare i seguenti metodi di utilità forniti dal motore di gioco:

1. int getRandomNumber(int max)— restituisce un numero intero casuale compreso tra 0 e (max-1) incluso.

2. int getRandomNumber(int min, int max)— restituisce un numero intero casuale da min a (max-1) incluso.

È tutto per ora! Se vuoi saperne di più sulla sezione "Giochi", ecco una documentazione utile che può aiutarti: