Catch Game – Erste Schritte

Schritt 1: Projekt erstellen

Wir starten mit dem Unity Hub und erstellen ein neues 2D-Projekt auf Basis der Vorlage Universal 2D Core. So hast du eine saubere Grundlage.

Öffne Unity Hub → Reiter Projects → New Project. Wähle die Vorlage Universal 2D Core (sie enthält das 2D-Rendering, Shader und Physikkomponenten). Je nach Unity-Version kann die Vorlage leicht anders heißen – falls sie fehlt, nimm 2D (URP) oder 2D. Gib als Projektnamen CatchGame ein (oder einen Namen deiner Wahl) und wähle einen Speicherort. Klick auf Create project und warte, bis Unity alles geladen hat.

💡 Tipp: Wähle gleich einen sinnvollen Namen und Speicherort – das spart Zeit, wenn das Projekt größer wird.

Im Unity Editor konzentrieren wir uns auf folgende Bereiche:

Schritt 2: Grafiken importieren

Für dieses Spiel brauchen wir vier Grafiken: den Boden, den Spieler (Fänger), ein gutes Objekt und ein schlechtes Objekt.

Du kannst eine einzelne Bilddatei herunterladen, in der alles schon drin ist. Sie dient als Ausgangspunkt – du kannst sie später nach Belieben ändern oder verbessern.

Um das Bild in Unity zu importieren: Rechtsklick im Fenster Assets, dann Import New Asset... auswählen, Datei auswählen und Import klicken.

💡 Tipp: Du kannst die Datei auch direkt per Drag & Drop in das Assets-Fenster ziehen – das ist oft noch schneller.
💡 Tipp: Fang einfach an – du kannst die Grafik später jederzeit anpassen.

Schritt 3: Sprite Sheet aufteilen

Nachdem du das Bild catchgame-img.png importiert hast, stellt Unity den Sprite Mode meist automatisch auf Multiple. Es ist trotzdem gut, das kurz zu überprüfen.

Warum „Multiple“? Das Bild ist ein sogenanntes Sprite Sheet – es enthält mehrere Spielelemente in einer Datei (Boden, Spieler, Objekte). Durch das Aufteilen erhalten wir einzelne Sprites, die wir direkt in die Szene ziehen können.

Wähle das Bild im Assets-Ordner aus. Im Inspector stelle sicher, dass Sprite Mode auf Multiple gesetzt ist. Wenn nicht, ändere das manuell und klicke auf Apply.

Öffne jetzt den Sprite Editor über den Inspector. Klicke im Sprite Editor oben links auf Slice. Die Standardeinstellungen kannst du so lassen – klick auf Slice und dann auf Apply.

Unity erkennt und schneidet das Bild automatisch in einzelne Sprites. Meist klappt das direkt gut. Falls nötig, kannst du die Ränder per Drag & Drop manuell anpassen.

💡 Tipp: Du willst eigene Bilder verwenden? Statt einer kombinierten Datei kannst du auch vier separate Bilder importieren. Rechtsklick im Fenster Assets → Import New Asset... → Dateien auswählen → Import.

💡 Tipp: Schneller importieren? Du kannst Bilddateien auch einfach per Drag & Drop direkt in das Fenster Assets ziehen. Unity importiert sie automatisch.

Schritt 4: Boden erstellen

Jetzt fügen wir den Boden zur Szene hinzu. Suche im Assets-Ordner den passenden Sprite (z. B. catchgame-img_3) und zieh ihn ins Fenster Scene.

Wähle das Rectangle Tool aus, und zieh den Boden so groß, dass er den unteren Bereich der Szene abdeckt. Mit der linken Maustaste kannst du die Seiten anpassen.

Klicke im Hierarchy-Fenster mit Rechtsklick auf das Objekt (z. B. catchgame-img_3) und benenne es um in Ground. Im Inspector stelle Order in Layer auf 100. So wird der Boden vor anderen Objekten dargestellt – wie eine höhere Ebene.

Klick auf Play, um die Szene zu testen – der Boden sollte unten sichtbar sein. Klick erneut auf Play, um zurück in den Editiermodus zu kommen.

Momentan sieht man den Boden in der Szene – aber er ist noch nicht „fest“. Andere Objekte würden einfach hindurchfallen, weil er keinen Collider hat.

Um das zu ändern, fügen wir einen Collider hinzu. Wähle das Objekt Ground in der Hierarchy, dann im Inspector: Add Component → Physics 2D → Box Collider 2D. Jetzt hat der Boden eine physikalische Form.

Schritt 5: Spieler (Fänger) erstellen

Jetzt fügen wir den Fänger – unseren Spieler – in die Szene ein. Die meisten Schritte sind ähnlich wie beim Boden.

1. Suche den Sprite des Fängers (z. B. XC-catchgame-img_2) im Ordner Assets und ziehe ihn ins Fenster Scene.
2. Stelle sicher, dass das Rectangle Tool ausgewählt ist, und positioniere den Fänger wie gewünscht.
3. Klicke mit Rechtsklick auf das Objekt im Hierarchy-Fenster und benenne es um in Player.
4. Mit ausgewähltem Player: Inspector → Add Component → Physics 2D → Box Collider 2D.

Jetzt sorgen wir dafür, dass der Spieler auf Schwerkraft und andere physikalische Effekte reagiert – mit einem Rigidbody-Komponenten.

Wähle weiterhin Player aus und füge nun Rigidbody 2D hinzu. Im Inspector: stelle Interpolate auf Interpolate, damit Bewegungen flüssiger aussehen.

Wir vergeben auch gleich einen Tag, damit wir den Spieler später im Code einfacher erkennen können.

Im Inspector: Wähle unter Tag → Player (ggf. musst du den Tag erst im Tag Manager anlegen).

Der Wert Order in Layer kann bei 0 bleiben – das passt für jetzt.

Klick auf Play, um zu testen – der Spieler sollte nach unten fallen und auf dem Boden landen. Danach wieder Play drücken, um in den Bearbeitungsmodus zurückzukehren.

Schritt 6: Spieler bewegen

Jetzt bringen wir unseren Spieler in Bewegung! Dafür erstellen wir ein einfaches C#-Skript, das die Geschwindigkeit des Rigidbody 2D anhand von Tastatureingaben verändert.

Im Ordner Assets: Rechtsklick → Create → MonoBehaviour Script. Nenne das Skript PlayerMove (mit großem P und M). Wichtig: Dateiname und Klassenname müssen exakt übereinstimmen.

Öffne nun die Datei PlayerMove.cs. Ersetze den Standard-Code durch folgenden Inhalt:

using UnityEngine;

public class PlayerMove : MonoBehaviour
{
    // Geschwindigkeit des Spielers (im Inspector einstellbar)
    public float speed = 5f;

    // Verbindung zum Rigidbody2D
    private Rigidbody2D rb;

    // Wert für horizontale Eingabe (A/D oder Pfeiltasten)
    private float x;

    // Die Bewegung, die wir anwenden wollen
    private Vector2 move;

    // Wird beim Start einmal aufgerufen
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    // Wird regelmäßig für Physik aufgerufen
    void FixedUpdate()
    {
        // Tastatureingabe abfragen (links/rechts)
        x = Input.GetAxis("Horizontal");

        // Bewegung setzen (nur X, Fallgeschwindigkeit bleibt)
        move = new Vector2(x * speed, rb.linearVelocity.y);

        // Bewegung anwenden
        rb.linearVelocity = move;
    }
}

Gehe zurück zu Unity. Wähle das Objekt Player in der Hierarchy. Im Inspector: Add Component → Scripts → PlayerMove.

Stelle im Inspector unter Speed einen Wert wie 5 ein.

Klick auf Play und versuche, den Spieler mit A/D oder den Pfeiltasten zu bewegen. Danach wieder Play drücken, um zurück in den Szenenmodus zu wechseln.

Schritt 7: Ein fallendes Objekt erstellen

Jetzt kommt endlich etwas zum Fangen! Wir starten mit einem einzelnen fallenden Objekt – einem Fisch –, den wir später als Vorlage für weitere nutzen.

1. Ziehe den Fisch-Sprite aus dem Ordner Assets in die Szene.
2. Benenne das neue Objekt in der Hierarchy um in Fish.
3. Im Inspector: Setze den Tag auf Good. Falls der Tag noch nicht existiert: Untagged → Add Tag, neuen Tag Good anlegen, dann zurück zum Objekt und Tag zuweisen.
4. Setze Order in Layer auf 5, damit der Fisch über dem Spieler angezeigt wird.
5. Add Component → Physics 2D → Rigidbody 2D.
6. Setze Gravity Scale auf 0.1 und Interpolate auf Interpolate – für weichere Bewegung.
7. Add Component → Box Collider 2D, dann Is Trigger aktivieren.

Damit der Fisch nicht ewig in der Szene bleibt, wenn man ihn verfehlt, erstellen wir ein Skript, das ihn nach ein paar Sekunden automatisch entfernt.

8. Rechtsklick im Ordner Assets → Create → MonoBehaviour Script, nenne es TimeDestroyer.
9. Öffne das Skript und ersetze den Inhalt durch diesen Code:

using UnityEngine;

public class TimeDestroyer : MonoBehaviour
{
    // Wie lange das Objekt sichtbar bleibt
    public float aliveTimer = 5f;

    // Wird beim Start einmal ausgeführt
    void Start()
    {
        Destroy(gameObject, aliveTimer);
    }
}

Hänge dieses Skript an das Objekt Fish (Add Component → Scripts → TimeDestroyer). Im Inspector kannst du Alive Timer z. B. auf 5 setzen.

Jetzt machen wir aus dem Fisch ein Prefab, damit wir ihn später leicht vervielfältigen können.

Ziehe den Fish aus der Hierarchy in den Ordner Assets. Unity erstellt automatisch ein Prefab (blaues Symbol).

Schritt 8: Ein schlechtes Objekt (Bombe) erstellen

Jetzt, wo wir ein gutes Objekt (Fisch) haben, erstellen wir ein schlechtes – eine Bombe –, die der Spieler vermeiden soll. Wir nutzen das Fisch-Prefab als Vorlage und ändern ein paar Dinge.

1. Fisch duplizieren
   Achte darauf, dass du die Instanz im Hierarchy-Fenster bearbeitest, nicht das Prefab im Ordner Assets.
   Rechtsklick auf Fish → Rename → Bomb.
2. Sprite ändern
   Ziehe das Bombenbild aus dem Ordner Assets in das Feld Sprite im Inspector (oder klicke auf den kleinen Kreis rechts neben dem Feld und wähle das Sprite manuell).
3. Tag ändern
   Setze den Tag auf Bad.
   💡 Tipp: Neuen Tag erstellen
   Falls Bad noch nicht existiert:

   • Dropdown bei „Tag“ → Add Tag…
   • Klicke auf das +
   • Füge den neuen Tag Bad hinzu
   • Zurück zum Bombenobjekt und Tag zuweisen
4. Collider anpassen
   Klicke auf Edit Collider, um die Collider-Form ggf. an das neue Sprite anzupassen.
5. Prefab erstellen
   Ziehe das Objekt Bomb aus der Hierarchy in den Ordner Assets, um daraus ein neues Prefab zu machen.

Schritt 9: Objekte erscheinen lassen

Jetzt bringen wir Bewegung ins Spiel – von oben! In diesem Schritt erstellen wir einen einfachen Spawner, der zufällig Objekte (z. B. Fisch oder Bombe) von oben herabfallen lässt.

Wir beginnen mit zwei unsichtbaren GameObjects, die den Spawnbereich markieren: eins links, eins rechts. Zwischen diesen Punkten können später Objekte erscheinen.

Rechtsklick in der Hierarchy → Create Empty. Achte darauf, dass kein anderes Objekt ausgewählt ist, sonst wird es versehentlich untergeordnet. Benenne das neue Objekt in Spawner um und verschiebe es links über das sichtbare Kamerabild.

Dupliziere dieses Objekt (Rechtsklick → Duplicate), verschiebe die Kopie nach rechts und benenne sie in RightSide um. Diese beiden markieren unseren Spawnbereich.

Wähle den Spawner aus und kontrolliere im Inspector, ob seine Z-Position auf 0 steht. Nur so wird er in der Spielansicht korrekt angezeigt. Du kannst auch jedem Objekt ein kleines Icon zuweisen, um sie leichter zu erkennen.

Nun erstellen wir das Skript. Rechtsklick im Assets-Ordner → Create → MonoBehaviour Script, nenne es ItemSpawn. Hänge es dann an das Objekt Spawner.

Das Skript erzeugt zufällige Objekte (Fisch oder Bombe) zwischen den X-Positionen von Spawner und RightSide. Die Y-Position entspricht der von Spawner, Z bleibt bei 0.

💡 Tipp: Auch in Unitys 2D-Ansicht gibt es Tiefe. Die Kamera ist standardmäßig auf Z = -10 – deine Objekte müssen auf Z = 0 oder höher liegen, um sichtbar zu sein.

using UnityEngine;

public class ItemSpawn : MonoBehaviour
{
    // Rechte Begrenzung des Spawnbereichs
    public GameObject RightSide;

    // Liste mit Prefabs (z. B. Fisch, Bombe)
    public GameObject[] items;

    // Verzögerung vor dem ersten Spawn und Abstand zwischen Spawns
    public float startDelay, repeatRate;

    void Start()
    {
        // Wiederholt "Spawn()" aufrufen
        InvokeRepeating("Spawn", startDelay, repeatRate);
    }

    void Spawn()
    {
        // Zufällige X-Position zwischen Spawner und RightSide
        Vector3 pos = new Vector3(
            Random.Range(transform.position.x, RightSide.transform.position.x),
            transform.position.y,
            0
        );

        // Zufälliges Item aus der Liste spawnen
        Instantiate(items[Random.Range(0, items.Length)], pos, transform.rotation);
    }
}

Nachdem du das Skript hinzugefügt hast, ziehe das Objekt RightSide in das entsprechende Feld im Inspector. Erweitere dann das Array Items und ziehe die Prefabs Fish und Bomb hinein. Setze Start Delay und Repeat Rate jeweils auf 2 (später anpassbar).

Das war’s! Drücke Play – und sieh zu, wie Fische und Bomben vom Himmel fallen. Dein Spawner ist einsatzbereit – ein kleiner Schritt, der das Spiel lebendig macht.

Schritt 10: Objekte fangen

Jetzt bringen wir das Körbchen zum Einsatz – es soll Dinge wirklich „fangen“. Dank Unitys eingebauter 2D-Physik und der Collider2D-Komponenten können wir auf Berührungen mit Triggern reagieren.

Wir schreiben ein Skript, das prüft, ob ein fallendes Objekt „gut“ oder „schlecht“ ist (per Tag). Bei gutem Objekt: Punktzahl erhöhen, bei schlechtem: verringern. In beiden Fällen verschwindet das Objekt nach dem Kontakt.

Rechtsklick im Ordner Assets → Create → MonoBehaviour Script, nenne es ItemChecker und öffne die Datei.

Das Skript verwendet OnTriggerEnter2D() – Unity ruft diese Methode automatisch auf, wenn ein Collider2D den Triggerbereich deines Objekts berührt.

using UnityEngine;

public class ItemChecker : MonoBehaviour
{
    // Punktestand des Spielers
    public int score;

    // Wird aufgerufen, wenn ein Objekt den Trigger berührt
    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.gameObject.tag == "Good")
        {
            score += 10;
            Destroy(other.gameObject);
        }

        if (other.gameObject.tag == "Bad")
        {
            score -= 10;
            Destroy(other.gameObject);
        }
    }
}

Hänge das ItemChecker-Skript an dein Spielerobjekt (den Fänger).

Unity erkennt nun Berührungen mit dem Trigger und aktualisiert den Punktestand entsprechend. Du kannst die Punktzahl sogar live im Inspector verfolgen, während das Spiel läuft.

Geschafft! Du hast den Kern eines 2D-Fangspiels gebaut: Objekte fallen, der Spieler bewegt sich, Kollisionen werden erkannt – und Punkte gezählt. Ein kleines, aber vollständiges Spiel mit viel Potenzial.