So unterschiedlich Brettspieladaptionen, Platformer (Jump and Runs), Maze-Games (Pac Man) oder gar zweidimensionale Taktik- und Strategiespiele auch sein mögen, die Techniken, mit denen sich die zugrundeliegenden Spielwelten zum Leben erwecken lassen, sind im Prinzip stets die gleichen. Im Rahmen des heutigen Artikels möchte ich Ihnen demonstrieren, dass die Erstellung und Darstellung der besagten Spielwelten unter technischen Gesichtspunkten alles andere als kompliziert ist, sondern lediglich ein wenig Fleißarbeit unsererseits erfordert.
Sämtliche Spiele, mit denen wir uns in den vorangegangenen Artikeln beschäftigt haben, zeichnen sich durch eine Gemeinsamkeit aus: Interaktionen fanden jeweils nur zwischen den einzelnen Spieleobjekten statt – zwischen den Bällen und Schlägern oder zwischen den Raumschiffen, Asteroiden und abgefeuerten Waffenobjekten. Der Weltraum, genauer gesagt die Hintergrundsterne und galaktischen Nebel, dienten lediglich als Kulisse, wodurch sich die Entwicklung der besagten Spiele ungemein vereinfacht hat. Im Rahmen dieses Artikels möchte ich Ihnen demonstrieren, wie sich zweidimensionale Spielwelten erstellen und darstellen lassen, mit denen die einzelnen Spielobjekte auch tatsächlich interagieren können. In diesem Zusammenhang werde ich Ihnen zeigen, wie sich eine zugegebenermaßen schlicht aussehende Spielfigur kletternd, springend, laufend und mitunter auch unfreiwillig fallend durch eine solche Welt bewegen kann (Abb. 1-4).
Abb. 1: Bewegungsabläufe in einer Tile-basierten Spielwelt (Laufen)
Abb. 2: Bewegungsabläufe in einer Tile-basierten Spielwelt (Klettern)
Abb. 3: Bewegungsabläufe in einer Tile-basierten Spielwelt (Springen)
Abb. 4: Bewegungsabläufe in einer Tile-basierten Spielwelt (Fallen)Damit die Sache noch ein wenig interessanter wird, werden wir die jeweiligen Bewegungsabläufe selbstverständlich auch animieren, wobei wir auf das wohl älteste Animationsverfahren zurückgreifen: das der Texturanimation. Plattformspiele (Jump and Runs) sind geradezu prädestiniert dafür, um sich damit in die ganze Thematik einzuarbeiten, da die Visualisierung des Spielers und seiner Gegner sowie die Qualität der zugehörigen Bewegungsabläufe entscheidend für den Spielspaß sind. Selbstverständlich könnte ich Ihnen die gleichen Techniken auch am Beispiel eines anderen Spielegenres demonstrieren, allerdings hätten wir dann viel zu wenig Zeit, um uns mit deren jeweiligen genrespezifischen Herausforderungen auseinanderzusetzen. Nehmen wir als Beispiel die vermeintlich schlichteste Brettspieladaption überhaupt: Tic Tac Toe.
Gerade weil dieses Spiel so unkompliziert ist, lassen sich hierbei die verschiedenen Algorithmen zur Ermittlung der optimalen Spielstrategie (Minimax, Alpha-Beta-Pruning, Monte-Carlo-Tree-Search) praktisch mühelos nachvollziehen. Was die grafische Darstellung betrifft, könnten wir hingegen einfach auf den Programmcode unseres Jump-and-Run-Spiels zurückgreifen.
Bei der Entwicklung eines Artilleriespiels, zu deren Genrevertretern beispielsweise auch das allseits beliebte Angry Birds zählt, würde man sein Augenmerk unter anderem auf die Durchführung der ballistischen Berechnungen richten, da diese nun einmal das zentrales Element der Spielmechanik darstellen. Oder betrachten wir als letztes Beispiel das Genre der Maze-Games, zu dessen populärsten Vertretern zweifelsohne noch immer das Urgestein Pac Man zählt. Die Herausforderungen, mit denen man im Zuge der Entwicklung eines solchen Spiels konfrontiert wird, betreffen unter anderem die prozedurale Erzeugung der Spielwelten (also der Labyrinthe) oder aber das Thema Wegfindung.
Animation in zwei Dimensionen
In den ersten drei Spieleprojekten haben wir uns das Leben zugegebenermaßen ein wenig einfach gemacht, da wir auf Animationen, also auf eines der wohl wichtigsten gestalterischen Elemente überhaupt, verzichtetet haben. Um das Fehlen jedweder Animationen zumindest ein wenig zu kaschieren, mussten wir uns freilich mit einigen Tricks behelfen. So haben wir beispielsweise im Rahmen der Darstellung einer Explosion die Ausmaße des zugehörigen Billboard-Objekts kontinuierlich vergrößert, während wir zeitgleich dafür gesorgt haben, dass die Farben der verwendeten Feuerballtextur mehr und mehr verblassten und zunehmend durchscheinender (transparenter) wurden. Animationen, wie man sie aus 3-D-Spielen kennt, betreffen in der Regel sowohl die Geometrie der animierten Objekte als auch die verwendeten Texturen. Da es in einem 2-D-Spiel nun einmal keine dreidimensionalen Modelle zum Animieren gibt, bleibt uns letzten Endes nur die Texturanimation, deren Funktionsprinzip doch recht stark an das klassische Daumenkino erinnert: Texturanimationen basieren auf einer vorab festgelegten Reihenfolge von Texturwechseln.
Alle Animationen, die in unserem Demoprogramm verwendet werden, sind in der Datei TextureAnimations.txt gespeichert, die ihrerseits im Programmordner Data zu finden ist (online auf entwickler.de). Wie nachfolgend gezeigt wird, müssen wir beim Erstellen einer neuen Texturanimation lediglich die Indexwerte der beteiligten Texturen auflisten und darüber hinaus die Zeitdauer (AnimationStepDuration) festlegen, die zwischen zwei Texturwechseln verstreichen soll:
#NumAnimations:# 7
#Animation 0 (Fire):#
#NumAnimationSteps:# 3
#AnimationStepDuration[ms]:# 250.0
#AnimationSteps:# 14, 15, 16
[usw.]
In unserem Programmbeispiel greifen wir bei der Verwaltung sämtlicher Animationsparameter auf die in Listing 1 (online auf entwickler.de) skizzierte CTextureAnimationDescription-Klasse zurück. Für die Handhabung der zugehörigen Klassenobjekte ist darüber hinaus die in Listing 2 (online auf entwickler.de) gezeigte CTextureAnimationDescription-Klasse verantwortlich. Auch wenn man nur an einem verhältnismäßig kleinen Spieleprojekt arbeitet, wird es bereits nach relativ kurzer Zeit zunehmend schwieriger, den Überblick darüber zu behalten, welche Spielfiguren und Szenenobjekte sich mithilfe welcher Texturanimationen zum Leben erwecken lassen. Wie Sie der Aufstellung in der im Datenordner abgelegten und auf entwickler.de zu findenden Datei PlayerAnimationsOverview.txt entnehmen können, kann die vom Spieler kontrollierte Figur beispielsweise in Abhängigkeit von ihrem jeweiligen Bewegungszustand sechs verschiedene Texturanimationen ausführen:
#NumAnimations:# 6
#DescID of Animation 0 (Move Right):# 2
#DescID of Animation 1 (Move Left):# 3
#DescID of Animation 2 (Climb Up):# 6
#DescID of Animation 3 (Climb Down):# 6
#DescID of Animation 4 (Jump Right):# 4
#DescID of Animation 5 (Jump Left):# 5
Für die Verwaltung dieser Daten greifen wir auf die in Listing 3 (online auf entwickler.de) deklarierte CTextureAnimationsOverview-Klasse zurück. Wenn sich nun beispielsweise der Bewegungszustand der vom Spieler kontrollierten Figur ändert und eine neue Animation abgespielt werden muss, können wir den Indexwert der betreffenden Animation mithilfe der CTextureAnimationsOverview-Methode Get_DescID() wie folgt ermitteln:
PlayerObject.Start_Animation(PlayerObjectAnimationsOverview.Get_DescID(PlayerObject.NewMovementStatus), /*Loop-Animation:*/ true, SimulationTime);
Für die Handhabung der einzelnen Texturanimationen ist die in Listing 4 (online auf entwickler.de) skizzierte CTextureAnimation-Klasse verantwortlich. Die Funktionsweisen der zugehörigen Klassenmethoden Start_OneTimeAnimation(), Start_LoopAnimation(), Update_RunningAnimation(), Stop_Animation() sowie Get_ActualTextureSetID() können Sie hingegen anhand von Listing 5 (online auf entwickler.de) nachvollziehen. Im Rahmen der Aktualisierung einer laufenden Animation müssen wir lediglich die aktuelle Zeit (actualTime) und den Zeitpunkt des letzten Texturwechsels (TimeSinceLastUpdate) zueinander in Relation setzen:
if (actualTime > TimeSinceLastUpdate + AnimationStepDuration)
{
TimeSinceLastUpdate = actualTime;
ActualAnimationStep++;
}
Sofern eine Animation lediglich ein einziges Mal abgespielt werden soll (One-Time-Animation), wird diese beendet, sobald sämtliche Animationsschritte einmal durchlaufen worden sind:
if (ActualAnimationStep == NumAnimationSteps)
AnimationRunning = false;
Soll eine Animation hingegen in einer Dauerschleife abgespielt werden (Loop-Animation), müssen wir sie stattdessen lediglich zurück auf Anfang setzen:
if (ActualAnimationStep == NumAnimationSteps)
ActualAnimationStep = 0;
Bevor wir nun eine laufende Animation auf die Figur des Spielers oder auf ein anderes Szenenobjekt übertragen können, müssen wir zunächst einmal den Index der zum aktuellen Animationsschritt (ActualAnimationStep) zugehörigen Textur bzw. den Index des zugehörigen Textursets (bestehend aus Surface Map, Normal Map, Specular Map sowie Light Map) ermitteln. Hierfür ist ein Aufruf der Get_ActualTextureSetID()-Methode erforderlich, die im Prinzip nichts weiter tut, als den besagten Index aus dem von einer CTextureAnimation-Instanz verwalteten pTextureSetIDArray auszulesen:
return pTextureSetIDArray[ActualAnimationStep];
Tile-basierte Spielwelten
Ein paar Blätter Karopapier, eine Schere und einige bunte Stifte – mehr ist für den Entwurf eines einfachen 2-D-Spiels im Prinzip nicht erforderlich. Die einzelnen Linien auf dem Papier stellen eine ideale Orientierungshilfe dar, die auch einem künstlerisch unbedarften Programmierer die Ausgestaltung einer abwechslungsreichen Spielwelt ermöglicht. Hierfür muss man lediglich die einzelnen Karopapierkästchen in verschiedenen Farben ausmalen bzw. ihre Begrenzungslinien nachzeichnen – so etwas bekommt wirklich jeder hin. Die einzelnen Kästchen repräsentieren gewissermaßen die kleinsten Gestaltungselemente, aus denen sich eine zweidimensionale Spielwelt zusammensetzen lässt.
Für die Darstellung dieser quadratischen Bausteine greifen wir in unserem Programmbeispiel zum wiederholten Mal auf ein texturiertes Vertex-Quad zurück. Da wir für die Visualisierung unserer Spielwelten eine mehr oder weniger große Anzahl von nahtlos aneinandergereihten Vertex-Quads benötigen, spricht man in diesem Zusammenhang gemeinhin von einer Tile-basierten Spielwelt (Tiling bzw. Kachelung: nahtlose Aneinanderreihung) und bezeichnet die zugrunde liegenden Bausteine dementsprechend als Kacheln bzw. Tiles. Im Rahmen eines 2-D-Spiels würde man nun sämtliche Tiles in einer Ebene anordnen.
Allerdings müssen wir nicht auf diese Weise vorgehen. Wir könnten stattdessen auch auf beliebig geformte Vertex-Quads...

