Hallo! In diesem Schritt-für-Schritt-Tutorial erstellen wir gemeinsam
einen einfachen 2D-Platformer mit der
Unity-Engine. Dieses Tutorial ist für Einsteiger
geeignet: Du musst kein Experte sein, wir erklären alles klar und
ausführlich. Wir nutzen die integrierte
Unity-2D-Physik, fügen etwas Animation hinzu und
lernen, wie man mit Sprite-Sheets arbeitet.
Für dieses Tutorial benötigst du einige Ressourcen:
Sprites, Sounds und Scripts.
📦 .zip-Archiv für das Projekt herunterladen 📦
— darin ist alles enthalten, was du für den Start deines Platformers in
Unity brauchst.
Öffne Unity und erstelle ein neues 2D-Projekt. Wähle dazu am besten 2D Built-in Render Pipeline — oder ein anderes 2D-Template, das dir passt.
Zuerst richten wir die Grundlagen des Spiels ein, indem wir das Boden-Objekt und den Spieler hinzufügen.
Entpacke das heruntergeladene .zip
-Archiv und importiere
das Sprite largeGround
in Unity. Ziehe
largeGround
in die Szene und benenne das erstellte
GameObject in Ground um.
Wähle Ground in der Hierarchie aus. Im Inspector:
0
ist.
Jetzt fügen wir den Spieler hinzu. Importiere das Sprite-Sheet
ratIdle
(es ist ebenfalls im Archiv enthalten). Unity schneidet Sprite-Sheets
meist automatisch, dabei kann es aber leicht zu Verschiebungen kommen,
was später zu ruckelnden Animationen führt. Deshalb ist es besser, das
manuell einzustellen. Dieses Sprite-Sheet ist für ein Raster mit 4 × 5
Sprites ausgelegt.
ratIdle
im Assets-Ordner aus.Multiple
.
4
und Rows (R): 5
ein und
klicke Slice.
Erweitere das Sprite Sheet – es sollte jetzt 20 Einzelbilder enthalten. Ziehe das erste in die Szene. Benenne das neue GameObject in Rat um.
Wähle das Rat-GameObject und nimm folgende Einstellungen vor:
Player
.0
beträgt.Interpolate
.
Damit der Sprung funktioniert, müssen wir auch definieren, was als
„Boden“ zählt. Wähle das Objekt Ground aus und setze
dessen Layer auf Ground
. Falls dieser
Layer noch nicht existiert, erstelle ihn zuerst.
Jetzt bringen wir unsere Ratte in Bewegung! Wir erstellen ein neues Skript, das sowohl für das Laufen als auch das Springen zuständig ist.
Klicke im Ordner Assets mit der rechten Maustaste und
erstelle ein neues MonoBehaviour-Skript. Nenne es
PlayerMove
. Dieses Skript nutzt die Komponente
Rigidbody2D, um den Spieler mit der eingebauten
Physik von Unity zu bewegen. Außerdem fügen wir einen Sprung hinzu,
der eine Kraft entlang der Y-Achse anwendet. Um zu prüfen, ob der
Spieler auf dem Boden steht, verwenden wir
Physics2D.OverlapPoint
. Tatsächlich liefern
OverlapCircle
oder OverlapBox
eine noch
zuverlässigere Bodenprüfung, aber für das grundlegende Prinzip eines
Platformers reicht OverlapPoint
hier völlig aus.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerMove : MonoBehaviour
{
// Welche Layer gelten als „Boden“ (im Inspector setzen)
public LayerMask whatIsGround;
// Position zur Bodenprüfung
public Transform groundCheck;
// Steht die Ratte gerade auf dem Boden?
public bool isGrounded;
// Wie hoch die Ratte springt
public float jumpForce;
// Wie schnell sie sich seitlich bewegt
public float speed;
// Referenz auf Rigidbody2D
Rigidbody2D rb;
void Start()
{
// Referenz auf das Rigidbody2D des Objekts holen
rb = GetComponent<Rigidbody2D>();
}
void Update()
{
// Wenn die Sprungtaste gedrückt wird und die Ratte auf dem Boden ist
if (Input.GetButtonDown("Jump") && isGrounded)
{
// Kraft nach oben anwenden (Sprung)
rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
// Doppelsprung verhindern — wird in FixedUpdate zurückgesetzt
isGrounded = false;
}
}
void FixedUpdate()
{
// Prüfen, ob GroundCheck den Bodenlayer berührt
isGrounded = Physics2D.OverlapPoint(groundCheck.position, whatIsGround);
// Horizontale Eingabe abfragen (Pfeile oder A/D)
float x = Input.GetAxis("Horizontal");
// Bewegungsvektor erstellen (vertikale Geschwindigkeit beibehalten)
Vector3 move = new Vector3(x * speed, rb.linearVelocity.y, 0f);
// Bewegung auf das Rigidbody anwenden
rb.linearVelocity = move;
}
}
Hänge das Skript PlayerMove
an das GameObject
Rat. Im Inspector: Setze Speed auf
3
und Jump Force auf 5
.
Erstelle jetzt ein Kindobjekt, das den Boden erkennt. Rechtsklick auf
Rat in der Hierarchie → Create Empty,
benenne es in GroundCheck
um und verschiebe es knapp
unter die Füße der Ratte (aber außerhalb des Colliders).
Wähle jetzt erneut Rat. Im PlayerMove-Komponent:
Ground Check
das Objekt
GroundCheck zu.
What Is Ground
den Layer
Ground
.
💡 Tipp: Falls der Layer Ground
nicht
angezeigt wird, stelle sicher, dass du das Bodenobjekt ausgewählt hast
und der Layer korrekt angelegt ist.
Drücke Play – jetzt sollte sich die Ratte nach links und rechts bewegen (Pfeiltasten oder A/D) und springen, wenn sie am Boden ist.
Die Ratte kann sich jetzt bewegen und springen — aber sie schaut immer nur in eine Richtung. Lass uns dafür sorgen, dass sie sich abhängig von der Eingabe nach links oder rechts dreht. Dafür fügen wir dem Skript eine neue Variable hinzu und schreiben eine Funktion, die das Sprite der Ratte bei Richtungswechsel spiegelt.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerMove : MonoBehaviour
{
// Welche Layer gelten als "Boden" (im Inspector setzen)
public LayerMask whatIsGround;
// Position zur Überprüfung, ob die Ratte am Boden ist
public Transform groundCheck;
// Ist die Ratte momentan am Boden?
public bool isGrounded;
// Sprungkraft
public float jumpForce;
// Bewegungsgeschwindigkeit (links/rechts)
public float speed;
// Referenz auf Rigidbody2D
Rigidbody2D rb;
// Gibt an, ob die Ratte gerade nach links schaut
public bool isLookingLeft;
void Start()
{
// Rigidbody2D-Komponente holen
rb = GetComponent<Rigidbody2D>();
}
void Update()
{
// Wenn Sprungtaste gedrückt und Ratte am Boden
if (Input.GetButtonDown("Jump") && isGrounded)
{
// Sprungkraft anwenden
rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
// Doppelsprung verhindern – wird in FixedUpdate zurückgesetzt
isGrounded = false;
}
}
void FixedUpdate()
{
// Prüfen, ob GroundCheck Boden berührt
isGrounded = Physics2D.OverlapPoint(groundCheck.position, whatIsGround);
// Horizontale Eingabe abfragen
float x = Input.GetAxis("Horizontal");
// Bewegungsvektor erstellen (vertikale Geschwindigkeit beibehalten)
Vector3 move = new Vector3(x * speed, rb.linearVelocity.y, 0f);
// Bewegung anwenden
rb.linearVelocity = move;
// Wenn nach links bewegt, aber noch nicht nach links schaut – drehen
if (x < 0 && !isLookingLeft)
TurnTheRat();
// Wenn nach rechts bewegt und gerade nach links schaut – drehen
if (x > 0 && isLookingLeft)
TurnTheRat();
}
// Spiegelung durch Invertierung der X-Skalierung
void TurnTheRat()
{
// Blickrichtung umkehren
isLookingLeft = !isLookingLeft;
// Sprite optisch spiegeln
transform.localScale = new Vector3(
transform.localScale.x * -1,
transform.localScale.y,
transform.localScale.z
);
}
}
Wähle das Rat-Objekt in der Hierarchie. Im
PlayerMove-Skript aktiviere das Häkchen bei
Is Looking Left
— das sollte zur Anfangsorientierung des
Sprites passen (z. B. wenn deine Ratte standardmäßig nach links
schaut).
Das war's! Jetzt dreht sich die Ratte beim Laufen in die richtige Richtung. Eine kleine Änderung – aber sie macht die ganze Szene lebendiger.
Zeit, unsere Ratte zu animieren! Zuerst fügen wir einen Animator-Komponenten hinzu und erstellen einen Controller.
Wähle das GameObject Rat in der Hierarchie aus. Im Inspector: klicke auf Add Component und wähle Animator.
Öffne nun das Fenster Assets, klicke mit der rechten
Maustaste und erstelle einen neuen
Animator Controller. Benenne ihn
RatAnimator
.
Wechsle zurück zum Objekt Rat und trage den neuen
RatAnimator
-Controller in das Feld
Controller des Animator-Komponenten ein.
Jetzt bringen wir die Ratte mit ihrer ersten Animation zum Leben – einer Idle-Loop-Animation.
Öffne das Fenster Animation, falls es noch nicht sichtbar ist. Du findest es unter Window → Animation → Animation. Du kannst es platzieren, wo es dir am besten passt (zum Beispiel über dem Assets-Fenster).
Wähle Rat in der Hierarchie. Klicke im Fenster
Animation auf Create und speichere die neue Animation
unter dem Namen IdleRatAnimation
.
Jetzt fügen wir die Frames aus dem Sprite-Sheet hinzu. Öffne im
Fenster Assets den Ordner ratIdle
. Wähle
alle 20 Frames aus: klicke auf den ersten Frame, halte
Shift gedrückt und klicke auf den letzten. Ziehe alle
ausgewählten Bilder auf die Timeline im Fenster Animation.
Öffne nun das Fenster Animator (Window → Animation →
Animator), falls es noch nicht sichtbar ist. Doppelklicke auf den
Zustand IdleRatAnimation
— oder wähle ihn direkt in den
Assets. Im Inspector stelle sicher, dass
Loop Time aktiviert ist.
Du kannst auch die
Speed der Animation anpassen — zum Beispiel auf
0.5
setzen, damit die Bewegung weicher wirkt.
Jetzt animieren wir die Bewegung der Ratte! Wir erstellen eine Laufanimation und richten die Übergänge ein.
Importiere zuerst das Sprite ratRun
aus dem Archiv in
deinen Assets-Ordner.
Genau wie bei ratIdle
in Schritt 1: Wähle das
ratRun
-Sprite im Assets-Ordner aus,
stelle Sprite Mode auf Multiple
und
klicke auf Apply. Öffne dann den Sprite Editor,
wähle Slice → Grid by Cell Count, gib Spalten (C):
4
und Zeilen (R): 5
ein, klicke auf
Slice und dann auf Apply.
Wähle Rat in der Hierarchie. Klicke im Fenster
Animation auf das Dropdown-Menü neben
IdleRatAnimation
und wähle
Create New Clip. Benenne die neue Animation
RunRatAnimation
.
(Stelle sicher, dass Rat in der Hierarchie ausgewählt ist – sonst
lässt Unity keine neue Animation zu.)
Öffne in den Assets ratRun
und wähle alle 20 Frames aus:
erster Frame → Shift halten → letzter Frame. Ziehe
sie dann in das Fenster Animation, um die Timeline zu
füllen.
Öffne das Fenster Animator. Falls es nicht sichtbar ist, gehe zu Window → Animation → Animator.
Standardmäßig ist IdleRatAnimation
der Startzustand. Wir
erstellen jetzt einen Parameter vom Typ Float, um
zwischen Idle und Lauf zu wechseln.
Speed
hinzu.
IdleRatAnimation
→
Make Transition → auf
RunRatAnimation
klicken.
RunRatAnimation
zu
IdleRatAnimation
erstellen.
Jetzt konfigurieren wir die Übergänge:
IdleRatAnimation → RunRatAnimation
.
Speed
auf Greater als
0.1
.
RunRatAnimation → IdleRatAnimation
.
Speed
Less als
0.1
.
Um die Animationen passend zu steuern, erstellen wir ein kleines
Skript, das Bewegungsinformationen an den Animator übergibt. So kann
automatisch zwischen Idle
und Run
gewechselt
werden — abhängig von der Geschwindigkeit der Ratte.
Erstelle im Ordner Assets ein neues
MonoBehaviour
-Skript und nenne es
PlayerAnim
. Füge folgenden Code ein:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerAnim : MonoBehaviour
{
// Referenz auf den Animator
Animator anim;
// Referenz auf das Rigidbody2D
Rigidbody2D rb;
void Start()
{
anim = GetComponent<Animator>();
rb = GetComponent<Rigidbody2D>();
}
void Update()
{
// Animator mit aktueller Bewegungsgeschwindigkeit (Betrag der X-Geschwindigkeit) aktualisieren
anim.SetFloat("Speed", Mathf.Abs(rb.linearVelocity.x));
}
}
Hänge das PlayerAnim
-Skript an das GameObject
Rat.
Und das war’s! Wenn du die Szene jetzt startest, wird die Animation automatisch zwischen Idle und Run wechseln — je nachdem, ob sich die Ratte bewegt.
Jetzt erstellen wir eine Sprunganimation für unsere Ratte. Wir haben
zwar kein spezielles Sprite dafür, aber wir können die
ratRun
-Sprites mit reduzierter Geschwindigkeit
wiederverwenden, um die Bewegung eines Sprungs zu simulieren.
Wähle Rat in der Hierarchie. Klicke im Fenster
Animation auf das Dropdown-Menü und wähle
Create New Clip. Nenne die neue Animation
JumpRatAnimation
.
Erweitere im Assets-Fenster das Sprite Sheet ratRun
.
Wähle alle 20 Frames aus (erster Frame → Shift halten
→ letzter Frame), und ziehe sie auf die Timeline im Animationsfenster.
Öffne jetzt das Fenster Animator. Wir fügen einen neuen Animationsparameter hinzu und verbinden ihn mit der Sprunglogik.
Wechsle im Animator zur Registerkarte Parameters und
füge einen neuen Bool-Parameter namens
isJumping
hinzu.
Konfiguriere die Übergänge wie folgt:
isJumping == true
.
isJumping == true
.
isJumping == false
.
Wähle abschließend den Zustand JumpRatAnimation
und setze
die Speed auf 0.2
, damit die
Laufbewegung wie ein Sprung aussieht.
Jetzt verbinden wir die Sprunganimation mit dem tatsächlichen Zustand
der Ratte. Dafür greifen wir auf die Variable
isGrounded
im PlayerMove
-Skript zu. Wenn die
Ratte nicht auf dem Boden ist (auch beim Fallen), wird automatisch die
Sprunganimation ausgelöst.
Öffne das Skript PlayerAnim
und ersetze den Inhalt wie
folgt:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerAnim : MonoBehaviour
{
// Referenz auf den Animator
Animator anim;
// Referenz auf Rigidbody2D
Rigidbody2D rb;
// Referenz auf PlayerMove (für isGrounded)
PlayerMove pm;
void Start()
{
// Animator-Komponente holen
anim = GetComponent<Animator>();
// Rigidbody2D holen
rb = GetComponent<Rigidbody2D>();
// PlayerMove-Skript holen
pm = GetComponent<PlayerMove>();
}
void Update()
{
// Wenn die Ratte auf dem Boden ist
if (pm.isGrounded)
{
// Kein Sprung mehr
anim.SetBool("isJumping", false);
// Geschwindigkeit anhand der Bewegung setzen
anim.SetFloat("Speed", Mathf.Abs(rb.linearVelocity.x));
}
else
{
// Beim Springen oder Fallen: Geschwindigkeit 0
anim.SetFloat("Speed", 0);
// Sprunganimation aktivieren
anim.SetBool("isJumping", true);
}
}
}
Und das war’s! Jetzt wird die Sprunganimation automatisch abgespielt, sobald die Ratte in der Luft ist – egal ob sie springt oder fällt.
Jetzt geben wir der Ratte noch etwas mehr Leben – sie soll beim Laufen Schrittgeräusche abspielen. Das funktioniert über ein Animation Event, das eine Funktion aus einem neuen Skript auslöst.
Erstelle im Ordner Assets ein neues
MonoBehaviour
-Skript mit dem Namen
PlayerSound
und füge diesen Code ein:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerSound : MonoBehaviour
{
// AudioClip für Schritte
public AudioClip footsteps;
// Öffentliche Funktion zum Abspielen – wird durch Animation Event aufgerufen
public void FootStepsAudio()
{
// Ton an der Position der Ratte abspielen
AudioSource.PlayClipAtPoint(footsteps, transform.position);
}
}
Wähle das Objekt Rat in der Hierarchie und füge das
Skript PlayerSound
hinzu. Importiere dann die Datei
ratStep
aus dem Archiv und trage sie im Feld
Footsteps
des Komponenten ein.
Wechsle jetzt in das Fenster Animation und wähle
RunRatAnimation
. Wähle ein Bild, bei dem ein Schritt
passiert, und klicke in der Zeitleiste auf Add Event.
Im Inspector (rechts) gib den Funktionsnamen
FootStepsAudio()
ein.
Und fertig! Jedes Mal, wenn die Ratte diesen Frame erreicht, wird ein Schrittgeräusch abgespielt. Du kannst mehrere Events einfügen, um beide Schritte im Rhythmus zu synchronisieren.
Jetzt erweitern wir das Level ein wenig und richten die Kamera so ein, dass sie der Ratte folgt. So haben wir mehr Platz zum Testen und sind bereit für den nächsten Abschnitt.
Zuerst machen wir aus dem ursprünglichen Boden ein Prefab. Wähle Ground in der Hierarchie aus und ziehe es in den Assets-Ordner, um das Prefab zu erstellen.
Ziehe das Prefab anschließend mehrfach zurück in die Szene, um weitere Plattformen zu platzieren. Positioniere sie an verschiedenen horizontalen (und optional vertikalen) Stellen, um eine kleine Sprung-Herausforderung zu gestalten.
Wähle nun die Main Camera in der Hierarchie aus und ziehe sie auf das Objekt Rat. Dadurch wird die Kamera ein Kind der Ratte und folgt ihr automatisch.
Optional kannst du im Transform die X-Position der Kamera auf
0
setzen, damit die Bewegung bei Drehungen zentriert und
flüssiger bleibt.
Und das war’s – der erste Teil ist geschafft! Du hast jetzt eine laufende, springende, animierte Ratte mit Ton, Kameraverfolgung und einem erweiterten Level zum Erkunden.