Ein Camera Follow Script sorgt dafür, dass eine Kamera einem bestimmten GameObject folgt. In einem 2D-Plattformer ist dieses Ziel meistens die Spielfigur. Bewegt sie sich durch das Level, passt das Script die Position der Kamera an, sodass der Spieler innerhalb des sichtbaren Bildausschnitts bleibt.
Unity stellt dafür verschiedene Möglichkeiten bereit. Du kannst ein eigenes C#-Script schreiben, die Kamera als Child-Objekt an den Spieler koppeln oder ein Kamerasystem wie Cinemachine verwenden. Welche Lösung sinnvoll ist, hängt davon ab, wie sich die Kamera während des Spiels verhalten soll.
Was ist ein Camera Follow Script?
Ein Camera Follow Script ist keine fest eingebaute Unity-Komponente mit einer einheitlichen Funktionsweise. Die Bezeichnung steht üblicherweise für ein selbst erstelltes Script, das die Kameraposition anhand eines Zielobjekts berechnet.
Das Script kann direkt auf der Main Camera liegen. Dort greift es auf den Transform der Kamera zu und verändert ihre Position entsprechend der Bewegung des Spielers.
Ein einfaches Follow-System berücksichtigt zunächst nur die Position des Zielobjekts. Erweiterte Varianten können zusätzlich die Geschwindigkeit, Bewegungsrichtung, Levelgrenzen oder besondere Spielsituationen einbeziehen.
Warum benötigt ein Spiel eine Kamerasteuerung?
Eine feststehende Kamera zeigt immer denselben Ausschnitt der Spielwelt. Das eignet sich beispielsweise für einzelne Räume, Bildschirmrätsel oder Szenen, deren gesamter Spielbereich innerhalb des Kamerabildes liegt.
Bei größeren Levels reicht ein fester Ausschnitt dagegen häufig nicht aus. Verlässt die Spielfigur den sichtbaren Bereich, kann der Spieler ihre Position nicht mehr erkennen.
Ein Camera Follow Script verschiebt den Bildausschnitt zusammen mit dem Zielobjekt. Dabei muss die Kamera nicht zwangsläufig jede Bewegung exakt übernehmen. Sie kann auch mit Verzögerung folgen oder innerhalb bestimmter Grenzen stehen bleiben.
Die Main Camera als Ausgangspunkt
In vielen Unity-Projekten übernimmt die Main Camera die Darstellung der Spielwelt. Sie besitzt einen Transform, der ihre Position und Ausrichtung festlegt, sowie eine Camera-Komponente für die eigentlichen Darstellungseinstellungen.
Ein Camera Follow Script verändert hauptsächlich den Transform. Die Camera-Komponente bleibt weiterhin für das Rendering zuständig.
Mehr über den Aufbau der Kamera erfährst du im Artikel Unity Main Camera – der Blick auf deine Spielwelt.
Direktes Folgen ohne Verzögerung
Die einfachste Variante einer Kamerasteuerung übernimmt die Position des Spielers. Damit sich die Kamera nicht an derselben räumlichen Stelle wie die Spielfigur befindet, ergänzt du einen festen Abstand.
Dieser Abstand wird als Offset bezeichnet. Bei einem klassischen 2D-Spiel befindet sich die Kamera häufig auf der negativen Z-Achse, während die Spielfigur ungefähr auf Z = 0 steht.
Ein einfaches Script kann folgendermaßen aussehen:
using UnityEngine;
public class CameraFollow : MonoBehaviour
{
public Transform target;
public Vector3 offset = new Vector3(0f, 0f, -10f);
private void LateUpdate()
{
if (target == null)
{
return;
}
transform.position = target.position + offset;
}
}Die Variable target enthält den Transform des Zielobjekts. Über offset bestimmst du den Abstand zwischen Kamera und Spieler.
Das Script setzt die Kameraposition in jedem Frame auf die Position des Zielobjekts zuzüglich des festgelegten Offsets. Dadurch folgt die Kamera unmittelbar.
Warum eignet sich LateUpdate für die Kamera?
Unity führt verschiedene Aktualisierungsmethoden innerhalb eines Frames aus. Dazu gehören unter anderem Update(), FixedUpdate() und LateUpdate().
Viele Bewegungs-Scripts verändern die Position einer Spielfigur während Update(). Die Methode LateUpdate() wird anschließend aufgerufen und eignet sich deshalb häufig für Kameras, die auf die bereits aktualisierte Spielerposition reagieren sollen.
Dadurch lässt sich vermeiden, dass die Kamera innerhalb eines Frames noch mit einer älteren Position des Zielobjekts arbeitet. Allerdings hängt die optimale Aktualisierung auch davon ab, wie du die Spielfigur bewegst und ob Rigidbody-Interpolation zum Einsatz kommt.
Ein Camera Follow Script in Unity einrichten
Damit das Script funktioniert, musst du es zunächst in deinem Unity-Projekt anlegen und anschließend der Kamera zuweisen.
- Erstelle im Project-Fenster ein neues C#-Script mit dem Namen CameraFollow.
- Öffne die Datei und füge den gewünschten Programmcode ein.
- Speichere das Script und wechsle zurück zu Unity.
- Wähle die Main Camera in der Hierarchy aus.
- Füge das Script als Komponente zur Kamera hinzu.
- Ziehe das GameObject deiner Spielfigur aus der Hierarchy in das Feld Target.
- Kontrolliere den Offset und starte anschließend den Play Mode.
Bewegt sich die Spielfigur, sollte die Kamera ihrer Position folgen. Falls das nicht geschieht, prüfe zunächst, ob das Target-Feld korrekt zugewiesen ist und ob das Script im Inspector aktiviert wurde.
Warum der Offset wichtig ist
Der Offset beschreibt den gewünschten Abstand zwischen Kamera und Zielobjekt. Er besteht aus den drei Werten X, Y und Z.
Bei einem seitlich dargestellten 2D-Spiel kann ein negativer Z-Wert dafür sorgen, dass die Kamera vor der Spielebene steht und auf die dort platzierten Sprites blickt. Die X- und Y-Werte verschieben den Spieler dagegen innerhalb des sichtbaren Ausschnitts.
Ein positiver Y-Offset kann beispielsweise sinnvoll sein, wenn du oberhalb der Spielfigur mehr von der Umgebung zeigen möchtest. Ein X-Offset verschiebt den Bildmittelpunkt seitlich.
Der passende Offset hängt von der Kameraprojektion, dem Levelaufbau und der gewünschten Bildkomposition ab. Er muss deshalb nicht in jedem Projekt dieselben Werte besitzen.
Weiche Kamerabewegungen mit SmoothDamp
Eine Kamera, die jede Positionsänderung des Spielers unmittelbar übernimmt, kann bei schnellen Bewegungen unruhig wirken. Besonders häufig fällt das auf, wenn die Spielfigur abrupt ihre Richtung wechselt.
Mit Vector3.SmoothDamp kannst du eine gedämpfte Bewegung umsetzen. Die Kamera nähert sich dabei dem Ziel mit einem weicheren Übergang.
Das folgende Script ergänzt das einfache Follow-System um eine einstellbare Dämpfung:
using UnityEngine;
public class SmoothCameraFollow : MonoBehaviour
{
public Transform target;
public Vector3 offset = new Vector3(0f, 0f, -10f);
public float smoothTime = 0.2f;
private Vector3 velocity = Vector3.zero;
private void LateUpdate()
{
if (target == null)
{
return;
}
Vector3 desiredPosition = target.position + offset;
transform.position = Vector3.SmoothDamp(
transform.position,
desiredPosition,
ref velocity,
smoothTime
);
}
}Die Variable smoothTime beeinflusst, wie schnell sich die Kamera dem Ziel annähert. Kleinere Werte führen im Allgemeinen zu einer direkteren Reaktion. Größere Werte erzeugen eine deutlichere Verzögerung.
Der Parameter velocity speichert den Bewegungszustand, den SmoothDamp zwischen den Aufrufen benötigt. Deshalb wird er als Variable außerhalb von LateUpdate() angelegt.
Für die Dämpfung gibt es keinen universell richtigen Wert. Eine schnelle Spielfigur in einem anspruchsvollen Plattformer benötigt möglicherweise eine direktere Kameraführung als ein ruhiges Erkundungsspiel.
Kamera mit Lerp bewegen
Eine weitere Möglichkeit zur Interpolation bietet Vector3.Lerp. Damit berechnest du eine Position zwischen dem aktuellen Standort der Kamera und einer gewünschten Zielposition.
Ein vereinfachter Aufruf sieht folgendermaßen aus:
Vector3 desiredPosition = target.position + offset;
transform.position = Vector3.Lerp(
transform.position,
desiredPosition,
followSpeed * Time.deltaTime
);Der Ausdruck setzt voraus, dass target, offset und followSpeed bereits im Script definiert sind.
Wird Lerp auf diese Weise in jedem Frame wiederholt, nähert sich die Kamera dem Ziel schrittweise an. Die Bewegung unterscheidet sich jedoch von SmoothDamp: Der Interpolationsfaktor bestimmt jeweils den Anteil des verbleibenden Abstands, der innerhalb des aktuellen Frames zurückgelegt wird.
Für eine gezielt gedämpfte Kamerabewegung mit einem einstellbaren Annäherungsverhalten ist SmoothDamp häufig leichter abzustimmen.
Horizontales und vertikales Folgen trennen
Ein Camera Follow Script muss nicht zwangsläufig alle Bewegungen der Spielfigur übernehmen. Bei einem 2D-Plattformer kann es sinnvoll sein, die Kamera horizontal folgen zu lassen, während ihre vertikale Position zunächst unverändert bleibt.
Das verhindert beispielsweise, dass jeder kleine Sprung die gesamte Kamera nach oben und unten bewegt.
Eine einfache Variante berücksichtigt deshalb nur die X-Position des Spielers:
using UnityEngine;
public class HorizontalCameraFollow : MonoBehaviour
{
public Transform target;
public float xOffset = 0f;
private void LateUpdate()
{
if (target == null)
{
return;
}
Vector3 cameraPosition = transform.position;
cameraPosition.x = target.position.x + xOffset;
transform.position = cameraPosition;
}
}Die Y- und Z-Position der Kamera bleiben bei dieser Variante erhalten. Nur die horizontale Position verändert sich entsprechend dem Zielobjekt.
Für Levels mit großen Höhenunterschieden reicht eine ausschließlich horizontale Kamerabewegung allerdings möglicherweise nicht aus. Dort kannst du zusätzliche Regeln für die vertikale Bewegung ergänzen.
Eine Dead Zone für die Kamera einrichten
Eine Dead Zone beschreibt einen Bereich innerhalb des Kamerabildes, in dem sich die Spielfigur bewegen darf, ohne dass die Kamera sofort folgt.
Erst wenn der Spieler diesen Bereich verlässt, beginnt die Kamera, ihre Position anzupassen. Dadurch bleibt das Bild bei kleinen Bewegungen ruhiger.
Das kann besonders bei Spielen sinnvoll sein, in denen die Spielfigur häufig zwischen benachbarten Positionen wechselt oder kurze Sprünge ausführt.
Eine Dead Zone lässt sich mit eigenen Positionsberechnungen umsetzen. Alternativ bietet Cinemachine entsprechende Möglichkeiten innerhalb seiner Kamerasteuerung.
Die Kamera innerhalb der Levelgrenzen halten
Ein weiteres Problem entsteht, wenn die Kamera dem Spieler bis an den Rand eines Levels folgt. Ohne zusätzliche Begrenzung kann sie Bereiche außerhalb der eigentlichen Spielwelt zeigen.
Das fällt beispielsweise auf, wenn links oder rechts neben dem Level keine Hintergrundgrafik mehr vorhanden ist. Die Kamera zeigt dann möglicherweise einen leeren Bereich.
Mit Mathf.Clamp kannst du die erlaubte Kameraposition innerhalb bestimmter Grenzen halten.
using UnityEngine;
public class BoundedCameraFollow : MonoBehaviour
{
public Transform target;
public Vector3 offset = new Vector3(0f, 0f, -10f);
public float minX = -10f;
public float maxX = 10f;
public float minY = -5f;
public float maxY = 5f;
private void LateUpdate()
{
if (target == null)
{
return;
}
Vector3 desiredPosition = target.position + offset;
float clampedX = Mathf.Clamp(
desiredPosition.x,
minX,
maxX
);
float clampedY = Mathf.Clamp(
desiredPosition.y,
minY,
maxY
);
transform.position = new Vector3(
clampedX,
clampedY,
desiredPosition.z
);
}
}Die Variablen minX, maxX, minY und maxY definieren die erlaubten Positionen des Kameramittelpunkts.
Beachte dabei, dass dieses Beispiel lediglich die Kameraposition begrenzt. Die tatsächlichen Ränder des sichtbaren Bildes hängen zusätzlich von der Orthographic Size beziehungsweise vom Sichtfeld und Seitenverhältnis der Kamera ab.
Möchtest du verhindern, dass außerhalb des Levels liegende Bereiche sichtbar werden, musst du die Ausdehnung des Kamerabildes bei der Berechnung der Grenzen berücksichtigen.
Levelgrenzen und Orthographic Size
Bei einer orthografischen Kamera beschreibt die Orthographic Size die halbe sichtbare Höhe des Kamerabildes in Unity-Einheiten. Die sichtbare Breite ergibt sich zusätzlich aus dem Seitenverhältnis.
Verwendest du beispielsweise eine Orthographic Size von 5, beträgt die sichtbare Höhe 10 Unity-Einheiten. Bei einem Seitenverhältnis von 16:9 ist die sichtbare Breite entsprechend größer.
Eine Kamera, deren Mittelpunkt genau am äußersten Rand des Levels steht, zeigt deshalb normalerweise bereits Bereiche außerhalb dieser Grenze.
Für eine vollständige Begrenzung musst du die halbe sichtbare Breite beziehungsweise Höhe von den Levelgrenzen abziehen oder zu ihnen addieren. Bei sehr kleinen Levels, die nicht vollständig in den Kamerabereich passen, benötigst du außerdem eine passende Sonderbehandlung.
Warum die Kamera beim Springen unruhig wirken kann
Folgt eine Kamera jeder vertikalen Bewegung der Spielfigur unmittelbar, verändert sich der Bildausschnitt bei jedem Sprung. Das kann den Eindruck erzeugen, dass die gesamte Umgebung auf und ab schwingt.
Eine mögliche Lösung besteht darin, die vertikale Kamerabewegung stärker zu dämpfen als die horizontale. Eine andere Variante nutzt einen Bereich, innerhalb dessen die Spielfigur springen darf, ohne die Kamera zu verschieben.
Auch ein zeitlich verzögertes Folgen oder eine feste Kamerahöhe für bestimmte Levelabschnitte kommt infrage.
Welche Variante sich eignet, hängt von der Bewegungsgeschwindigkeit, den Sprunghöhen und der Gestaltung des Levels ab. Wichtig ist vor allem, dass der Spieler relevante Hindernisse und Plattformen rechtzeitig erkennen kann.
Camera Follow und Rigidbody2D
Verwendet deine Spielfigur einen Rigidbody2D, erfolgt ihre physikalische Bewegung häufig im Zusammenhang mit dem festen Physik-Zeitschritt. Die Darstellung auf dem Bildschirm wird dagegen mit der Bildrate aktualisiert.
Dadurch können sichtbare Unterschiede zwischen der Bewegung des Spielers und der Kamera entstehen. Besonders bei einer Kamera, die dem Ziel sehr eng folgt, kann das als leichtes Ruckeln auffallen.
Eine mögliche Gegenmaßnahme ist die Rigidbody2D-Interpolation. Sie kann die dargestellte Bewegung zwischen den Physikaktualisierungen glätten.
Ob diese Einstellung sinnvoll ist, hängt von der Art deiner Spielerbewegung ab. Prüfe deshalb zunächst, ob das Ruckeln tatsächlich aus dem Zusammenspiel von Physik und Kamerasteuerung entsteht.
Camera Follow und die Z-Achse
Bei einem 2D-Spiel ist die Z-Position der Kamera besonders wichtig. Sie sorgt dafür, dass die Kamera mit ausreichendem Abstand auf die Spielebene blickt.
Übernimmst du die vollständige Position des Spielers ohne Offset, kann die Kamera auf derselben Z-Position wie die Spielfigur landen. Je nach Kamerakonfiguration verschwinden die Sprites dann möglicherweise aus dem sichtbaren Bereich.
Deshalb sollte ein Follow-Script den benötigten Z-Abstand erhalten. Bei einer orthografischen 2D-Kamera ist beispielsweise ein fester negativer Z-Wert üblich, sofern die Kamera in Richtung der positiven Z-Achse blickt.
Die Kamera als Child des Spielers
Eine einfache Alternative zum Camera Follow Script besteht darin, die Main Camera in der Hierarchy als Child der Spielfigur einzurichten.
Dadurch übernimmt die Kamera die Bewegungen ihres Parent-Objekts. Ein separates Follow-Script ist für diese grundlegende Kopplung nicht erforderlich.
Allerdings folgt die Kamera dann auch Transformationen des Parents. Dreht oder skaliert sich die Spielfigur, kann sich dies auf die Kamera auswirken.
Außerdem fehlen ohne weitere Komponenten oder Scripts Funktionen wie Dämpfung, Dead Zones oder Levelbegrenzungen. Für komplexere Kamerabewegungen eignet sich deshalb häufig eine eigenständige Steuerung.
Camera Follow bei mehreren Spielfiguren
Ein Follow-System muss nicht zwangsläufig nur einem einzigen GameObject folgen. Bei Spielen mit mehreren Figuren kann die Kamera beispielsweise einen gemeinsamen Mittelpunkt berechnen.
Dazu lassen sich die Positionen der beteiligten Figuren auswerten. Die Kamera richtet ihren Bildausschnitt anschließend so aus, dass möglichst alle relevanten Objekte sichtbar bleiben.
Bei einer orthografischen Kamera kann zusätzlich die Orthographic Size angepasst werden, um den sichtbaren Bereich zu vergrößern oder zu verkleinern.
Solche Systeme benötigen allerdings zusätzliche Regeln, beispielsweise für Mindestabstände, maximale Zoomstufen und die Begrenzung des Kamerabildes.
Weiter geht es zur Unity
Andere Artikel auf Games und Lyrik:
