Gestione degli eventi

1. Introduzione

Un motore di gioco sarebbe di scarsa utilità se potessimo usarlo solo per disegnare qualcosa sullo schermo. Per scrivere un gioco a tutti gli effetti, abbiamo bisogno che interagisca con l'utente! Per essere più precisi, il nostro programma dovrebbe tenere traccia delle azioni dell'utente e rispondere ad esse.

Per fare ciò, il motore di gioco CodeGym dispone di metodi speciali che chiama quando l'utente fa clic sui pulsanti del mouse o sui tasti della tastiera.

Il punto della classe è che tu scrivi questi metodi da solo, e quindi il motore di gioco CodeGym è responsabile della loro chiamata. Tutto ciò di cui hai bisogno è dichiarare questi metodi nel tuo codice. Questo è più facile da fare di quanto sembri.

2. 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)

Dichiari semplicemente questi metodi nella tua classe che eredita la Gameclasse. E poi scrivi il codice che vuoi in questi metodi. Il motore di gioco chiamerà questi metodi quando l'utente fa clic sui pulsanti del mouse.

onMouseLeftClick(int x, int y)viene richiamato 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. Le coordinate della cella in alto a sinistra sono (0,0). Per utilizzare questo metodo, è necessario sovrascriverlo, posizionando l' @Overrideannotazione prima del nome del metodo.

onMouseRightClick(int x, int y)viene chiamato quando si fa clic con il pulsante destro del mouse . Funziona in modo simile al onMouseLeftClick(int x, int y)metodo.

Esempi 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) {
      // 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, "");
   }
}

Nell'esempio precedente, abbiamo dichiarato entrambi i metodi: onMouseLeftClick()e onMouseRightClick(). Il primo metodo verrà chiamato quando l'utente fa clic con il pulsante sinistro del mouse sulle celle del campo di gioco. Il secondo metodo verrà chiamato quando si fa clic con il pulsante destro del mouse.

Come argomenti, il motore di gioco CodeGym passerà le (x, y)coordinate della cella del campo di gioco in cui è stato fatto clic con il mouse.

3. 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 fare qualcosa quando l'utente preme un tasto, devi solo dichiarare questi metodi nella tua classe che eredita la Gameclasse.

Scrivi il tuo codice in questi metodi e il motore di gioco li chiamerà quando l'utente preme (o rilascia) un tasto.

onKeyPress(Key key)viene chiamato quando viene premuto un tasto qualsiasi . Il valore del tasto premuto (o ) viene passato al metodo come parametro. Per utilizzare questo metodo, è necessario sovrascriverlo, posizionando l' annotazione prima del nome del metodo.Key.UNKNOWNkey@Override

onKeyReleased(Key key)viene chiamato quando viene rilasciato un tasto qualsiasi . Il valore della chiave corrispondente (o ) viene assegnato al parametro. Per utilizzare questo metodo, è necessario sovrascriverlo, posizionando l' annotazione prima del nome del metodo.Key.UNKNOWNkey@Override

Esempi 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 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. Elenco di tutte le chiavi supportate

Quando il motore CodeGym chiama i metodi onKeyPress()e onKeyReleased(), passa loro informazioni sul tasto premuto (rilasciato). Per fare questo, il motore CodeGym ha un tipo speciale chiamato Key.

Nella versione corrente del motore, il Keytipo supporta solo un set limitato di 9 valori:

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Se il giocatore preme la barra spaziatrice, il onKeyPress()metodo verrà chiamato con Key.SPACEcome parametro. Se l'utente preme la freccia sinistra, il parametro sarà Key.LEFT. Se l'utente preme un tasto che non è nell'elenco sopra, il onKeyPress()metodo verrà chiamato con Key.UNKNOWNcome parametro.

Il problema qui è che i giochi CodeGym esistenti sono stati progettati per funzionare su un telefono. Al posto della tastiera standard, abbiamo 8 pulsanti virtuali:

5. Lavorare con un timer

Molti giochi si svolgono in tempo reale, ovvero l'utente potrebbe non fare nulla, ma alcuni eventi si verificano comunque nel gioco. Per consentirti di implementare tali giochi, abbiamo aggiunto un timer al motore di gioco.

Ecco come funziona: accendi il timer e imposti l'ora dopo la quale dovrebbe essere attivato. Ad esempio, 500 ms. Quindi, ogni mezzo secondo, il motore di gioco CodeGym chiamerà il onTurn()metodo. Un numero infinito di volte, finché il timer non viene spento.

Come si usa un timer?

1. Attiva il timer

Per attivare il timer, abbiamo il void setTurnTimer(int timeMs)metodo. Il metodo prende come argomento la durata (in millisecondi o 1/1000 di secondo) dell'intervallo tra le richiamate. Devi solo chiamare questo metodo una volta e il motore di gioco inizierà a chiamare il onTurn()metodo ogni timeMsmillisecondo.

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

Per fare ciò, devi dichiarare un void onTurn(int step)metodo in una classe che erediti la Gameclasse. Il motore di gioco chiamerà questo metodo. Ad ogni chiamata, il motore passa un numero sequenziale che identifica la chiamata al metodo ( 1, 2, 3, ...).

3. Spegnere il timer

Se il timer non è più necessario, ad esempio perché l'utente ha terminato il gioco, può essere disattivato. Per fare ciò, basta chiamare il stopTurnTimer()metodo.

4 Accelerare/modificare il timer

In alcuni giochi la frequenza degli eventi aumenta regolarmente, quindi sarebbe comodo poter velocizzare il nostro timer, ovvero ridurre il tempo tra le richiamate. E niente potrebbe essere più semplice: chiama setTurnTimer(int timeMs)di nuovo con il nuovo valore e il tempo tra le chiamate a onTurn()cambierà.

Esempio:

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

In questo semplice esempio, abbiamo creato un campo di 3 celle per 3 celle. Quindi abbiamo attivato un timer che chiamerà il onTurn()metodo ogni mezzo secondo.

Qui, il colore della cella centrale cambierà ogni mezzo secondo. Il testo della cella non cambierà. Dopo 50 secondi (100 richiamate), il colore smetterà di cambiare e il timer si spegnerà.