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 Game
classe. 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' @Override
annotazione 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 Game
classe.
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.UNKNOWN
key
@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.UNKNOWN
key
@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 Key
tipo supporta solo un set limitato di 9 valori:
Valore | Ciò che l'utente ha premuto |
---|---|
|
L'utente ha premuto il tasto Invio |
|
L'utente ha premuto il tasto Esc |
|
L'utente ha premuto il tasto Pausa |
|
L'utente ha premuto la barra spaziatrice |
|
L'utente ha premuto il tasto freccia sinistra |
|
L'utente ha premuto il tasto freccia destra |
|
L'utente ha premuto il tasto Freccia su |
|
L'utente ha premuto il tasto freccia giù |
|
Qualsiasi chiave diversa da quelle sopra elencate |
Se il giocatore preme la barra spaziatrice, il onKeyPress()
metodo verrà chiamato con Key.SPACE
come 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.UNKNOWN
come 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 timeMs
millisecondo.
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 Game
classe. 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à.