Benutzer:Brainos/ First Person Shooter Steuerung in Blender 2.5

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Dieses Tutorium ist angelehnt an die Tutorien von http://www.tutorialsforblender3d.com/Game_Engine/ zur Steuerung mit dem WASD- Tasten und der Maussteuerung aus First Person Sicht. Es vereint beide, nutzt aber einen komplizierteren, aber leistungsfähigeren Ansatz zur Realisierung, die Module.

Realisiert ist das Ganze durch eine Mischung aus Logic Brigs und zwei Pythonskripten. Eines für die Mausbewegung und eines für die Tastaturbewegung.

Vorbereitung[Bearbeiten]

Da wir für die Game Engine entwickeln, sollten wir zunächst oben in der Menüleiste, wo standardmäßig "Blender Render" steht, auf "Blender Game" umstellen, damit wir in allen Menüs die Einstellungen haben, welche die Game Engine (GE) betreffen.

Abbildung 1: Blender 2.5r26831 Vorbereitung

Als Spielerobjekt soll uns der bereits vorhandene Würfel dienen. Damit dieser physikalisch korrekt bewegt werden kann, muss im Einstellungsmenü [Propertys] im Physikbereich der Typ auf "Dynamic" gesetzt werden. Damit der Würfel jetzt nicht nach unten fällt wenn man die GE startet, sollte man eine genügend große Fläche unter den Würfel erstellen. Die vorhandene Kamera nutzen wir als Kamera im Spiel. Diese muss jedoch zunächst ausgerichtet werden. Mit Alt+g und Alt+r setzen wir dessen Position und Rotation zurück, so dass die Kamera sich jetzt genau im Koordinatenursprung befindet. Nun verschieben wir sie entlang der Z-Achse ein Stück über den Würfel. Abschließen sollte die Kamera noch 90° um die X-Achse gedreht werden: r x 90 Damit jetzt die Kamera der Bewegung des Spielers folgt, muss diese mit dem Würfel gruppiert werden. Dazu erst die Kamera auswählen, dann die Umschalttaste halten und den Würfel markieren. Nun Strg+P drücken und mit Eingabetaste bestätigen.

Maussteuerung[Bearbeiten]

Da die Maussteuerung in erster Linie die Kamera beeinflusst, benutzen wir diese auch als Ausgangspunkt. Zunächst muss im "Logic Editor" der Kamera ein Sensor vom Typ "Mouse" erzeugt werden, der den Namen 'mouse' tragen sollte, damit er später im Skript durch diesen angesprochen werden kann. Der Sensor muss außerdem auf "Movement" gestellt werden, sodass er immer auslöst, wenn die Maus bewegt wurde. Jetzt wird er mit einem neu zu erzeugenden Controller verbunden. Dieser muss vom Typ "Python" sein und von "Script" auf "Module" umgestellt werden. Nun brauchen wir nur noch einen Motion-Actuator. Dieser bleibt auf den Standardwerten stehen, muss aber "LookUpDown" genannt werden. Jetzt wird es etwas trickreich. Damit durch die Mausbewegung der Spieler gedreht wird und nicht nur die Kamera, benötigt das Spielerobjekt auch einen Motion-Actuator mit dem Namen 'LookLeftRight'. Damit man von dem Controller der Kamera auf diesen Actuator zugreifen kann, müssen diese verbunden werden. Dazu markiert man zunächst beide Objekte, woraufhin im Logic Editor die Logic Brigs beider Objekte erscheinen. Nun kann man den Controller der Kamera mit dem Actuator des Spielers verbinden.

Startet man jetzt die GE, so passiert noch überhaupt nichts, da wir dem Controller der Kamera noch kein Modul zugewiesen haben. Dieses müssen wir zunächst erzeugen.

Ein Modul in der GE ist nichts weiter, als ein Pythonskript, das zumindest eine Funktion enthält. Diese Funktion wird direkt vom Controller aufgerufen, deswegen hat der Eintrag bei Module auch die Form Modulname.Funktionsname. Der Vorteil von Modulen besteht darin, das nur bei der ersten Verwendung globale Variablen angelegt werden und diese während des ganzen Spiels ihre Werte halten, welche man natürlich auch ändern darf.

Um ein neues Modul zu erzeugen legen wir im "Text Editor" eine neue Datei mit dem Namen mouse.py an. Für ein Modul ist es wichtig, dass es die Dateiendung .py besitzt. Das Skript beginnt wie folgt:

import GameLogic,Rasterizer

Rasterizer.showMouse(True)

window_width  = Rasterizer.getWindowWidth()
window_height = Rasterizer.getWindowHeight()

Anders als bei normalen Skripten für die GE ist das Modul 'GameLogic' nicht automatisch eingebunden, es muss also per Hand gemacht werden. Danach machen wir den Mauszeiger sichtbar und speichern die Höhe und die Breite des Fensters. Anmerkung: In den Einstellungen im Abschnitt 'Scene' sollte das 'Framing' nicht auf 'Letterbox' stehen, da sonst die Fenstergröße nicht der angezeigten Größe entspricht.

Da diese ersten Codezeilen im globalen Bereich des Skriptes stehen, werden sie nur bei der ersten Verwendung den Moduls abgearbeitet und nicht jedes mal, wie bei normalen Skripten. Diesen Vorteil nutzen wir auch bei unseren anderen Variablen, die wir sonst jedes mal neu initialisieren müssten:

cont = GameLogic.getCurrentController()
own = cont.owner

sens_mouse         = cont.sensors['mouse']
actu_LookLeftRight = cont.actuators['LookLeftRight']
actu_LookUpDown	   = cont.actuators['LookUpDown']

Hier ermöglichen wir uns zunächst den Zugriff auf den aktuellen Controller und das aktuelle Objekt und danach auf die gekoppelten Sensoren und Actuatoren, die per Namen angesprochen werden.

Nun kommen wir zu eigentlichen Modulfunktion die bei jeder Mausbewegung aufgerufen werden soll.

def main():

	mouse_x = window_width/2 - sens_mouse.position[0]
	mouse_y = window_height/2 - sens_mouse.position[1]

Im ersten Schritt wird ermittelt, wie weit die aktuelle Mausposition von der Bildschirmmitte entfernt ist.

Mit Hilfe dieser Werte berechnen wir nun, wie stark um welche Achse rotiert werden soll. In das Ergebnis fließen auch zu 80% die Ergebnisse aus der letzten Berechnung mit ein, welche global gespeichert werden, wodurch die Bewegung weicher wirkt. Durch Rundungsfehler kann es vorkommen kann, dass die Rotation nie ganz Null wird, wird diese einfach auf Null gesetzt, wenn der Wert recht klein ist.

	UpDown	  = own['OldUpDown']    = mouse_y * .001 * .2 + own['OldUpDown'] * .8
	LeftRight = own['OldLeftRight'] = mouse_x * .001 * .2 + own['OldUpDown'] * .8

	if abs(UpDown) < 0.001:
		UpDown=0

Wir müssen 2 Game property für die Kamera einzufügen : OldUpDown , OldLeftRight, die Beide sind float variablen

Abschließend müssen nur noch den Actuatoren die passenden Werte übergeben und diese aktiviert werden.

	actu_LookLeftRight.dRot = (0, 0,LeftRight)
	actu_LookUpDown.dRot = (UpDown,0,0)

	cont.activate(actu_LookLeftRight)
	cont.activate(actu_LookUpDown)

Damit im beim nächsten Durchlauf der Abstand von der Bildschirmmitte wieder korrekt bestimmt werden kann, muss der Mauszeiger wieder in die Mitte des Schirm gesetzt werden.

	Rasterizer.setMousePosition( int(window_width/2), int(window_height/2))

Damit das Modul jetzt verwendet werden kann, muss es noch in den Controller eingetragen werden. Dazu mouse.main in das Textfeld eintragen.

Tastatursteuerung[Bearbeiten]

Die Tastatursteuerung gestaltet sich um einiges aufwändiger und komplexer als Maussterung, da bedeutend mehr Sensoren ausgewertet werden müssen.