Zuerst benötigst du einen Spieler, der sich in der Umgebung umsehen kann.

Du kannst dafür beispelsweise ein leeres Objekt erstellen. Wähle im Hierarchiefenster mit der rechten Maustaste Createn –> Empty. Benenne das Objekt als First Person Player. Ziehe es ins Zentrum deiner Szene. Füge eine Character Controller-Componente hinzu.

Zentriere den Charakter mit F und achte darauf, dass die Gizmos aktiviert sind. Dann sind die Begrenzungen des Charakters erkennbar. Erstelle als nächstes eine Grafik, damit das Objekt besser zu erkennen ist. Gehe mit der rechten Maustaste auf das GameObject, wähle Create –> 3D–>Cylinder. Entferne dann den Capsule Collider, da der Character Controller als Collider agiert. Wähle Create–>Material, um deinem Charakter ein Material zuzuweisen. Ziehe das Material auf den Spieler.

Hast du noch keine Kamera im Spiel, kannst du sie mit der rechten Maustaste auf das GameObject kreieren oder du ziehst die MainCamera zu deinem GameObject, das als Spieler fungieren soll.

Wähle die Camera, setze die Transformkomponente auf Reset und ziehe sie nach oben in den Kopfbereich des Spielers. Die Kamera sollte nicht ganz nach oben, da die Kamera nicht durch die Decke gehen soll, wenn deine Spielfigur springt.

Du benötigst ein Script, dass dir ermöglicht, dich umzusehen. Alles wird mit der Maus bewegt und diese bewegt sich auf zwei Achsen (x und y). Bewegst du die Maus zur Seite, soll der Spieler sich auf der y-Achse rotieren. Bewegst du die Maus hoch oder runter, soll sich nicht deine Spielfigur bewegen, sondern nur die Kamera auf der x-Achse.

Die Kamerarotation sollte auf 180° beschränkt werden, damit sie nicht hinter den Spieler geht. Dieser Vorgang wird als Clamping bezeichnet. Wähle die Kamera und füge eine neue Componente hinzu: MouseLook

In der Update-Funktion des Scripts soll eine Inputfunktion für die Mausbewegung eingefügt werden.

Erstelle:

float mouseX = Input.GetAxis(„Mouse X“)

Dabei handelt es sich um einen Programmzugang innerhalb von Unity für die Mausrotation.

Dasselbe machst du für die Y-Achse:

float mouseY = Input.GetAxis(„Mouse Y“);

Jetzt möchtest du die Geschwindigkeit der Maus kontrollieren.

Deswegen erstelle unter public class:

public float mouseSensitivity = 100f;

Das Input wird mit der mouseSensitivity multipliziert.

Ein Script für ein Spiel aus der Egoperspektive schreiben

Zuerst benötigst du einen Spieler, der sich in der Umgebung umsehen kann.

Du kannst dafür beispelsweise ein leeres Objekt erstellen. Wähle im Hierarchiefenster mit der rechten Maustaste Createn –> Empty. Benenne das Objekt als First Person Player. Ziehe es ins Zentrum deiner Szene. Füge eine Character Controller-Componente hinzu.

Zentriere den Charakter mit F und achte darauf, dass die Gizmos aktiviert sind. Dann sind die Begrenzungen des Charakters erkennbar. Erstelle als nächstes eine Grafik, damit das Objekt besser zu erkennen ist. Gehe mit der rechten Maustaste auf das GameObject, wähle Create –> 3D–>Cylinder. Entferne dann den Capsule Collider, da der Character Controller als Collider agiert. Wähle Create–>Material, um deinem Charakter ein Material zuzuweisen. Ziehe das Material auf den Spieler.

Hast du noch keine Kamera im Spiel, kannst du sie mit der rechten Maustaste auf das GameObject kreieren oder du ziehst die MainCamera zu deinem GameObject, das als Spieler fungieren soll.

Wähle die Camera, setze die Transformkomponente auf Reset und ziehe sie nach oben in den Kopfbereich des Spielers. Die Kamera sollte nicht ganz nach oben, da die Kamera nicht durch die Decke gehen soll, wenn deine Spielfigur springt.

Du benötigst ein Script, dass dir ermöglicht, dich umzusehen. Alles wird mit der Maus bewegt und diese bewegt sich auf zwei Achsen (x und y). Bewegst du die Maus zur Seite, soll der Spieler sich auf der y-Achse rotieren. Bewegst du die Maus hoch oder runter, soll sich nicht deine Spielfigur bewegen, sondern nur die Kamera auf der x-Achse.

Die Kamerarotation sollte auf 180° beschränkt werden, damit sie nicht hinter den Spieler geht. Dieser Vorgang wird als Clamping bezeichnet. Wähle die Kamera und füge eine neue Componente hinzu: MouseLook

In der Update-Funktion des Scripts soll eine Inputfunktion für die Mausbewegung eingefügt werden.

Erstelle:

float mouseX = Input.GetAxis(„Mouse X“)

Dabei handelt es sich um einen Programmzugang innerhalb von Unity für die Mausrotation.

Dasselbe machst du für die Y-Achse:

float mouseY = Input.GetAxis(„Mouse Y“);

Jetzt möchtest du die Geschwindigkeit der Maus kontrollieren.

Deswegen erstelle unter public class:

public float mouseSensitivity = 100f;

Das Input wird mit der mouseSensitivity multipliziert. Außerdem soll die Bewegung unabhängig von der Framerate erfolgen. Multipliziere deine Funktion zusätzlich mit Time.deltaTime;

Das Gleiche machst du mit der Y-Achse. Damit passt sich die Rotationsgeschwindigkeit an die Framerate an.

Jetzt soll sich auch der Körper des Spielers bewegen. Dafür ist eine Referenz von der Hauptkamera zum 1st-Person Objekt notwendig.

Erstelle dafür: public Transform playerBody;

Im UpdateBereich greife auf den PlayerBody zu.

playerBody.Rotate(Vector3.up * mouseX)

Ziehe dann den Spieler in den Bereich PlayerBody.

Jetzt geht es darum, hoch und runter zu schauen. Dafür muss die Maus um die X-Achse rotieren.

Erstelle dafür eine private Variable:

float xRotation = 0f

Im Updatebereich füge hinzu:

xRotation -=mouseY;

Jetzt wird die Rotation hinzugefügt:

transform.localRotation = Quaternion.Euler()

Quaternion ist in Unity verantwortlich für die Rotation in Unity. Dazu kommen der x-, der y- und der z-Wert.

transform.localRotation = Quaternion.Euler(xRotation, 0f, 0f);

Für diese Rotation muss jetzt das „Clamping“ hinzugefügt werden.

Dafür benötigst du:

xRotation = Mathf.Clamp(xRotation, -90f, 90f)

Damit wird die Kamerabewegung auf -90f und 90f eingegrenzt. So gehst du auf Nummer sicher, dass die Kamera nicht hinter den Spieler überrotiert.

In der Startfunktion fehlt noch ein Code, den Cursor auf das Bildschirmzentrum als Ausgangspunkt festlegt.

Cursor.lockState = CursorLockMode.Locked;

Das Script sieht jetzt folgendermaßen aus:

Als nächstes folgt die Spielerbewegung. Für die Spielerbewegung sind Eingaben notwendig. Die Eingaben sind für die horizontale und vertikale Achse nötig. Die Bewegungstasten, die in Unity vordefiniert sind, befinden sich auf der Tastatur und sind W, A, S und D.

Für W ist Vertical = 1

S -> Vertical = -1

Das gleiche gilt für Horizontal:

A -> -1

D -> 1

Diese Einstellungen funktionieren zeitgleich für den Controller.

Entlang der x-Achse bewegt sich der Spieler zur Seite und entlang der z-Achse nach vorne und zurück.

Die Bewegung muss immer relativ zu der Richtung erfolgen, in welche der Spieler guckt.

Wir benötigen dafür das PlayerMovement Script, dass in Visual Studio geschrieben wird. Füge dieses zum FirstPersonPlayer hinzu.

Erstelle unter void Update:

float x = Input.GetAxis(„Horizontal“);

float z = Input.GetAxis(„Vertical“);

Jetzt wird der Input in die Richtung verwandelt, in die der Spieler sich bewegen soll.

Verctor3 move = transform.right * x + transform.forard * z;

Damit hast du eine Richtung erstellt, die auf der Spielerbewegung und die jeweilige x- und z-Bewegung basiert. Dadurch bewegt sich die Spielfigur immer auf Basis der Richtung, in der er blickt.

Zusätzlich wird ein Verweis auf den Character Controller benötigt.

Erstelle jetzt als public den CharacterController:

public CharacterController controller;

Entferne die Start-Nachricht.

Füge jetzt unter Vector3 move ein:

controller.Move(move);

Zusätzlich soll die Geschwindigkeit der Bewegung kontrolliert werden können:

public float speed = 12f;

Multipliziere deswegen die Controllerbewegungen mit der Geschwindigkeit:

controller.Move(move * speed);

Dazu kommt noch „* Time.deltaTime“);

da es sich im UpdateBereich befindet.

controller.Move(move * speed * Time.deltaTime);

Damit wird die Framerate unabhängig gemacht.

Anschließend wird der CharacterController ins Feld gezogen. Bewegt sich die Kamera, bewegt sich auch die Richtung, in die sich der Spieler bewegt.

Um beispielsweise Treppen steigen zu können, ist es notwendig, den StepOffset des CharacterControllers zu steigern, wie z. B. auf 0.7

Step Offset definiert, wie hoch die Stufen sind, die du erklimmen kannst. Unter Slope Limit definierst du den Winkel, den dein Charakter klettern kann.

Als nächstes benötigst du Gravitation, damit dein Charakter nicht in der Luft hängen bleibt, wenn er beispielsweise Treppen hochgesteigen ist.

Die Gravitation definiert sich als Kraft, die sich innerhalb einer bestimmten Zeit auswirkt. Damit steigert sich die Geschwindigkeit, wenn sie Wirkung zeigt. Es wird eine Geschwindigkeitsvariable benötigt.

Du benötigst:

Vector 3 velocity;

Die Geschwindigkeit bezüglich der y-Achse wird mit einer Gravitationskonstante eingestellt.

velocity.y +=

Erstelle außerdem: public float gravity = -9,81f;

Anschließend fügst du die Gravitation zur Geschwindigkeit hinzu.

velocity.y += gravity * Time.deltaTime;

Um die Geschwindigkeit hinzuzufügen setzt du dazu:

controller.Move(velocity * Time.deltaTime)

Delta y ergibt sich aus der Hälfte der Gravitation mulitpliziert mit Zeit zum Quadrat.

Aus diesem Grund wird die Geschwindigkeit nocheinmal mit Time.deltaTime multipliziert.

Das fertige Script sieht folgendermaßen aus:

Jetzt hat Graviation Auswirkungen auf den Spieler.

Erstelle ein leeres Objekt und ziehe es bei deinem Spieler nach unten und nenne es GroundCheck. Dieses Objekt nimmt einen Physikcheck vor, ob der Spieler auf dem Boden steht. Damit das Objekt diesen Check vornehmen kann, muss eine Verbindung im Script hergestellt werden.

Füge hinzu:

public Transform groundCheck;

public float groundDistance = 0.4f;

Dazu kommt eine

public LayerMask groundMask;

Weiterhin benötigst du eine Variable, die feststellt, ob der Spieler sich auf dem Boden befindet:

bool isGrounded;

Jetzt kommt der Zusatz zur updateFunktion:

isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);

Damit wird anhand der Physik überprüft, ob die Figur am Boden ist. Sie ist dies, wenn das Objekt bzw. die Sphere die Position, Entfernung und die Mask am Boden sind.

Erstellt wird beim neuen GameObject eine kleine unsichtbare Sphäre an einem festgelegten Punkt. Wenn sie mit etwas kollidiert, das sich in der GroundMask befindet ist der Spieler auf dem Boden. Ansonsten, ist es der Spieler nicht.

Dazu kommt:

if(isGrounded && velocity.y <0)

{

velocity.y = 2f;

}

Damit zwingst du den Spieler auf den Boden.

Das Script sieht jetzt folgendermaßen aus:

Zieh den GroundCheck in das jeweilige Feld vom PlayerScript.

Füge bei der Ground Mask die Ebene bzw. für Layer ein. Du kannst auch neue Layers rechts oben neu definieren.

Umwelt, die als Boden agieren soll, musst du auf die jeweilige Layer umstellen.

Fällt die Spielfigur zu langsam, kannst du die Gravitation erhöhen.

Für das Springen definiert sich die Geschwindigkeit aus der Sprunghöhe:

Geschwindigkeit = Wurzel aus (Sprunghöhe * -2 * Gravitation)

Du benötigst dafür:

if(Input.GetButtonDown(„Jump“) && isGrounded)

{

velocity.y=Mathf.Sqrt()

}

Jetzt fügst du noch eine öffentliche Variable für die Sprunghöhe ein:

public float jumpHeight = 3f;

Anschließend lässt du aus: jumpHeight * -2f * gravity die Wurzel ziehen.

velocity.y=Mathf.Sqrt(jumpHeight * -2f * gravity)

Das fertige Script sieht folgendermaßen aus:

Damit das Springen funktioniert, sollte der Boden dem Layer Ground zugeordnet sein. Sonst funktioniert das Script mit dem Springen nicht.