Handhabung des Events

1. Einleitung

Eine Spiel-Engine würde wenig nützen, wenn wir damit nur etwas auf den Bildschirm zeichnen könnten. Um ein vollwertiges Spiel zu schreiben, müssen wir mit dem Benutzer interagieren! Genauer gesagt sollte unser Programm Benutzeraktionen verfolgen und darauf reagieren.

Zu diesem Zweck verfügt die CodeGym-Spiel-Engine über spezielle Methoden, die sie aufruft, wenn der Benutzer auf die Maustasten oder Tastaturtasten klickt.

Der Sinn des Kurses besteht darin, dass Sie diese Methoden selbst schreiben und dann die CodeGym-Spiel-Engine dafür verantwortlich ist, sie aufzurufen. Sie müssen diese Methoden lediglich in Ihrem Code deklarieren. Das ist einfacher, als es sich anhört.

2. Arbeiten mit der Maus

Die Spiel-Engine verfügt über zwei Methoden zum Arbeiten mit der Maus:

void onMouseLeftClick(int x, int y)

void onMouseRightClick(int x, int y)

Sie deklarieren diese Methoden einfach in Ihrer eigenen Klasse, die die GameKlasse erbt. Und schreiben Sie dann in diese Methoden den gewünschten Code. Die Spiel-Engine ruft diese Methoden auf, wenn der Benutzer mit den Maustasten klickt.

onMouseLeftClick(int x, int y)wird von der Engine aufgerufen, wenn die linke Maustaste gedrückt wird. Seine Parameter sind die Koordinaten der Zelle des Spielfelds, in der der Klick erfolgt ist. Die Koordinaten der oberen linken Zelle sind (0,0). Um diese Methode zu verwenden, müssen Sie sie überschreiben, indem Sie die @OverrideAnmerkung vor dem Methodennamen platzieren.

onMouseRightClick(int x, int y)wird aufgerufen, wenn mit der rechten Maustaste geklickt wird. Es funktioniert ähnlich wie die onMouseLeftClick(int x, int y)Methode.

Beispiele für die Verwendung dieser Methoden:

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

Im obigen Beispiel haben wir beide Methoden deklariert: onMouseLeftClick()und onMouseRightClick(). Die erste Methode wird aufgerufen, wenn der Benutzer mit der linken Maustaste auf Zellen des Spielfelds klickt. Die zweite Methode wird aufgerufen, wenn mit der rechten Maustaste geklickt wird.

Als Argumente übergibt die CodeGym-Spiel-Engine die (x, y)Koordinaten der Zelle des Spielfelds, auf die mit der Maus geklickt wurde.

3. Arbeiten mit der Tastatur

Die Spiel-Engine verfügt über zwei Methoden zum Arbeiten mit der Tastatur:

void onKeyPress(Key key);

void onKeyReleased(Key key);

Wenn Sie etwas tun möchten, wenn der Benutzer eine Taste drückt, müssen Sie diese Methoden lediglich in Ihrer Klasse deklarieren, die die GameKlasse erbt.

Sie schreiben Ihren Code mit diesen Methoden und die Spiel-Engine ruft sie auf, wenn der Benutzer eine Taste drückt (oder loslässt).

onKeyPress(Key key)wird aufgerufen, wenn eine beliebige Taste gedrückt wird . Der Wert der gedrückten Taste (oder ) wird als Parameter an die Methode übergeben . Um diese Methode zu verwenden, müssen Sie sie überschreiben, indem Sie die Anmerkung vor dem Methodennamen platzieren.Key.UNKNOWNkey@Override

onKeyReleased(Key key)wird aufgerufen, wenn eine beliebige Taste losgelassen wird . Dem Parameter wird der Wert des entsprechenden Schlüssels (oder ) zugewiesen . Um diese Methode zu verwenden, müssen Sie sie überschreiben, indem Sie die Anmerkung vor dem Methodennamen platzieren.Key.UNKNOWNkey@Override

Beispiele für die Verwendung dieser Methoden:

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. Liste aller unterstützten Schlüssel

onKeyPress()Wenn die CodeGym-Engine die Methoden und aufruft onKeyReleased(), übergibt sie ihnen Informationen über die gedrückte (losgelassene) Taste. Zu diesem Zweck verfügt die CodeGym-Engine über einen speziellen Typ namens Key.

In der aktuellen Version der Engine Keyunterstützt der Typ nur einen begrenzten Satz von 9 Werten:

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Wenn der Spieler die Leertaste drückt, wird die Methode mit dem Parameter onKeyPress()aufgerufen . Key.SPACEWenn der Benutzer den linken Pfeil drückt, lautet der Parameter Key.LEFT. Wenn der Benutzer eine Taste drückt, die nicht in der obigen Liste enthalten ist, wird die Methode mit dem Parameter onKeyPress()aufgerufen .Key.UNKNOWN

Das Problem hierbei ist, dass die vorhandenen CodeGym-Spiele für die Ausführung auf einem Telefon konzipiert sind. Anstelle der Standardtastatur haben wir 8 virtuelle Tasten:

5. Arbeiten mit einem Timer

Viele Spiele finden in Echtzeit statt, d. h. der Benutzer tut möglicherweise nichts, bestimmte Ereignisse finden jedoch dennoch im Spiel statt. Um Ihnen die Umsetzung solcher Spiele zu ermöglichen, haben wir der Spiel-Engine einen Timer hinzugefügt.

So funktioniert es: Sie schalten den Timer ein und stellen die Zeit ein, nach der er ausgelöst werden soll. Zum Beispiel 500 ms. Dann ruft die CodeGym-Spiel-Engine jede halbe Sekunde die onTurn()Methode auf. Unendlich oft – bis der Timer ausgeschaltet wird.

Wie benutzt man einen Timer?

1. Schalten Sie den Timer ein

Um den Timer einzuschalten, haben wir die void setTurnTimer(int timeMs)Methode. Die Methode verwendet als Argument die Dauer (in Millisekunden oder 1/1000 Sekunde) des Intervalls zwischen Rückrufen. Sie müssen diese Methode nur einmal aufrufen, und die Spiel-Engine beginnt onTurn()alle timeMsMillisekunden, die Methode aufzurufen.

2. Überschreiben Sie die onTurn(int)Methode

Dazu müssen Sie eine void onTurn(int step)Methode in einer Klasse deklarieren, die die GameKlasse erbt. Die Spiel-Engine ruft diese Methode auf. Bei jedem Aufruf übergibt die Engine eine fortlaufende Nummer, die den Methodenaufruf identifiziert ( 1, 2, 3, ...).

3. Schalten Sie den Timer aus

Wenn der Timer nicht mehr benötigt wird, beispielsweise weil der Benutzer das Spiel beendet hat, kann er ausgeschaltet werden. Rufen Sie dazu einfach die stopTurnTimer()Methode auf.

4 Beschleunigen/ändern Sie den Timer

In manchen Spielen nimmt die Häufigkeit von Ereignissen regelmäßig zu, daher wäre es praktisch, unseren Timer beschleunigen zu können, also die Zeit zwischen Rückrufen zu verkürzen. Und nichts könnte einfacher sein – rufen Sie einfach setTurnTimer(int timeMs)erneut mit dem neuen Wert an, und die Zeit zwischen den Aufrufen onTurn()ändert sich.

Beispiel:

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 diesem einfachen Beispiel haben wir ein Feld erstellt, das 3 mal 3 Zellen groß ist. Dann haben wir einen Timer eingeschaltet, der die Methode jede halbe Sekunde aufruft onTurn().

Dabei ändert sich die Farbe der zentralen Zelle jede halbe Sekunde. Der Text der Zelle ändert sich nicht. Nach 50 Sekunden (100 Rückrufe) ändert sich die Farbe nicht mehr und der Timer wird ausgeschaltet.