Spielebereich auf CodeGym: Game Engine

„Spiele“ von CodeGym ist ein neuer Bereich mit großen Aufgaben, bei denen es um das Schreiben beliebter Computerspiele geht. Sie sind einfacher zu erstellen, als es scheint: Jedes Projekt ist in zwanzig Teilaufgaben unterteilt. Indem Sie Aufgaben Schritt für Schritt erledigen, schreiben Sie Ihr eigenes Spiel, können dann einzigartige Funktionen hinzufügen und es mit Freunden teilen. Die Spiele nutzen die einfache CodeGym-Spiel-Engine . In diesem Artikel beschreiben wir die wichtigsten Funktionen und wie der Prozess zum Schreiben von Spielen aussieht.

1. Einleitung

Für den Entwickler gibt es bei der Umsetzung eines Computerspiels drei Phasen:

1. Spielinitialisierung – Diese Phase besteht aus vorbereitenden Aktionen: Festlegen der Größe des Spielfelds, Zeichnen des Spielfelds, Erstellen von Spielobjekten und deren Platzierung an ihren Anfangspositionen sowie andere Aktionen, die zu Beginn des Spiels ausgeführt werden müssen.

2. Spielablauf. Diese Phase umfasst das Bewegen von Spielobjekten, Spieleraktionen, das Führen von Spielständen und andere Aktionen, die in einer bestimmten Häufigkeit oder beim Drücken von Tasten ausgeführt werden müssen.

3. Spielabschluss. Diese Phase umfasst das Stoppen der Animation, das Melden eines Gewinns oder Verlusts und andere Aktionen, die am Ende des Spiels ausgeführt werden müssen.

2. Spielinitialisierung

Die Spielinitialisierung besteht aus nur zwei Schritten: Schritt 1: Erstellen Sie die Hauptklasse des Spiels. Um Ihr eigenes Spiel mit der CodeGym-Spiel-Engine zu entwickeln, müssen Sie eine Klasse erstellen, die die GameKlasse erbt (com.codegym.engine.cell.Game). Dies gibt Ihrer Klasse die Möglichkeit, die Methoden der Spiel-Engine aufzurufen, und gibt der Engine die Möglichkeit, Ihre Methoden aufzurufen. Zum Beispiel:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Schritt 2: Überschreiben Sie die Initialisierungsmethode(). Alle zum Starten des Spiels erforderlichen Aktionen werden in dieser Methode ausgeführt: Erstellen des Spielfelds, Erstellen von Spielobjekten usw. Sie müssen diese Methode lediglich in der Klasse deklarieren, die die Klasse erbt Game. Zum Beispiel:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
        // Here we perform all actions to initialize the game and its objects
    }
}

Die initialize()Methode ist analog zur main()Methode: Sie ist der Ausgangspunkt für den gesamten für das Spiel geschriebenen Code.

3. Ein Spielfeld schaffen

Auch das Anlegen eines Spielfeldes besteht aus nur zwei Schritten. Schritt 1: Teilen Sie das Spielfeld in Zellen auf. Das gesamte Spielfeld wird von der Spiel-Engine in Zellen unterteilt. Die Mindestgröße beträgt 3x3; das Maximum beträgt 100x100. Die Abmessungen des Spielbildschirms sind konstant. Es kann in unterschiedlich viele Zellen unterteilt werden. Beispiel: 7 Zellen breit und 9 Zellen hoch: Beachten Sie, dass die Zellen von der oberen linken Ecke beginnend nummeriert werden. Um die Größe des Spielfeldes festzulegen, verwenden Sie die void setScreenSize(int width, int height)Methode. Es legt die Größe des Spielfeldes fest. Seine Parameter stellen die Anzahl der Zellen horizontal (Breite) und vertikal (Höhe) dar. Normalerweise wird es einmal aufgerufen, wenn das Spiel gestartet wird. Zum Beispiel:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
       // Set the field size to 7 cells x 9 cells
       setScreenSize(7, 9);
        ...
    }
}

Wenn Sie ein Spiel schreiben, müssen Sie möglicherweise die aktuelle Breite und Höhe des Spielfelds ermitteln. Zu diesem Zweck sind die Methoden int getScreenWidth()und int getScreenHeight()hilfreich. Schritt 2: Schalten Sie das Gitter ein oder aus (optional). Wenn Ihnen das schwarze Gitter, das die Zellen auf dem Spielfeld trennt, nicht gefällt, können Sie es deaktivieren. Die void showGrid(boolean isShow)Methode schaltet das Raster ein und aus. Standardmäßig wird das Raster angezeigt. Um es zu deaktivieren, rufen Sie diese Methode mit false als Argument auf:

showGrid(false);

Ergebnis: Um das Netz wieder einzuschalten, rufen Sie an:

showGrid(true);

4. Ein primitives Programm

Hier ist ein Beispiel für ein Programm:

public class MySuperGame extends Game {

    @Override
    public void initialize() {

        // Create a playing field that is 3 cells x 3 cells
        setScreenSize(3, 3);
        // Turn off the grid
        showGrid(false);
        // Change the background of the center cell to blue, and display an "X" in it.
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);
    }
}

In diesem Beispiel ist das Spielfeld auf 3x3 eingestellt, das Raster ist ausgeschaltet und in der mittleren Zelle ist ein orangefarbenes „X“ halb so groß wie die Zelle auf einem blauen Hintergrund eingestellt. Dies ist das Erste, was der Spieler sieht, wenn das Spiel beginnt.

5. Arbeiten mit Zellen des Spielfeldes

Die Tatsache, dass wir das Spielfeld in Zellen unterteilen können, ist großartig, aber was können wir mit den Zellen selbst machen? Sie können für jede Zelle des Spielfelds folgende Eigenschaften festlegen:

• Zellenfarbe (Zellenhintergrundfarbe);
• Text (Text oder Zahl);
• Textfarbe;
• Textgröße als Prozentsatz der Zellengröße.

Schauen wir uns die Methoden zum Arbeiten mit den Zellen des Spielfelds an :

1. void setCellColor(int x, int y, Color color)– legt die Farbe der Zelle mit Koordinaten (x, y) fest:

   
   setCellColor(0, 0, Color.RED);
   setCellColor(3, 6, Color.BLACK);
   setCellColor(6, 8, Color.NONE);
   




2. Color getCellColor(int x, int y)– gibt die Farbe der Zelle mit Koordinaten (x, y) zurück:

   
   Color myColor = getCellColor(2, 0);
   




3. void setCellValue(int x, int y, String value)– legt den Text der Zelle mit den Koordinaten (x, y) fest, die der Zeichenfolge im Wertparameter entsprechen:

   
   setCellValue(3, 3, "text");
   setCellValue(0, 8, "W");
   setCellValue(4, 1, "2222");
   setCellValue(6, 6, "");
   




4. String getCellValue(int x, int y)– gibt den in der Zelle enthaltenen Text mit Koordinaten (x, y) zurück:

   
   String s = getCellValue(3, 3);
   System.out.println(getCellValue(4, 1));
   




5. void setCellTextSize(int x, int y, int size)– legt die Größe des Zellinhalts mit Koordinaten (x, y) fest. Der Größenparameter ist die Texthöhe als Prozentsatz der Zellenhöhe:

   
   setCellTextSize(2 , 0, 70); // 70% of the cell height
   




6. int getCellTextSize(int x, int y)– gibt die Größe des Zellinhalts mit Koordinaten (x, y) zurück:

   
   int size = getCellTextSize(2 , 0);
   




7. void setCellNumber(int x, int y, int value)– legt den Text der Zelle mit den Koordinaten (x, y) fest, die der Zahl im Wertparameter entsprechen:

   
   setCellNumber(3, 3, 40);
   setCellNumber(0, 8, -8);
   setCellNumber(4, 1, 2222);
   setCellNumber(6, 6, 0);
   




8. int getCellNumber(int x, int y)– gibt die in der Zelle enthaltene Zahl mit Koordinaten (x, y) zurück. Wenn die Zelle keine Zahl enthält, wird 0 zurückgegeben:

   
   int i = getCellNumber(3, 3);
   System.out.println(getCellNumber(4, 1));
   




9. void setCellTextColor(int x, int y, Color color)– legt die Farbe des Inhalts (Textes) der Zelle mit Koordinaten (x, y) fest:

   
   setCellTextColor(2, 1, Color.GREEN);
   setCellTextColor(0, 1, Color.NONE);
   




10. Color getCellTextColor(int x, int y)– gibt die Farbe des Inhalts (Text) der Zelle mit den Koordinaten (x, y) zurück:

    
    Color textColor = getCellTextColor(1, 3);
    

Der Einfachheit halber gibt es mehrere setCellValueEx()Methoden mit unterschiedlichen Parametersätzen:

1. void setCellValueEx(int x, int y, Color cellColor, String value)– legt die Hintergrundfarbe (cellColor) und den Inhalt (value) der Zelle mit Koordinaten (x, y) fest:

   
   setCellValueEx(0, 2, Color.BLUE, "56");
   




2. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)– legt die Hintergrundfarbe (cellColor), den Inhalt (value) und die Textfarbe (textColor) der Zelle mit Koordinaten (x, y) fest:

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);
   




3. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)– legt die Hintergrundfarbe (cellColor), den Inhalt (value), die Textfarbe (textColor) und die Textgröße (textSize) der Zelle mit Koordinaten (x, y) fest:

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);
   

6. Mit Farbe arbeiten

Der Color enumist für die Farben in der Spiel-Engine verantwortlich. Es verfügt über eindeutige Werte für 148 Farben. Es hat auch einen Sonderwert (NONE), der keine Farbe darstellt. Hier ist ein Beispiel für die Arbeit mit Farbe:

Color myColor = Color.WHITE;  // The myColor variable is set to white.
Color redColor = Color.RED;  // The redColor variable is set to red.
Color blueColor = Color.BLUE;  // The blueColor variable is set to light blue.

Manchmal müssen Sie möglicherweise ein Array aller vorhandenen Farben abrufen. Verwenden Sie dazu die values()Methode. Zum Beispiel:

Color[] colors = Color.values();  // The colors variable is assigned an array containing all available colors.

Es ist sehr einfach, den Index einer Farbe in der Palette abzurufen:

Color color = Color.RED;
int redIndex = color.ordinal();  // Index of red

int blueIndex = Color.BLUE.ordinal();  // Index of blue

Sie können eine Farbe auch anhand ihres Index ermitteln:

Color color = Color.values()[10];  // The color variable is assigned the color with index 10 in the Color enum.

7. Dialogfelder

Am Ende des Spiels müssen Sie dem Spieler einen Sieg oder eine Niederlage melden. Dazu gibt es eine spezielle Methode, die ein Dialogfeld auf dem Spielbildschirm anzeigt:

void showMessageDialog(Color cellColor, String message, Color textColor, int textSize)

Hier:

• cellColorist die Hintergrundfarbe des Dialogfelds;
• messageist der Text der Nachricht;
• textColorist die Farbe des Nachrichtentextes;
• textSizeist die Größe des Nachrichtentextes.

Das Dialogfeld schließt sich von selbst, wenn der Benutzer die Leertaste drückt.

8. Utility-Methoden

Beim Schreiben von Spielen werden häufig Zufallszahlen verwendet. Um das Erhalten von Zufallszahlen zu erleichtern, können Sie die folgenden von der Spiel-Engine bereitgestellten Hilfsmethoden verwenden:

1. int getRandomNumber(int max)– gibt eine zufällige Ganzzahl von 0 bis einschließlich (max-1) zurück.

2. int getRandomNumber(int min, int max)– gibt eine zufällige Ganzzahl von min bis einschließlich (max-1) zurück.

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: