Programmieren

Erstellen eines Programmes

Es wird davon ausgegangen, dass du bereits die Einführung und die Installationsanleitung gelesen hast.

Im Folgendem werden die Grundideen von EEA2 am Beispiel von Drop Of Water (DOW) erklärt. Dieses "Spiel" sollte direkt via Eclipse startbereit sein. Diese Ideen sollten ausreichen, um eigene Spiele zu entwickeln.

Das Spiel enthält einen Wassertropfen, der durch Drücken der Maustaste an einer zufälligen Stelle instanziert wird. Anschließend fällt er nach unten bis zum Ende (dem Fensterrand) und wird bei Berühren des Bodens zerstört. Danach wird wieder zurück in das Hauptmenü gewechselt. Wird während des Spiels die ESC-Taste gedrückt, so soll ebenfalls ins Hauptmenü zurückgewechselt werden. Fällt der Tropfen in den Eimer, wird die Punktzahl um einen Punkt erhöht.

Startup und Zustände

Zunächst betrachten wir die Launcher-Klasse. Diese befindet sich im DoW2-desktop Projekt. Der Grund liegt in der Unterstützung von mehreren Platformen von LibGdx. Desktop ist gedacht für Desktoprechner mit Linux, Windows oder Mac OS X.

public class DesktopLauncher {
    public static void main (String[] arg) {
	    LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
	    new LwjglApplication(new DropOfWaterGame(), config);
    }
}

new DropOfWaterGame() instantiiert hier das eigentliche Spiel. Den Rest kannst du getrost ignorieren. Du kannst die Klasse DropOfWaterGame mit jeder Klasse ersetzen, die die abstrakte Klasse EEAGame implementiert.

public static EEAGameState MainMenuState;
public static EEAGameState GameplayState;

public DropOfWaterGame() {		
}

/**
 * Diese Methode wird zu Beginn des Programmes aufgerufen
 */
protected void initStates() {
	MainMenuState = new MainMenuState(this);
	MainMenuState.setBackgroundColor(0, 255, 255);
	GameplayState = new GameplayState(this);
	GameplayState.setBackgroundColor(255, 0, 255);
}

/**
 *  Diese Methode wird zu Beginn des Programmes aufgerufen, nachdem initStates aufgerufen worden ist
 */
protected void startGame() {
	setScreen(MainMenuState);
}	

in der Methode initStates() werden Zustände erzeugt und über public static als Klassenattribute zur Verfügung gesetellt. Der erste Zustand wird mit startGame() gesetzt. Das Spiel startet also im Zustand MainMenuState.

Entities

Jeder Zustand muss EEAGameState implementieren. Betrachten wir den Zustand MainMenuState. In der Methode init() werden verschiedene Entities erzeugt. Der Hintergrund ist bereits eine Entity.

Entity background = new Entity("menu");
background.addComponent(new ImageRenderComponent("menu.png")); // Bildkomponente
em.addEntity(background);

Einer Entity können mehrere Components hinzugefügt werden, wie in Kapitel #ToDoLink erläutert. Der Entity background wird eine ImageRenderComponent, und damit ein Bild, hinzugefügt. Anschließend wird das Entity dem Entitymanager em (deklariert in Klasse EEAGameState) übergeben. Standarmäßig wird die nun an der Position (0,0) angezeigt.

Events und Actions

Die Entity Background besitzt keine Interaktion. Im Normalfall benötigt man Interaktionen auf Entities. Als Beispiel soll ein Button dienen, der bei Klick in den GamePlayState wechselt.

Entity new_Game_Entity = new Entity("Neues Spiel starten");
new_Game_Entity.setPosition(60, 350);
new_Game_Entity.addComponent(new ImageRenderComponent("entry.png"));
new_Game_Entity.setSize(330, 100);

Analog zur Hintergrundentity wird erstmal eine Entity erzeugt und ihr ein Name gegeben. Anschließend wird die Position der Entity gesetzt. Das Bild wird genauso wie beim Hintergrund festgelegt. Die Methode setSize skaliert das Bild. Bis jetzt sind noch keine Interaktionen möglich. Jetzt wird es langsam spannend...

Es soll der Zustand gewechselt werden, wenn die Maus über dem Button ist und die Maus geklickt wird. Hierfür nutzen wir einen ANDEvent, da beide Ereignisse zeitgleich erfolgen müssen, damit wir reagieren:

// Erstelle das Auslöse-Event und die zugehörige Action
ANDEvent changeStateEvent = new ANDEvent(new MouseClickedEvent(), new MouseEnteredEvent());
Action new_Game_Action = new ChangeStateAction(game, DropOfWaterGame.GameplayState);
changeStateEvent.addAction(new_Game_Action);
new_Game_Entity.addComponent(changeStateEvent);

Das obige Listing tut genau dies. Am Anfang wird ein Event erzeugt, das auslöst, wenn die Maus geklickt wird und sich dabei auf dem Button befindet ("den Bereich des Buttons betreten hat", daher MouseEnteredEvent). Anschließend wird eine ChangeStateAction angelegt. Noch haben die Events und die Actions nichts miteinander zu tun. Nun muss dem Event mitgeteilt werden, welche Action sie auszulösen hat. Dies macht addAction(Action action). Beachte, dass man hier mehrere Actions hinzufügen kann. Zuletzt wird das Entity wieder dem Entitymanager übergeben.

Entitäten zur Laufzeit hinzufügen und bewegen

Wir möchten nun den Wassertropfen zur Laufzeit hinzufügen. Anschließend soll dieser nach unten "fallen". Wir sorgen zunächst dafür, dass der Wassertropfen an einer zufällig gewählten Position erscheint. Wenn also ein Mausklick im Spielfenster erfolgt, so soll eine selbst definierte Action ausgeführt werden, die den Wassertropfen erzeugt.

Gehen wir in die init() Methode der Klasse GamplayState. Dort wird die Hilfsmethode createDropByClick(..) aufgerufen. Diese wird im Folgenden erläutert:

Entity mouseClickedListener = new Entity("Mouse_Clicked_Listener");
// Wenn man mit der Maus klickt, dann sollen neue Tropfen erzeugt werden
MouseClickedEvent mouseClicked = new MouseClickedEvent();
mouseClicked.addAction(new CreateDropAction(em, game, bucket, this, mouseClicked));
mouseClickedListener.addComponent(mouseClicked);
em.addEntity(mouseClickedListener);

Am Anfang wird wie gewohnt eine Entity erzeugt. Das ist nichts neues. Danach fügen wir eine CreateDropAction ein, die als Parameter den EntityManager (em), das Spielobjekt (game), den Eimer (bucket), den aktuellen EEAGameState (this) und den Event (mouseClicked) erhält. Diese Action ist selbst definiert. Anschließend geht es wie gewohnt weiter.

Implementieren einer eigenen Action

Hierbei gibt es im Grunde nicht viel zu beachten. Der Schlüssel ist in der act(float delta) Methode. Diese Methode wird aufgerufen, wenn das Event ausgelöst wurde. Das delta gibt an, wie lange es her ist, dass diese Methode aufgerufen wurde.

In dieser Action ist es auch möglich, neue Entities zur Laufzeit hinzuzufügen. Dies geschieht auf genau die gleiche Art und Weise wie vorne besprochen.