Pacman - The Game

Aus Nettundfroh
Wechseln zu: Navigation, Suche

Pac-Man

Das hier vorgestellte Spiel stellt eine Nachahmung des Computerspieleklassikers Pac-Man dar.

Es spiegelt den Stand der Entwicklung am 30.01.2013 wieder und ist Kern der Abgabe von Aufgabe 4 im Kurs GEA im WS2012/13.

gerendertes Einzelbild des Pac-Man-Modells

Umfang & neue Features

Das Spiel umfasst zwei Spielmodi:

  1. Singleplayer
  2. Multiplayer

Der Singleplayer Modus entspricht stark dem des Originalspiels. Der Spieler muss alle Pellets im Feld einsammeln, um ein Level zu gewinnen. Er startet mit 3 Leben, die er nach Kontakt mit den Geistern verlieren kann. Sammelt der Spieler eine Powerpille ein, kann er für wenige Sekunden selber die Geister töten. Außerdem erhält der Spieler zusätzliche Punkte.

Vollkommen neu ist die Realisierung eines Multiplayermodus. Dieser lässt sich in zwei verschiedenen Varianten spielen:

  • Jeder gegen Jeden: Es geht darum, innerhalb des Levels mehr Pellets einzusammeln als die anderen Spieler. Sammelt man eine Powerpille ein, kann man damit andere Spieler auffressen. Dieser verlieren dabei keine Leben, aber sehr viele Punkte. Zusätzlich ist es den Spielern überlassen, ob sie diesen Modus mit oder ohne Geister spielen wollen.
  • Coop: Die Spieler treten zusammen gegen die Geister an. Sie gewinnen, wenn sie alle Pellets eingesammelt haben. In diesem Modus verlieren die Spieler Leben, wenn sie von den Geistern gefressen werden. Sammeln sie Powerpillen ein, können sie damit die Geister töten, jedoch nicht sich gegenseitig.

Ebenfalls neu im Spiel ist eine weitere Kameraperspektive. Im Original gab es lediglich eine Draufsicht, in diesem Spiel wurde jetzt ebenfalls eine Third-Person Perspektive eingebaut. Dabei wird zusätzlich noch eine Minimap eingeblendet, damit der Spieler jederzeit einen guten Überblick über das gesamte Level haben kann.

Wie im Originalspiel gibt es ein Standardlevel, dass sich vom Aufbau auch stark am Original orientiert. Ebenfalls gibt es 4 verschiedene Geister, die sich individuell verhalten und mit aufsteigendem Level immer schneller werden. Zur akustischen Untermalung wurden die Soundeffekte aus dem ursprünglichen Spiel übernommen. Neu hingegen sind die 3D-Modelle zur Darstellung des Levels und der Figuren.

Spielmenu im Startbildschirm
neue 3rd Person Ansicht in Pac-Man

Dateien

Präsentation (pptx)

Präsentation (pdf)

Unity-Quellen des Spielprojekts

Webdemo des Prototyps (bitte JavaScript aktivieren!)

Die folgenden Hilfen finden sich auch im Spiel selber und können dort angesehen werden.

Steuerung

Die Steuerung basiert wie bei derartigen Spielen übliche auf den Pfeiltasten bzw. analog auf den Tasten W, A, S, D. Die Steuerung unterscheidet sich dabei leich in Abhängigkeit von der gewählten Kameraperspektive.

Steuerung Vogelperspektive:
Hoch / Links / Runter / Rechts: Pfeiltasten oder W A S D

Steuerung Third Person Perspektive:
Geradeaus / Links / Rückwärts / Rechts: Pfeiltasten oder W A S D
90° Drehung Links: Q
90° Drehung Rechts: E

Zwischen den Perspektiven wechselt man mit der Taste C.

Hilfebereich im Spiel

Singleplayer

Spielprinzip:

  • Zum Gewinnen alle Pellets einsammeln
  • Geister fressen einen auf
  • Mit PowerPille können Geister getötet werden
  • Geister werden jedes Level schneller
  • Das letzte gegessene Item verschafft ein Extra-Leben

Multiplayer

Einstellungsmöglichkeiten:

  • Mit Geistern spielen oder nicht
  • Jeder gegen Jeden: Wer die meisten Punkte holt, gewinnt. Gegenseitig aufressen bringt Punkte.
  • Coop Modus: Zusammen spielen gegen die Geister. Nur im Coop Modus kann man Leben verlieren

Darüber hinaus gilt wie im Singleplayer:

  • Geister werden jedes Level schneller
  • Das letzte gegessene Item verschafft ein Extra-Leben (nur relevant im Coop Modus)

Levelgenerierung

Das Level wird automatisch und scriptgesteuert erzeugt. Die Daten des Levels sind als 2-dimensionales int-Array repräsentiert.

Pseudocode:

var level = [
	[1,1,1,1,1]
	[1,0,2,0,1],
	[1,0,1,0,1],
	[1,0,3,0,1],
        [1,1,1,1,1],
        ];

leicht versetzte Vogelperspektive

Bei der Erzeugung müssen die Array-Indices in Spielraumkoordinaten umgerechnet werden.

Die Zahlenwerte bedeuten jeweils unterschiedliche Objekte, die an der entsprechenden Stelle initialisiert werden können (Pacman, Geister, Wand, Pellet, usw...). Der Aufbau des Standardlevels orientiert sich am Level des ursprünglichen Spiels. Es ist also auch achsensymmetrisch zur y-Achse.

Das Levelscript stellt darüber hinaus weitere Funktionen zur Verfügung, die z.B. von Pac-Man und den Geistern benötigt werden:

  • checkForWall(position: Vector3)

Die Funktion rechnet die übergegeben Position um in Arrayindices und überprüft, ob sich an dieser Stelle eine Wand befindet. Diese Abfrage wird für die möglichen Richtungen bei der Steuerung von Pac-Man benötigt.

  • getRespawnPlaceGhost()
  • getRespawnPlacePacman()

Die Funktion liefern jeweils die Spielraumkoordinaten der Punkte zurück, wo die Geister bzw. Pac-Man wiedergeboren werden.

  • getPossibleDirections(posX: int, posY: int, walkingDirection: int)

Die vielleicht wichtigste Funktion zur Steuerung der Geister. In Abhängigkeit der übergebenen Position und der aktuellen Laufrichtung des Geistes liefert die Funktion ein Array zurück mit den möglichen Richtungen (ganzzahlige Gradzahlen, als0 0°, 90°, 180° oder 270°), in die der Geist weiter laufen kann ohne mit einer Wand zu kollidieren. Dabei werden verschiedene Möglichkeiten unterschieden: Auf gerader Strecke soll sich der Geist nicht einfach umdrehen. An Abzweigungen und Kreuzungen werden jeweils mehrere mögliche Richtungen zurückgeliefert.

  • searchForPathToRespawnPlaceGhost(position: Vector 3)

Die Funktion ermittelt mit Hilfe des implementierten A* Algorithmus den kürzesten Weg, den ein Geist von der Position, an der er getötet wurde, zurück zu seinem "Zuhause" zurücklegen muss. Die Implementierung des A* Algorithmus orientiert sich dabei an der Version von Brian Grinstead, zu finden unter http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript .

Bewegung Pac-Man

Je nach Kameraperspektive gibt es zwei verschiende Steuerungsmöglichkeiten für Pac-Man.

1. Vogelperspektive

Die Basis der Steuerung ist hierbei das "GridMove" Skript von Eric Haines (http://wiki.unity3d.com/index.php?title=GridMove). Dabei handelt es sich um ein verbreitetes Bewegungsskript für gitterbasierte Bewegungen, wie es im Falle von Pac-Man ja der Fall ist. Die Figur bewegt sich auf einem festen 2D-Gitter und kann dabei nur horizontal oder vertikal gehen, nicht diagonal. Der folgende Pseudocode stellt die Implementierung vor.

Pseudocode:

function GridMove(){
    vec forward = getUserInput();
    forward.reduceToVerticalOrHorizontalMovement();
    vec startPosition = this.position;
    vec endPosition = startPosition + gridSize * forward;
    if (!endPosition.checkForWall()) this.position = transformFromTo(startPosition, endPosition);
}

Das Skript wurde dabei erweitert um die Abfrage, ob sich in der ausgewählten Richtung eine Wand befindet. Ist dies der Fall, wird die entsprechende Bewegung nicht ausgeführt.


2. Third-Person-Perspektive

Grundlage der Steuerung bei dieser Kameraperspektive ist das "FPSInputContoller" Skript. Dabei wurden jedoch ein paar kleine Änderungen vorgenommen:

  • Diagonale Bewegungen wurden deaktiviert
  • Sprünge wurden deaktiviet
  • Zusätzliche Steuerungsmöglichkeit, Pac-Man um 90° nach links oder rechts zu drehen.

Geister

Die NPCs in diesem Spiel sind die Geister, die Pac-Man jagen. Die Herausforderung in diesem Zusammenhang teilt sich in drei verschiedene Aufgaben:

  1. Allgemeine Bewegungssteuerung
  2. Intelligentes Verhalten
  3. Individualisierbarkeit

Alle Punkte wurden durch vollständige Eigenimplementierungen umgesetzt.

gerendertes Einzelbild des Geist-Modells

Allgemeine Bewegungssteuerung

An jedem Punkt des Gitters, das von einem Geist erreicht wird, findet eine Überprüfung statt, in welche Richtung der Geist weitergehen kann. Die Entscheidung darüber ist abhängig von der aktuellen Laufrichtung, so soll auf geraden Strecken der Geist nicht einfach die Richtung ändern. An Kreuzungen sind dann jedoch mehrere Richtungen, auch die entgegengesetzte, möglich.

Pseudocode:

function GhostMove(){
    int[] possibleDirections = getDirections(position, walkingDirection);
    int direction = decideForDirection(possibleDirections);
    this.turnToDirection(direction);
    this.walk();
}

Intelligentes Verhalten

Die KI der Geister wird durch vier verschiedenen Verhaltenweisen bestimmt:

  • Pac-Man folgen bei Sichtkontakt: Realisiert wird dies mit einem Raycasting-Befehl. In Blickrichtung des Geistes wird ein Strahl ausgesendet. Trifft dieser unter Berücksichtigung der Blickweite des jeweiligen Geistes auf Pac-Man, erhöht der Geist sofort seine Geschwindigkeit und verfolgt Pac-Man. Das besondere hierbei ist die Verwendung der Unity-Klasse Layer. Pac-Man und alle Wände befinden sich in einem eigenen Layer. Das Raycasting findet dann nur auf diesem Layer statt, kann also nicht auf andere Objekte wie z.B. Geister oder Pellets treffen, die zum Standard-Layer gehören. Diese Einschränkung verbessert darüber hinaus die Performanz des Spiels, da der Strahl nur wenige Objekte treffen kann und viele Kontakte den Verarbeitungsaufwand massiv erhöhen.
var hit: RaycastHit;
var fwd: Vector3 = transform.forward;
var layerMask = 1 << 8;

// if Ghost sees Pacman, make Ghost faster
   
if (Physics.Raycast(transform.position, fwd, hit, viewDistance, layerMask) && hit.collider.gameObject.tag == "Pac-Man") {
    // do something smart
} 

  • An Kreuzungen gezielt nach Pac-Man Ausschau halten: Die Geister haben die Fähigkeit, sich an Abzweigungen und Kreuzungen einmal in alle möglichen Laufrichtungen zu drehen, um nach Pac-Man Ausschau zu halten und so die Wahl über die neue Laufrichtung nicht zufällig zu treffen, sondern bewusst in Richtung Pac-Man zu rennen.
  • Vor Pac-Man wegrennen, wenn dieser eine Powerpille geschluckt hat: An jedem Gitterpunkt wird überprüft, ob in einer der möglichen Bewegungsrichtungen Pac-Man zu sehen ist. Ist dies der Fall, nehmen die Geister auf jeden Fall einen anderen Weg.
  • Nach dem Tod den kürzesten Weg zum "Zuhause" finden: Realisiert wird dies mit einer Implementierung des A* Algorithmus. Wenn ein Geist von Pac-Man gefressen wird, wird der kürzeste Pfad von diesem Ort zurück zum "Zuhause" ermittelt und der Geist geht dann diesen Weg. Weitere Informationen dazu gibt es bei den Erklärungen zum Levelaufbau.

Diese Verhaltensweisen sind für jeden Geist unterschiedlich ausgeprägt, aufgrund der individuellen Parameter.

Individualisierbarkeit

Die Geister sehen alle unterschiedlich aus. Jeder Geist soll jedoch auch ein individuelles, wiedererkennbares Verhalten an den Tag legen. Beeinflussen lässt sich das Verhalten wie folgt:

  • Laufgeweschwindigkeit
  • Renngeschwindigkeit
  • Sichtweite
  • An Kreuzungen Ausschau halten nach Pac-Man
  • Bevorzugtes Verhalten an Kreuzungen: Geradeaus gehen, Richtung wechseln, zurückgehen ja oder nein
  • Prozentualer Wert, mit dem sich der Geist an dieses Richtungsverhalten halten soll

Grundsätzliches

Das vielleicht wichtigste Element, um in Unity Multiplayer-Spiele realisieren zu können, ist die Klasse NetworkView. Objekte dieser Klasse sind die Voraussetzung um Zustände synchronisieren und RPC-Aufrufe tätigen zu können. Beispiele für die Verwendung dafür werden in den folgenden Abschnitten beschrieben.

Verbindungsaufbau

Unity liefert einfache Möglichkeiten, um einen Verbindungsaufbau mehrerer Spieler realisieren zu können. Auf Serverseite wird die Funktion Network.InitializeServer() aufgerufen, als Parameter sind u.a. die Anzahl möglicher Verbindungen und die Portnummer anzugeben. Auf Serverseite ist die Funktion Network.Connect() aufzurufen, hier sind die IP-Adresse des Server und wiederum der verwendete Port anzugeben. Mit zugehörigen Listener-Methoden wie z.B. OnServerInitialized oder OnConnectedToServer kann dann auf eingehende Verbindungen reagiert werden. Im Falle des Pac-Man Spiels wird die Anzahl der Spieler hochgezählt. Diese wird auch allen Spielern angezeigt, um jederzeit zu wissen, wie viele Spieler an der aktuellen Sitzung teilnehmen.

Spielstart

Der Spielstart unterscheidet sich im Vergleich zum Singleplayer-Modus an einer zentralen Stelle, der Initialisierung der Objekte.

 // Initialisierung Singleplayer
 Instantiate(pellet, objectVector, Quaternion.identity);
 // Initialisierng Multiplayer
 Network.Instantiate(pellet, objectVector, Quaternion.identity, 0);

Durch den Aufruf Network.Instantiate() wird das übergebene Objekt (Pellet) mit den übergebenen Positions- und Rotationsangaben für alle verbundenden Spieler initialisiert. Die Synchronisierung wird automatisch gewährleistet, sodass dabei keine weitere Arbeit involviert ist. Diese Initialisierung der Objekte wird vom Server vorgenommen.

Das Erzeugen von individuellen Pac-Man Figuren je Spieler ist hingegen etwas aufwändiger. Jeder Spieler soll schließlich seinen eigene Pac-Man Figur bekommen, die nur er steuern kann. Die entsprechende Methode muss also von jedem verbundenen Spieler selber aufgerufen werden. Dazu wird die RPC-Technik verwendet.

Bei der Erzeugung der Spielwelt startet der Sever einen RPC-Aufruf, der an alle verbundenen Spieler geht (inkl. an sich selbst).

var viewID: NetworkViewID = Network.AllocateViewID();
networkView.RPC("instantiatePacMan", RPCMode.AllBuffered, viewID, objectVector);

Innerhalb dieser Methode findet dann die Erzeugung der individuellen Pac-Man Figur statt. Jedes Pac-Man Objekt hat verdrahtete Skripte, die die Steuerung regeln. Würde man an dieser Stelle keine weiteren Vorkehrungen treffen, könnte man alle Spieler gleichzeitig steuern. Um dies zu verhindern, wird die Methode OnNetworkInstantiate verwendet, die auf die Erzeugung eines Netzwerk-Objektes reagiert.

/* deactivate Control for other Pacmans */
function OnNetworkInstantiate(info: NetworkMessageInfo) {
    if (!networkView.isMine) {
        Destroy(this.gameObject.GetComponent(GridMove));
    }
}

Das Attribut networkView.IsMine liefert zurück, ob es sich um das vom jeweiligen Spieler erzeugte Pac-Man-Objekt handelt. Ist dies nicht der Fall, wird das entsprechende Steuerungsskript entfernt.

Dieses Attribut muss an mehreren Stellen ausgelesen werden. Wenn z.B. Kameras erzeugt werden oder die Kameraperspektiven gewechselt werden, muss jeweils sichergestellt sein, dass die entsprechenden Änderungen nur auf dem Pac-Man-Objekt des jeweiligen Spielers vorgenommen werden.

Spielverlauf

Eine Besonderheit im Gegensatz zum Singleplayer-Modus ist natürlich, dass nun auch verschiedene Pac-Man-Figuren kollidieren können. Entsprechende Ereignisse müssen also entsprechend verarbeitet werden. Hierbei findet darüber hinaus eine Unterscheidung statt, ob der Jeder-gegen-Jeden Modus oder der Coop-Modus gespielt wird. Im Coop-Modus können sich die Pac-Mans nicht gegenseitig fressen.

Eine relativ triviale Angelegenheit ist es, dass jeder Spieler nur seine eigene HUD mit entsprechenden Informationen über Punktzahl und Anzahl übriger Leben sehen soll. Dafür wird wieder das Attribut networkView.isMine ausgelesen.

Spielende

Das Spielende wird im Multiplayer-Modus in Abhängigkeit des gewählten Spielmodus zu unterschiedlichen Zeitpunkten erreicht. Hierbei ist wiederum wichtig, alle Spieler über das Levelende zu informieren (damit das Spiel angehalten wird), aber auch über den Start des nächsten Levels (damit die Pausierung wieder aufgehoben wird). Auch in diesem Zusammenhang finden RPCs Anwendung, ebenso muss das Attribut networkView.isMine an mehreren Stellen ausgelesen werden.

3D - Modelle

Pac-Man und die Geister werden in diesem Spiel mithilfe von 3D-Modellen dargestellt. Diese wurden in Blender erstellt und anschließend in Unity importiert.

Das Pac-Man-Modell wurde darüber hinaus mit einer Animation versehen, er öffnet und schließt andauernd sein Maul. Die Geister wackeln hin und her. Die Animationen bilden Manipulationen eines einfachen Skeletts dieser Modelle über mehrere Keyframes ab. Die Vorlage für das Pac-Man Modell stammt von Blender Underground und lag dort als einfaches Beispiel für Rigging vor. Die gewonnen Erkenntnisse wurden bei der Gestaltung der Geister angewendet. Die Modelle wurden aus Blender inklusive der Animationen im FBX-Format exportiert und bilden die Grundlage der entsprechenden Prefabs in Unity.

Pac-Man mit Skelett für Maulöffnung
Wackelbewegung des Geistes über Skelett

Levelgestaltung

Das Level und die sonstigen Objekte (Pellets, Item, Powerpellets) wurden mit Boardmitteln von Unity gestaltet. Insbesondere zu erwähnen ist hier die Zuordnung verschiedener Materialien zu den einzelnen Objekten und eine anschließende Anpassung der jeweiligen Shader. Darüber lässt sich gut eine dunkle Atmosphäre schaffen mit kräftigen, strahlenden Objekten. Hierbei wurde insbesondere auf hohe Kontraste Wert gelegt. Dies ist u.a. ein Kennzeichnen derartiger comichafter Welten, des Weiteren sorgt dies automatisch für eine gut zu erkennende Darstellung der Minimap.

Vogelperspektive ohne Minimap
3rd Person mit Minimap, analog zur klassischen Perspektive

Menüdesign

Mithilfe der Klasse GUISkin wurde die Darstellung des Menüs angepasst. Auch hier wurde Wert gelegt auf kräftige, kontrastreiche Farben, um die Lesbarkeit der Schriftelemente zu gewährleisten.

Hohe Kontraste für GUI-Elemente: Multiplayer Menü

Sonstige Effekte

Die Powerpellets wurden mit einem Halo-Effekt versehen, wodurch sie zu leuchten scheinen. Darüber soll die Wichtigkeit dieses Objekts für den Spieler angedeutet werden. Gleichzeitig erlaubt dieses Leuchten es auch, die Position der Powerpellets in der Third Person Perspektive jederzeit im Blick zu haben, da der Halo der Powerpellets höher ist als die umgebenden Wände.

Sobald Pac-Man ein Powerpellet frisst, bekommt er ebenfalls diesen Leuchteffekt. Das signalisiert dem Spieler, dass er Geister und andere Pac-Mans fressen kann. Das nahende Ende der Powerphase wird durch ein Flackern angekündigt.

Powerpill-Pac-Man in der 3rd-Person-Ansicht

Wird ein Geist gefressen, verliert er seinen Körper und man sieht ausschließlich wie seine Augen sich auf den Heimweg machen. Dort wird der Geist dann komplett wieder gerespawnt.

Sound

Die verwendeten Soundeffekte stammen aus dem Originalspiel. Der komplette Satz der Sounddateien kann hier heruntergeladen werden: http://sweetsoundeffects.com/pacman-game-sfx/

Die einzelnen Dateien wurden zum Teil leicht bearbeitet, um sie besser ins Spiel integrieren zu können. Insbesondere die Hintergrundsirene musste derart geschnitten werden, dass eine Wiedergabe in einer Dauerschleife gut klingt, also ohne das deutliche Übergänge zu hören sind.

Die meisten Soundeffekte wurden als "AudioSource" direkt an das Pac-Man Objekt rangehangen. Damit lässt sich in der Pac-Man Klasse einfach der passende Effekt abspielen, wenn in der "OnTriggerEnter" Methode eine Kollision z.B. mit einem Pellet erkannt wurde.

Der folgende Quellcode zeigt die Initialisierung der einzelnen Sound-Effekte und wie ein einzelner Effekt gestartet wird.

// Audio Sources
var backgroundSound: AudioSource;
var pacmanEatsPelletSound: AudioSource;
var pacmanEatsItemSound: AudioSource;
var pacmankillsGhostSound: AudioSource;
var pacmanGetsKilledSound: AudioSource;
var levelOverSound: AudioSource;
var pacmanEatsPowerPelletSound: AudioSource;

function Start() {

    // Instantiate audio sources
    var aSources = GetComponents(AudioSource);
    backgroundSound = aSources[0];
    pacmanEatsPelletSound = aSources[1];
    pacmanEatsItemSound = aSources[2];
    pacmankillsGhostSound = aSources[3];
    pacmanGetsKilledSound = aSources[4];
    levelOverSound = aSources[5];
    pacmanEatsPowerPelletSound = aSources[6];

    // play background "music"
    backgroundSound.Play();

}

Wichtig ist hierbei die Reihenfolge zu beachten, in der die einzelnen AudioSources auf dem Pac-Man-Objekt abgelegt sind. Dies bestimmt nämlich die Reihenfolge im Array "aSources".

Kollisionserkennung

Die Objekte im Spiel werden mit entsprechenden "Tags" versehen.

So werden über den Aufruf der Methode "OnTriggerEnter(hit: Collider)" automatisch Kollisionen erkannt. Über die Abfrage des Tags des "hit"-Objektes, kann der Rückgabe entsprechend reagiert werden. Die meisten dieser Abfragen gehen von Pac-Man aus, da dieser mit Pelltes, Items, Powerpillen, Geistern und anderen Pac-Mans kollidieren kann.

Neben der Möglichkeit, Kollisionen über die Methode "OnTriggerEnter" zu erkennen, gibt es auch die Methode "OnCollisionEnter". Die lässt sich in diesem Zusammenhang jedoch nicht verwenden, da für die Bewegung von Pac-Man nicht die eingebaute Physikengine von Unity verwendet wird.

Kameraperspektiven

Es gibt im Spiel 3 verschiedene Kameras:

  1. Vogelperspektive: Eine Kamera die leicht schräg versetzt über dem Geschehen steht.
  2. Third-Person-Kamera: Diese zeigt Pac-Man von hinten und verfolgt dessen Bewegungen. Grundlage hier ist das mitgelieferte "SmoothFollow" Skript. Jede Pac-Man Figur hat seine eigene Third-Person-Kamera, damit in Multiplayerspielen wirklich jeder Spieler seine eigene Third-Person-Ansicht hat.
  3. Third-Person-Mini-Map: Diese Kamera hat in etwa die gleiche Position wie die Kamera der Vogelperspektive. Die Aufgabe dieser Kamera ist es, dem Spieler in der Third-Person-Perspektive auch einen Überblick über das gesamte Level zu geben. Dies lässt sich in Unity leicht über das sogenannte "Normalized View Port Rect" realisieren. Darüber lässt sich für eine Kamera definieren, welcher Teil des Bildschirm von der Ansicht dieser Kamera bedeckt sein soll. Standardmäßig ist hier definiert, dass die Ausgabe der Kamera am oberen linken Bildschirmrand beginnt (x=0, y=0) und den gesamten Bildschirm bedeckt (w=1, h=1). Will man nun eine einfache Minimap realisieren, die z.B. oben rechts angezeigt werden soll, kann man diese Attribute wie folgt belegen: x = 0.8, y = 0.8, w = 0.2, h = 0.2

Die Verwaltung bzw. das Umschalten der Kameras wird von einer eigenen Klasse geregelt. Darin ist u.a. festgelegt, dass die Kameraperspektive mit einem Druck auf die Taste "c" gewechselt wird. Außerdem kümmert sich die Klasse darum, dass beim Wechsel der Perspektive die verschiedenen Steuerungsmöglichkeiten umgestellt werden.

Vogelperspektive ingame
3rd Person: Screenshot während einer Drehung

Intro

Das Intro ist realisiert über drei einfache Bewegungsanimationen der beteiligten Figuren (Pac-Man und 2 Geister).

Die Animationen wurden mit Hilfe des Unity Editors erzeugt.

Die Überleitung vom Intro zum Menü erfolgt in dem Moment, in dem die Intromusik fertig gespielt wurde. Dieser Moment lässt sich mit dem Befehl "audio.isPlaying" abfragen.

Es folgt eine grobe Aufzählung der Veränderungen seit dem Prototyp. Sämtliche Features sind an anderer Stelle in dieser Dokumentation ausführlicher erklärt.

Neue Features

  • Neuer Multiplayer-Modus: Coop
  • Geister individualisierbar
    • Geschwindigkeit
    • Richtungsvorlieben (geradeaus, abbiegen, rückwärts, Zufall)
    • Intelligenz (An Kreuzungen Ausschau halten nach Pacman)
    • Sichtweite
  • 3D Modelle
    • Pac-Man
    • Geister
    • jeweils inkl. Animationen
  • Soundeffekte
  • Intro

Verbesserungen

  • Klügere Geister
    • Geister nutzen Wegfindung (A*) um nach ihrem Tod zurück zu ihrem "Zuhause" zu gehen
    • Geister rennen vor Pac-Man weg, wenn dieser eine Powerpille geschluckt hat
    • Geister betreten nicht mehr ihr "Zuhause" sondern sind stets auf der Jagd nach Pac-Man
  • Vollständige Menüfühung
  • Level verkleinert
    • die Kamera ist dadurch näher dran am Spiel
    • eine Runde ist dadurch wesentlich kürzer
    • kürzere Intervalle erhöhen den Spielspaß
  • Neue Kameraperspektive
    • Third Person Perspektive mit Minimap neben der Vogelperspektive
    • Kamerawechsel auf Tastendruck ('C')
    • Angepasste Steuerung für die verschiedenen Kameraperspektiven
  • Multiplayer Modus
    • Anzeige wie viele Spieler angemeldet sind
    • Auswählbar: Mit Geistern spielen ja / nein
    • Auswahl des Spielmodus
  • Leveldesign
  • Bugfixing

Bekannte Fehler

  • KI: Geister laufen durch Wände umittelbar nach Respawn (selten)
  • Multiplayer: Pac-Man bleibt stecken beim Warp (selten)
  • Multiplayer: Töten / getötet werden wird nicht richtig erkannt (selten)
  • Multiplayer: Geister alle einfarbig
  • Multiplayer: Animation beim Tod eines Geistes funktioniert nicht
  • Pac-Man: Pac-Man fängt an zu fliegen (sehr selten)

Aufgabe 4.1: Das Spiel

https://public.beuth-hochschule.de/~tramberend/12-ws/mmi-gea/exercises/04-game/

Entwickeln sie Ihren Prototypen aus Aufgabe 3 in ein vollständiges Spiel. Vervollständigen sie dafür die Spiellogik und fügen sie jetzt eventuelle Spezialeffekte, Post-Processing Effekte und aufwändigere Materialien hinzu. Achten sie dabei neben der visuellen Anmutung auch auf Spielbarkeit und Performance.

Nutzen sie die Möglichkeit Unity Anwendungen mit dem Unity-Webplayer zu deployen und stellen sie das fertige Spiel auf Ihrer Abgabeseite online.

Aufgabe 4.2: Abschlussdokumentation

Dokumentieren sie das Spiel und die wesentlichen Aspekte Ihrer Implementierung in einer Abschlussdokumentation. Stellen sie das Dokument auf Ihrer Abgabenseite online.

Aufgabe 4.3: Präsentation

Bereiten sie eine 15-20 minütige Präsentation und Demonstration Ihres Prototypen vor. Die Präsentation findet am 23.01.2013 in der Vorlesung um 16:00 Uhr statt. Für diese Präsentationsveranstaltung besteht Anwesenheitspflicht.

Stellen sie die vorbereiteten Präsentationsmaterialien auf Ihrer Abgabenseite online.

Abgabe

Senden sie einen Link auf die Abgabeseite Ihrer Arbeitsgruppe bis zum 23.01.2013 um 12.00 Uhr mit dem Betreff "[GEA] Abgabe Aufgabe 4" an tramberend@beuth-hochschule.de.

Für den erfolgreichen Abschluss dieser Aufgabe müssen alle Teilaufgaben termingerecht abgegeben werden. Das fertige Spiel und die Abschlusspräsentation werden benotet, und bestimmen die Modulnote.



Zurück zur Game Engine Architecture Hauptseite

Master Semester 2