Sezione giochi su CodeGym: gestione degli eventi

"Giochi" di CodeGym è una nuova sezione con grandi compiti interessanti in cui crei le tue versioni di giochi popolari. È semplice: ogni progetto di gioco è suddiviso in sottoattività. Completali uno per uno e il gioco è fatto. Puoi condividerlo sui social network e invitare i tuoi amici a giocare. In questo articolo descriveremo in dettaglio i metodi di gestione degli eventi utilizzati per scrivere i giochi.

1. Lavorare con il mouse

Il motore di gioco ha due metodi per lavorare con il mouse:

• void onMouseLeftClick(int x, int y);

• void onMouseRightClick(int x, int y);

Devi semplicemente dichiarare questi metodi nella tua classe che eredita Gamee aggiungere qualsiasi codice tu voglia a loro. Il motore di gioco li chiamerà quando l'utente fa clic sui pulsanti del mouse.

1. onMouseLeftClick(int x, int y)— chiamato dal motore quando si fa clic con il pulsante sinistro del mouse. I suoi parametri sono le coordinate della cella del campo di gioco in cui si è verificato il clic. La cella in alto a sinistra ha le coordinate (0, 0). È necessario eseguire l'override di questo metodo per utilizzarlo.

2. onMouseRightClick(int x, int y)— chiamato quando si fa clic con il pulsante destro del mouse. Questo metodo funziona come il onMouseLeftClick(int x, int y)metodo.

Ecco un esempio di utilizzo di questi metodi:

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) {
        // Set "X" in the cell where the left mouse click occurred
        setCellValue(x, y, "X");
    }

    @Override
    public void onMouseRightClick(int x, int y) {
        // Clear the cell where the right mouse click occurred
        setCellValue(x, y, "");
    }
}

2. Lavorare con la tastiera

Il motore di gioco ha due metodi per lavorare con la tastiera:

• void onKeyPress(Key key);

• void onKeyReleased(Key key);

Se vuoi che accada qualcosa quando l'utente preme un tasto, dichiara questi metodi nella tua classe che eredita Game e aggiungi il tuo codice a loro. Il motore di gioco li chiamerà quando l'utente preme o rilascia un tasto.

1. onKeyPress(Key key)— chiamato quando viene premuto un tasto qualsiasi. Il parametro chiave è il tasto premuto (o Key.UNKNOWN).

2. onKeyReleased(Key key)- chiamato quando viene rilasciato un tasto qualsiasi. Il parametro chiave è la chiave corrispondente (o Key.UNKNOWN).

Ecco un esempio di utilizzo di questi metodi:

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 space bar is pressed, the center cell turns yellow
        if (key == Key.SPACE) {
            setCellColor(1, 1, Color.YELLOW);
        }
    }

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

Importante! Nella versione attuale del motore di gioco, il tipo di chiave ha un set limitato di nove valori:

3. Lavorare con il timer

Molti giochi avvengono in tempo reale, cioè anche se l'utente non fa nulla, gli eventi si verificano comunque nel gioco. Per consentirti di implementare tali giochi, abbiamo aggiunto un timer al motore di gioco. Funziona in questo modo: accendi il timer e imposti l'intervallo del timer. Ad esempio, 500 millisecondi. Quindi, ogni mezzo secondo il motore di gioco chiama il onTurnTimer()metodo. Ancora e ancora per sempre, finché il timer non viene spento. Quindi come si usa il timer?

1. Attiva il timer.

   Per fare questo, c'è un metodo speciale. Il metodo prende come argomento l'intervallo tra le chiamate in millisecondi (1 millisecondo = 1/1000 di secondo). Devi solo chiamarlo una volta e il motore di gioco inizierà a chiamare il metodo ogni volta Ms millisecondi.void setTurnTimer(int timeMs)onTurn()

2. Eseguire l'override del metodo onTurn(int).

   Per fare ciò, devi dichiarare un metodo nella classe che eredita . Questo metodo verrà chiamato dal motore di gioco. Inoltre, ad ogni chiamata il motore di gioco passerà al metodo un identificatore sequenziale per la chiamata (1, 2, 3, …).void onTurn(int step)Game

3. Spegnere il timer.

   Se il timer non è più necessario, ad esempio quando l'utente completa il gioco, puoi disattivarlo. Per fare ciò, devi semplicemente chiamare il metodo.stopTurnTimer()

4. Accelerare o modificare il timer.

   In alcuni giochi, la velocità con cui si verificano gli eventi è in costante accelerazione, quindi sarebbe conveniente accelerare il nostro timer (ridurre il tempo tra le chiamate). Niente di più semplice: chiama setTurnTimer(int timeMs)ancora una volta con un nuovo valore e il tempo tra onTurn()le chiamate cambierà.

Per esempio:

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

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

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

    @Override
    public void onTurn(int step) {
        if(step == 100) {
            stopTurnTimer();  // If 100 calls have been made, turn off the timer
        }

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

        }
    }
    …
}

In questo semplice esempio, abbiamo creato un campo di 3 celle x 3 celle. Quindi abbiamo avviato un timer che chiamerà il onTurn()metodo ogni mezzo secondo. Ogni mezzo secondo, il colore della cella cambierà, ma il suo contenuto non cambierà. Dopo 50 secondi, il colore non cambierà più. È tutto per ora! Se vuoi saperne di più sulla sezione "Giochi", ecco una documentazione utile che può aiutarti: