Logo-Fisch
Startseite

Tutorial 4: 2D-Plattformspiel — Teil 1

Willkommen! In diesem Tutorial erstellen wir gemeinsam ein einfaches 2D-Plattformspiel mit der Unity-Engine. Du musst kein Profi sein – wir begleiten dich Schritt für Schritt auf verständliche und freundliche Weise. Wir nutzen Unitys eingebaute 2D-Physik und wagen auch einen ersten Blick auf Animationen (hallo, Sprite Sheets!). Um mitzumachen, brauchst du ein paar Assets: Bilder, Sounds und mehr. Hier kannst du das .zip-Archiv herunterladen – es enthält alles, was du für den Einstieg brauchst.

Schritt 1. Boden und Spieler vorbereiten

Starte Unity und erstelle ein neues 2D-Projekt. Dann bauen wir das Fundament des Spiels: ein Bodenobjekt und die Spielfigur.

Importiere zuerst largeGround aus dem Archiv (hier herunterladen, falls nötig). Entpacke das .zip und ziehe largeGround in die Szene. Benenne das neue GameObject in Ground um.

Wähle Ground in der Hierarchie aus. Im Inspector:

Jetzt fügen wir den Spieler hinzu. Importiere das Sprite Sheet ratIdle (ebenfalls aus dem Archiv). Unity wird es wahrscheinlich automatisch zerschneiden. Falls nicht, gehe wie folgt vor:

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:

Unity-Szene mit Boden und Ratte
Szene mit Boden und Ratte.

Schritt 2. Bewegung und Springen

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 C#-Skript. Nenne es PlayerMove. Dieses Skript verwendet Rigidbody2D, um die Figur mit der eingebauten Physik zu bewegen. Außerdem fügen wir Sprungunterstützung durch Kraft entlang der Y-Achse hinzu. 

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).

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.

Wähle jetzt erneut Rat. Im PlayerMove-Komponent:

💡 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.

Unity-Inspector mit PlayerMove-Skript und GroundCheck bei der Ratte
Skript PlayerMove auf der Ratte konfiguriert.

Schritt 3. In die richtige Richtung schauen

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.

Schritt 4. Vorbereitung für Animation

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.

Animator-Komponente mit zugewiesenem RatAnimator-Controller
Animator hinzugefügt, RatAnimator als Controller eingetragen.

Schritt 5. Die Idle-Animation erstellen

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.

IdleRatAnimation im Animator und Animationsfenster von Unity
IdleRatAnimation im Animator hinzugefügt und als Schleife eingestellt. Geschwindigkeit auf 0.5 gesetzt für flüssigeres Abspielen.

Schritt 6. Laufanimation und Übergänge erstellen

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.

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.

Jetzt konfigurieren wir die Übergänge:

Animator mit Übergängen zwischen Idle und Run, gesteuert durch den Speed-Parameter
Übergänge im Animator mit dem Parameter „Speed“. Denke daran, Has Exit Time zu deaktivieren und die Bedingungen richtig zu setzen.

Schritt 7. Animationen per Code wechseln

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 C#-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.

Schritt 8. Eine Sprunganimation hinzufügen

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.

Konfiguriere die Übergänge wie folgt:

Wähle abschließend den Zustand JumpRatAnimation und setze die Speed auf 0.2, damit die Laufbewegung wie ein Sprung aussieht.

Animator-Fenster mit Sprunganimation und eingerichteten Übergängen
JumpRatAnimation hinzugefügt und Übergänge definiert. Geschwindigkeit auf 0.2 gesetzt, isJumping steuert den Ablauf.

Schritt 9. Sprung im Code erkennen

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.

Schritt 10. Schrittgeräusche hinzufügen

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 C#-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.

Animation Event in RunRatAnimation ruft FootStepsAudio auf
Animation Event ruft die Funktion FootStepsAudio() während der RunRatAnimation auf.

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.

Schritt 11. Plattformen duplizieren und Kamera folgen lassen

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.

Szene mit duplizierten Plattformen und Kamera, die der Ratte folgt
Szene erweitert mit mehreren Plattformen. Kamera ist Kind der Ratte und folgt ihr automatisch.

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.