Tutorial: Multitasking

Ziel

Nach erfolgreichem Abschluss dieses Tutorials kannst du Multitasking mit der Engine Alpha realisieren, also nebenläufige Prozesse realisieren, zum Beispiel einen Countdown.

Einführung

Eines der wichtigsten Konzepte der Engine Alpha ist das Ticker-Konzept. Es ermöglicht Multitasking. Es ist zwar nicht unbedingt nötig, um ein Spiel zu programmieren, wird jedoch bei den meisten Spielen gebraucht.

Das Ticker-Interface

Klasse Tutorials/Multitasking

Attribute

• keine

Methoden

• abstract void tick()

Ein Ticker ist etwas, das immer wieder periodisch einen Tick macht. Hierbei ist ein solcher Tick eine Methode, die immer wieder aufgerufen wird. Bei jedem Aufruf kann man zum Beispiel:

• Ein Spielobjekt bewegen
• Einen Kollisionstest machen
• Spielpunkte rauf-/runterzählen
• usw.

Ein Ticker ist als ein Interface mit einer einzigen abstrakten Methode definiert.

/**
 * Diese Methode soll periodisch immer wieder aufgerufen werden.
 */
public void tick()

Damit kann jede Klasse dieses Interface implementieren und damit einen Tick haben. In dem Tick kann ein Spielschritt gemacht, ein Punktezähler erhöht oder ein Spielzustand geändert werden; das Ticker-Prinzip ist sehr vielseitig. Ein Ticker sorgt im Spiel meist für Bewegung.

Nun schreiben wir eine einfache Klasse, die dieses Interface implementiert:

import ea.*;

/**
 * Dieser Ticker zaehlt aufwaerts und schickt jede Runde eine Nachricht an 
 * die Konsole
 */
public class MeinTicker
implements Ticker //Implementieren des Ticker-Interfaces!
{
    /**Der Rundenzaehler*/
    private int zaehler;
   
    /**Der Konstruktor*/
    public MeinTicker() {
        zaehler = 0;
    }
    
    /**
     * Die tick()-Methode. Sie ueberschreibt die abstrakte tick()-Methode des
     * <code>Ticker</code>-Interfaces.<br />
     * Diese Methode soll in Regelmaessigen Abstaenden aufgerufen werden.
     */
    public void tick() {
        zaehler = zaehler + 1; //Rundenzaehler um 1 erhoehen
        System.out.println("Dies ist Runde " + zaehler + ".");
    }
}

Dieser Ticker sendet bei jedem Tick eine neue Konsolennachricht mit Angabe der aktuellen Runde.

Den Ticker "zum Laufen bringen"

Leider funktioniert dieser Ticker noch nicht, denn niemand ruft ihn regelmäßig auf. Dieser Ticker muss der Engine bekannt gemacht werden. Hierfür gibt es eine Klasse, die die Ticker aufruft. Diese Klasse ist die Klasse Manager.

Hier gibt es noch was zu tun: UML-Diagramm: Ticker & Manager

Über die Methoden anmelden(...) und abmelden kann ein Ticker an einem Manager gestartet und angehalten werden. Bei anmelden wird zusätzlich ein Parameter vom Typ int verlangt. Dieser gibt an, in wie großen Abständen in Millisekunden die tick()-Methode des Tickers aufgerufen werden soll.

Praktischerweise hat die Klasse Game bereits ein Manager-Objekt mit dem Namen manager. Du brauchst also keinen neuen Manager erstellen.

Dieser Quellcode kann zum Beispiel auch in der Einführung erstellten Klasse MeinSpiel verwendet werden. Dies wäre der veränderte Konstruktor:

/**
 * Konstruktor, erstellt das Spielfenster und alle Hintergrundressourcen in der
 * Klasse <code>Game</code>
 */
public MeinSpiel() {
    super(400, 300); //Aufruf des Konstruktors der Klasse Game; erstellt ein
    //Fenster der Breite 400 und Hoehe 300
        
    MeinTicker ticker = new MeinTicker(); //Erstellen des Tickers
    manager.anmelden(ticker, 200); //Anmelden und Starten des Tickers beim
                                   //Manager
    //Die Referenz auf diesen manager liegt in der Klasse Game
}

Nun wird beim Erstellen des Spiels ein Ticker erstellt und angemeldet und seine Ausgabe wird an der Konsole gezeigt.

Den Ticker wieder anhalten

Anhalten kann man den Ticker einfach über den Aufruf der folgenden Methode:

manager.anhalten(ticker);

Danach kannst du den Ticker natürlich über die bekannte Methode auch wieder anmelden.

Probleme?

Du kannst ein einfaches Beispielprojekt, das einen Ticker implementiert, herunterladen, testen und einsehen.