Unity-Tutorial für Einsteiger: So erstellst du einen 2D-Platformer — Teil 1

Schritt 1. Boden und Spieler vorbereiten

Ö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:

• Stelle sicher, dass die Z-Position 0 ist.
• Füge einen Box Collider 2D hinzu.

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.

• Wähle ratIdle im Assets-Ordner aus.
• Stelle Sprite Mode auf Multiple.
• Klicke auf Apply und öffne dann den Sprite Editor.
• Wähle dort Slice → Grid by Cell Count.
• Gib Columns (C): 4 und Rows (R): 5 ein und klicke Slice.
• Klicke auf Apply und schließe das Fenster.

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:

• Setze das Tag auf Player.
• Stelle sicher, dass die Z-Position 0 beträgt.
• Füge einen Capsule Collider 2D hinzu und setze Direction auf Horizontal.
• Klicke auf Edit Collider und passe die Größe mit den grünen Griffen an.
• Füge einen Rigidbody 2D hinzu. Setze Interpolate auf Interpolate.
• Aktiviere unter Constraints die Option Freeze Rotation Z.

Schritt 2. Bewegung und Springen

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:

• Weisen Sie dem Feld Ground Check das Objekt GroundCheck zu.
• Aktiviere im Feld 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.

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.

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.

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.

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.

• Wechsle im Animator zur Registerkarte Parameters.
• Klicke auf das +-Symbol und füge einen neuen Float mit dem Namen Speed hinzu.
• Rechtsklick auf IdleRatAnimation → Make Transition → auf RunRatAnimation klicken.
• Dann umgekehrt: Übergang von RunRatAnimation zu IdleRatAnimation erstellen.

Jetzt konfigurieren wir die Übergänge:

• Wähle den Pfeil von IdleRatAnimation → RunRatAnimation.
• Deaktiviere im Inspector Has Exit Time.
• Füge eine neue Condition hinzu: Setze Speed auf Greater als 0.1.

• Wähle den Pfeil von RunRatAnimation → IdleRatAnimation.
• Auch hier: Has Exit Time deaktivieren.
• Bedingung setzen: Speed Less als 0.1.

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

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.

Wechsle im Animator zur Registerkarte Parameters und füge einen neuen Bool-Parameter namens isJumping hinzu.

Konfiguriere die Übergänge wie folgt:

• Für den Übergang IdleRatAnimation → JumpRatAnimation:
  • Deaktiviere Has Exit Time.
  • Füge eine Bedingung hinzu: isJumping == true.
• Für den Übergang RunRatAnimation → JumpRatAnimation:
  • Deaktiviere Has Exit Time.
  • Füge eine Bedingung hinzu: isJumping == true.
• Für den Übergang JumpRatAnimation → IdleRatAnimation:
  • Deaktiviere Has Exit Time.
  • Füge eine Bedingung hinzu: isJumping == false.

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

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

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.

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.