Spielebereich auf CodeGym: Event-Handling

„Spiele“ von CodeGym ist ein neuer Abschnitt mit großen interessanten Aufgaben, in denen Sie Ihre eigenen Versionen beliebter Spiele erstellen. Es ist ganz einfach: Jedes Spielprojekt ist in Teilaufgaben unterteilt. Schließe sie einzeln ab und das Spiel ist beendet. Sie können es in sozialen Netzwerken teilen und Ihre Freunde zum Spielen einladen. In diesem Artikel beschreiben wir ausführlich die Methoden zur Ereignisbehandlung , die zum Schreiben von Spielen verwendet werden.

1. 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 Klasse, die sie erbt Game, und fügen ihnen den gewünschten Code hinzu. Die Spiel-Engine ruft sie auf, wenn der Benutzer mit den Maustasten klickt.

1. onMouseLeftClick(int x, int y)– Wird von der Engine aufgerufen, wenn mit der linken Maustaste geklickt wird. Seine Parameter sind die Koordinaten der Zelle des Spielfelds, in der der Klick erfolgt ist. Die Zelle oben links hat die Koordinaten (0, 0). Sie müssen diese Methode überschreiben, um sie verwenden zu können.

2. onMouseRightClick(int x, int y)— wird aufgerufen, wenn mit der rechten Maustaste geklickt wird. Diese Methode funktioniert wie die onMouseLeftClick(int x, int y)Methode.

Hier ist ein Beispiel 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) {
        // 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. 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 möchten, dass etwas passiert, wenn der Benutzer eine Taste drückt, deklarieren Sie diese Methoden in Ihrer Klasse, die Game erbt, und fügen Sie ihnen Ihren Code hinzu. Die Spiel-Engine ruft sie auf, wenn der Benutzer eine Taste drückt oder loslässt.

1. onKeyPress(Key key)— wird aufgerufen, wenn eine beliebige Taste gedrückt wird. Der Schlüsselparameter ist die gedrückte Taste (oder Key.UNKNOWN).

2. onKeyReleased(Key key)– wird aufgerufen, wenn eine beliebige Taste losgelassen wird. Der Schlüsselparameter ist der entsprechende Schlüssel (oder Key.UNKNOWN).

Hier ist ein Beispiel 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 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);
        }
    }
}

Wichtig! In der aktuellen Version der Spiel-Engine verfügt der Schlüsseltyp über einen begrenzten Satz von neun Werten:

3. Arbeiten mit dem Timer

Viele Spiele finden in Echtzeit statt, d. h. auch wenn der Benutzer nichts tut, passieren dennoch Ereignisse im Spiel. Um Ihnen die Umsetzung solcher Spiele zu ermöglichen, haben wir der Spiel-Engine einen Timer hinzugefügt. Das funktioniert ungefähr so: Sie schalten den Timer ein und stellen das Timer-Intervall ein. Beispiel: 500 Millisekunden. Dann ruft die Spiel-Engine jede halbe Sekunde die onTurnTimer()Methode auf. Immer und immer wieder – bis der Timer ausgeschaltet wird. Wie nutzt man den Timer?

1. Schalten Sie den Timer ein.

   Dafür gibt es eine spezielle Methode. Als Argument verwendet die Methode das Intervall zwischen Aufrufen in Millisekunden (1 Millisekunde = 1/1000 Sekunde). Sie müssen es nur einmal aufrufen, und die Spiel-Engine ruft die Methode alle Millisekunden auf.void setTurnTimer(int timeMs)onTurn()

2. Überschreiben Sie die Methode onTurn(int).

   Dazu müssen Sie in der erbenden Klasse eine Methode deklarieren . Diese Methode wird von der Spiel-Engine aufgerufen. Darüber hinaus übergibt die Spiel-Engine bei jedem Aufruf eine sequentielle Kennung für den Aufruf an die Methode (1, 2, 3, …).void onTurn(int step)Game

3. Schalten Sie den Timer aus.

   Wenn der Timer nicht mehr benötigt wird, beispielsweise wenn der Benutzer das Spiel beendet, können Sie ihn deaktivieren. Dazu müssen Sie lediglich die Methode aufrufen.stopTurnTimer()

4. Beschleunigen oder ändern Sie den Timer.

   In einigen Spielen beschleunigt sich die Geschwindigkeit, mit der Ereignisse auftreten, ständig, daher wäre es praktisch, unseren Timer zu beschleunigen (die Zeit zwischen Aufrufen zu reduzieren). Nichts einfacher als das: Rufen Sie setTurnTimer(int timeMs)noch einmal mit einem neuen Wert auf, und die Zeit zwischen onTurn()den Aufrufen ändert sich.

Zum Beispiel:

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 diesem einfachen Beispiel haben wir ein Feld erstellt, das 3 Zellen x 3 Zellen groß ist. Dann haben wir einen Timer gestartet, der die Methode jede halbe Sekunde aufruft onTurn(). Jede halbe Sekunde ändert sich die Farbe der Zelle, der Inhalt ändert sich jedoch nicht. Nach 50 Sekunden ändert sich die Farbe nicht mehr. Das ist alles für jetzt! Wenn Sie mehr über den Abschnitt „Spiele“ erfahren möchten, finden Sie hier einige nützliche Dokumentationen, die Ihnen helfen können: