Unity 2D Tutorial für Einsteiger: Wir erstellen das Spiel „Türme“ (City Defender)

Schritt 1. Ein neues Projekt erstellen

Starte den Unity Hub und erstelle ein neues 2D-Projekt, indem du die Vorlage 2D Core (Built-In Render Pipeline) auswählst — eine einfache und saubere Grundlage für dein erstes 2D-Tower-Defense-Spiel.

Öffne dazu den Unity Hub → Reiter Projects → New Project. Suche die Vorlage 2D Core (Built-In Render Pipeline) (sie enthält bereits grundlegende 2D-Grafik und Physik). Je nach Unity-Version kann der Name leicht variieren — wenn du diese Vorlage nicht findest, kannst du auch 2D (URP/SRP) oder einfach 2D wählen.

Gib im Feld für den Projektnamen CityDefender oder einen anderen Namen deiner Wahl ein und wähle einen passenden Ordner zum Speichern aus. Klicke anschließend auf Create project und warte einen Moment, bis Unity alles vorbereitet hat.

💡 Tipp: Verwende einen kurzen, klaren Projektnamen (z. B. CityDefender) — das hilft, Pfadfehler zu vermeiden und die Projektstruktur übersichtlich zu halten.

Schritt 2. Den Stadt-Hintergrund hinzufügen

Lade zuerst das Bild des Stadt-Hintergrunds herunter — eine Silhouette, die als Kulisse für unsere Szene dienen wird.

Importiere das heruntergeladene Bild in Unity – entweder über Import New Asset... (Rechtsklick im Fenster Assets) oder indem du die Datei direkt per Drag-and-Drop in den Projektordner ziehst.

Füge das Stadtbild anschließend in die Szene ein: Ziehe es aus dem Assets-Fenster in das Scene-Fenster. Passe die Größe an — z. B. Scale X = 0.5 und Scale Y = 0.5, damit der Hintergrund nicht zu groß ist.

Benenne das Objekt in City um, damit du es später leicht im Hierarchy-Fenster findest.

Schritt 3. Meteoriten hinzufügen

Im Spiel wird es zwei Arten von Meteoriten geben: kleine und schnelle – mit geringem Schaden, und große und langsame – mit starkem Einschlag auf die Stadt.

Lade die Meteoriten-Bilder unten herunter:

Importiere die heruntergeladenen Bilder in Unity — klicke dazu mit der rechten Maustaste im Assets-Fenster und wähle Import New Asset..., oder ziehe die Dateien einfach direkt in das Projektfenster.

Schritt 4. Prefab des kleinen Meteoriten

Füge das Bild des kleinen Meteoriten in die Szene ein und benenne das Objekt in Meteor-Small um. Passe die Größe an – z. B. Scale X = 0.5 und Scale Y = 0.5.

Erstelle das Tag Meteor und weise es dem kleinen Meteoriten zu.

Setze Order in Layer so, dass der Meteorit vor dem Stadt-Hintergrund gerendert wird (wenn City den Wert 0 hat, gib dem Meteoriten z. B. 5). So verschwindet er nicht hinter dem Hintergrund.

Füge die Komponenten Circle Collider 2D (für die Treffererkennung) und Rigidbody 2D (für die Physik) hinzu.

Im Rigidbody 2D des Meteoriten stelle Gravity Scale = 0 ein (wir bewegen ihn später manuell per Skript) und Interpolate = Interpolate für eine flüssigere Bewegung.

Jetzt erstellen wir ein kleines Skript, um die Parameter des Meteoriten zu speichern und ihn automatisch zu löschen (damit er nicht ewig im Spiel bleibt, falls er aus dem Bildschirm fliegt). Erstelle ein neues MonoBehaviour-Skript und nenne es MeteorParam – Dateiname und Klassenname müssen identisch sein.

using UnityEngine;

public class MeteorParam : MonoBehaviour
{
    public float speed;
    public int hp;
    public int damage;

    // Der Meteorit zerstört sich nach 10 Sekunden selbst,
    // damit er nicht unendlich lange in der Szene bleibt.
    void Start()
    {
        Destroy(gameObject, 10f);
    }
}

Hänge das Skript MeteorParam als Komponente an das Meteoritenobjekt an. Stelle im Inspector die Werte ein: speed = 5, hp = 1, damage = 1.

Erstelle dann ein Prefab: Ziehe das Meteoritenobjekt aus der Hierarchy in den Assets-Ordner.

Nachdem das Prefab erstellt wurde, kannst du den kleinen Meteoriten aus der Szene löschen – später werden wir Instanzen daraus erzeugen.

Schritt 5. Prefab des großen Meteoriten

Füge das Bild des großen Meteoriten in die Szene ein und benenne das Objekt Meteor-Big. Passe die Größe an – z. B. Scale X = 0.5 und Scale Y = 0.5.

Weise dem großen Meteoriten das Tag Meteor zu.

Setze Order in Layer auf 5, damit der Meteorit vor der Stadt gerendert wird.

Füge die Komponenten Circle Collider 2D und Rigidbody 2D hinzu.

Stelle im Rigidbody 2D ein: Gravity Scale = 0 und Interpolate = Interpolate für flüssige Bewegung.

Hänge das Skript MeteorParam als Komponente an den Meteorit. Setze im Inspector die Werte: speed = 2, hp = 10, damage = 10.

Erstelle ein Prefab: Ziehe das Meteorit-Objekt aus der Hierarchy in den Assets-Ordner. Anschließend kannst du den großen Meteoriten aus der Szene löschen – später wird er aus dem Prefab instanziiert.

Schritt 6. Meteoriten-Spawner

Erstelle in der Szene ein leeres Objekt (Create Empty), nenne es MeteorSpawner und positioniere es über der Bildschirmmitte (knapp oberhalb des sichtbaren Bereichs). Lege darin zwei weitere leere Objekte an und platziere sie links und rechts: nenne sie leftBound und rightBound. Achte darauf, dass bei allen drei Objekten die Koordinate Z = 0 ist.

Jetzt schreiben wir ein Skript, das eine zufällige X-Position zwischen den Begrenzungen wählt, kleine und große Meteoriten mit unterschiedlicher Frequenz spawnt und ihnen eine Flugrichtung zur Stadt gibt (große – direkt auf die Stadt, kleine – auf einen Zufallspunkt über der Stadtlinie).

Erstelle ein neues MonoBehaviour-Skript und nenne es MeteorSpawner:

using UnityEngine;

public class MeteorSpawner : MonoBehaviour
{
    // Spawn-Grenzen und Stadtobjekt für das Anvisieren
    public Transform leftBound, rightBound, city;

    // Meteoriten-Prefabs
    public GameObject smallMeteorPrefab, bigMeteorPrefab;

    // Spawn-Intervalle und Startverzögerungen
    public float smallRepeat = 1f, bigRepeat = 5f;
    public float startDelaySmall = 1f, startDelayBig = 5f;

    void Start()
    {
        // Unity ruft die Spawn-Methoden in Intervallen auf
        InvokeRepeating(nameof(SpawnSmall), startDelaySmall, smallRepeat);
        InvokeRepeating(nameof(SpawnBig),   startDelayBig,   bigRepeat);
    }

    // Spawn eines kleinen Meteoriten
    void SpawnSmall()
    {
        // Zufälliges X zwischen linker und rechter Begrenzung
        float xPos = Random.Range(leftBound.position.x, rightBound.position.x);
        Vector3 pos = new Vector3(xPos, transform.position.y, 0f);

        // Meteorit erzeugen
        var go = Instantiate(smallMeteorPrefab, pos, Quaternion.identity);

        // Ziel: zufälliges X über der Stadt, Y = Stadtlevel
        float xTarget = Random.Range(leftBound.position.x, rightBound.position.x);
        Vector3 target = new Vector3(xTarget, city.position.y, 0f);

        // Richtungsvektor normalisieren (Länge = 1), Geschwindigkeit separat
        Vector3 dir = (target - pos).normalized;

        // Komponenten holen und Geschwindigkeit setzen
        var mp = go.GetComponent<MeteorParam>();
        var rb = go.GetComponent<Rigidbody2D>();
        if (rb != null && mp != null)
            rb.linearVelocity = dir * mp.speed;
    }

    // Spawn eines großen Meteoriten
    void SpawnBig()
    {
        float xPos = Random.Range(leftBound.position.x, rightBound.position.x);
        Vector3 pos = new Vector3(xPos, transform.position.y, 0f);

        var go = Instantiate(bigMeteorPrefab, pos, Quaternion.identity);

        // Große zielen auf das Stadtzentrum
        Vector3 target = city.position;
        Vector3 dir = (target - pos).normalized;

        var mp = go.GetComponent<MeteorParam>();
        var rb = go.GetComponent<Rigidbody2D>();
        if (rb != null && mp != null)
            rb.linearVelocity = dir * mp.speed;
    }
}

Hänge das Skript MeteorSpawner an das Objekt MeteorSpawner. Fülle im Inspector die Felder aus: Ziehe leftBound, rightBound und das Objekt City in die Referenzen und weise die Prefabs smallMeteorPrefab und bigMeteorPrefab zu. Für den Anfang kannst du die Standardwerte lassen: smallRepeat = 1, bigRepeat = 5, startDelaySmall = 1, startDelayBig = 5.

💡 Tipp: Wenn Meteoriten „zerreißen“ oder zittern, stelle sicher, dass bei ihrem Rigidbody2D Interpolate = Interpolate und Gravity Scale = 0 gesetzt ist (wir bewegen sie manuell über linearVelocity).

Starte die Szene – die Meteoriten sollten chaotisch in Richtung Stadt fallen: kleine – häufiger und schneller, große – seltener und langsamer.

Schritt 7. Die Stadt erleidet Schaden

Bisher fliegen die Meteoriten einfach durch die Stadt. Jetzt fügen wir die Treffererkennung und das Verringern der Lebenspunkte hinzu. Dafür nutzen wir Kollisionen über einen Trigger.

Wähle in der Szene das Objekt City und füge die Komponente Box Collider 2D hinzu. Das entspricht zwar nicht exakt der Kontur der Stadt, aber uns ist hier eine einfache, gut sichtbare Lösung wichtiger als absolute Genauigkeit.

Passe die Größe des Colliders so an, dass er den unteren Bereich der Gebäude überdeckt, und aktiviere Is Trigger.

Jetzt erstellen wir ein Skript, das die Lebenspunkte der Stadt überwacht und die Szene neu lädt, wenn die Stadt zerstört wurde. Erstelle ein neues MonoBehaviour-Skript und nenne es CityDefense.

using UnityEngine;
// für das Neuladen der Szene
using UnityEngine.SceneManagement;

public class CityDefense : MonoBehaviour
{
    // Lebenspunkte der Stadt
    public int hp = 30;

    // wird aufgerufen, wenn ein anderer 2D-Collider in diesen Trigger eintritt
    void OnTriggerEnter2D(Collider2D other)
    {
        // wenn das Objekt kein Meteorit ist — abbrechen
        if (!other.CompareTag("Meteor")) return;

        // Komponenten mit den Meteorit-Parametern holen
        MeteorParam mp = other.GetComponent<MeteorParam>();

        // wenn Parameter vorhanden — Schaden anwenden
        if (mp != null)
        {
            int dmg = mp.damage;
            hp -= dmg;
            // Meteorit nach dem Treffer zerstören
            Destroy(other.gameObject);
        }

        // wenn die Lebenspunkte aufgebraucht sind — Szene neu laden
        if (hp <= 0)
        {
            hp = 0;
            string currentScene = SceneManager.GetActiveScene().name;
            SceneManager.LoadScene(currentScene);
        }
    }
}

Hänge das Skript CityDefense an das Objekt City. Jetzt fügen Meteoriten bei einem Treffer Schaden zu, und wenn die Lebenspunkte auf 0 fallen, wird die Szene neu gestartet.

Schritt 8. Der Laserturm

Momentan fallen die Meteoriten einfach auf die Stadt und zerstören sie – Zeit, Verteidigungstürme zu bauen! Wir beginnen mit dem Laserturm. Er schießt schnell und präzise auf einzelne Ziele und verursacht dabei geringen Schaden. Das ist deine erste Verteidigungslinie, ideal zum schnellen Ausschalten schwacher und schneller Meteoriten.

Lade das Bild des Laserturms herunter:

Importiere das Turmbild in Unity. Erstelle dann das Turmobjekt in der Szene – ziehe einfach den Sprite aus dem Assets-Ordner ins Scene-Fenster. Benenne den Turm z. B. in Gemeni Analyzer um. Skaliere ihn (z. B. X = 0.5, Y = 0.5) und setze Order in Layer auf 10, damit er über der Stadt angezeigt wird.

Für den Schusseffekt verwenden wir die Komponente Line Renderer. Füge sie dem Turm hinzu und wähle die Linienfarbe nach Belieben. Unter Material setze Sprites-Default.

Jetzt fügen wir einen Punkt hinzu, von dem der Laser ausgeht. Erstelle ein Kindobjekt (Rechtsklick auf den Turm → Create Empty) und nenne es LaserAnchor. Platziere es an der Linse des Turms und achte darauf, dass Z = 0 ist.

Erstelle ein neues MonoBehaviour-Skript mit dem Namen LaserTower und hänge es an den Turm. Hier ist der fertige Code:

using System.Collections;
using UnityEngine;

// Erfordert, dass ein LineRenderer auf dem Objekt vorhanden ist
[RequireComponent(typeof(LineRenderer))]
public class LaserTower : MonoBehaviour
{
    public Transform laserAnchor;      // Punkt, von dem der Laser ausgeht
    public int damage = 1;             // Schaden pro Schuss
    public float shootingDelay = 1f;   // Zeit zwischen Schüssen
    public float maxTargetDist = 7f;   // Angriffsreichweite (in Einheiten)
    public AudioClip laserSound;       // Sounddatei für den Laser
    public float volume = 0.7f;        // Lautstärke

    private LineRenderer lr;

    void Awake()
    {
        lr = GetComponent<LineRenderer>();

        // Wenn kein Schusspunkt angegeben ist, wird der Turm selbst verwendet
        if (laserAnchor == null) laserAnchor = transform;

        // Grundeinstellungen der Linie, damit der Laser sichtbar ist
        lr.useWorldSpace = true;
        lr.positionCount = 0;
        lr.startWidth = lr.endWidth = 0.06f;
        lr.sortingOrder = 5;
    }

    void Start()
    {
        // Regelmäßige Zielsuche und Schussausführung
        InvokeRepeating(nameof(TargetSearchAndShoot), 1f, shootingDelay);
    }

    void TargetSearchAndShoot()
    {
        // 1) Alle Meteoriten mit Tag "Meteor" finden
        GameObject[] meteors = GameObject.FindGameObjectsWithTag("Meteor");
        if (meteors.Length == 0) return;

        // 2) Den nächsten innerhalb des Radius wählen
        GameObject best = null;
        float bestSqr = maxTargetDist * maxTargetDist;
        Vector3 myPos = transform.position;

        foreach (GameObject m in meteors)
        {
            if (m == null) continue;
            float sqr = (m.transform.position - myPos).sqrMagnitude;
            if (sqr <= bestSqr)
            {
                best = m;
                bestSqr = sqr; // näher gefunden – Abstand aktualisieren
            }
        }

        if (best == null) return;

        // 3) Visueller Schuss – kurzer Laserblitz
        StartCoroutine(FlashLine(laserAnchor.position, best.transform.position));
        // Sound an der Kameraposition abspielen
        if (laserSound != null)
        AudioSource.PlayClipAtPoint(laserSound, Camera.main.transform.position, volume);

        // 4) Lebenspunkte des Meteoriten verringern (über MeteorParam)
        var mp = best.GetComponent<MeteorParam>();
        if (mp != null)
        {
            mp.hp -= damage;
            if (mp.hp <= 0)
                Destroy(best);
        }
    }

    // Kurzes Ein- und Ausschalten des Laserstrahls
    IEnumerator FlashLine(Vector3 start, Vector3 end)
    {
        lr.positionCount = 2;
        lr.SetPosition(0, start);
        lr.SetPosition(1, end);
        yield return new WaitForSeconds(0.05f);
        lr.positionCount = 0;
    }
}

Gib im Inspector beim Skript das Objekt LaserAnchor im Feld laserAnchor an.

Du kannst außerdem einen Lasersound hinzufügen, um den Schuss lebendiger zu machen. Lade die Datei 🎵 LaserBeep herunter, importiere sie in Unity (Assets → Import New Asset...) und wähle diesen Sound im Skriptfeld laserSound aus.

Erstelle anschließend ein Turm-Prefab, indem du das Objekt aus der Szene in den Assets-Ordner ziehst. Jetzt kannst du den Test starten – der Turm sucht automatisch nach den nächsten Meteoriten und schießt auf sie. Nach dem Test kannst du ihn aus der Szene löschen, da du nun das Prefab besitzt.

Schritt 9. Rakete für den Raketenturm

Wir haben bereits einen Turm gegen kleine Meteoriten. Jetzt bauen wir einen Turm mit hohem Schaden gegen große Ziele. Das wird ein Raketenturm: schießt selten, aber stark. Zuerst erstellen wir die eigentliche Rakete – sie erhält ein Ziel und fliegt mit Selbstzielsteuerung darauf zu.

Lade das Raketenbild herunter:

Importiere das Raketenbild in Unity. Erstelle ein neues Objekt, indem du den Sprite aus dem Ordner Assets in das Scene-Fenster ziehst. Benenne das Objekt Missile. Skaliere ungefähr auf X = 0.2, Y = 0.2 und setze Order in Layer auf 5.

Füge die Komponente Box Collider 2D hinzu und aktiviere Is Trigger. Danach füge Rigidbody 2D hinzu und stelle ein:

• Gravity Scale = 0 (die Rakete fällt nicht);
• Collision Detection = Continuous (besser für schnelle Objekte);
• Interpolate = Interpolate (gleichmäßige Bewegung).

Für die Steuerung der Rakete erstellen wir ein einfaches Skript. Die Rakete fliegt nach vorn relativ zu sich selbst und dreht sich sanft in Richtung Ziel. Das Ziel erhält die Rakete beim Start vom Raketenturm.

Erstelle ein neues MonoBehaviour-Skript mit dem Namen MissileMove und füge diesen Code ein:

using UnityEngine;

public class MissileMove : MonoBehaviour
{
    // Ziel der Rakete (wird beim Spawn vom Turm gesetzt)
    public GameObject target;

    public float speed = 7f;             // Fluggeschwindigkeit
    public float rotationSpeed = 100f;   // Rotationsgeschwindigkeit (Grad/Sek.)
    public int damage = 100;             // Schaden beim Treffer
    public float lifeTime = 5f;          // Selbstzerstörung nach (Sek.)

    private Rigidbody2D rb;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        // Falls die Rakete nichts trifft, verschwindet sie selbstständig
        Destroy(gameObject, lifeTime);
    }

    void Update()
    {
        if (target == null) return; // Ziel könnte vorher zerstört worden sein

        // Richtung zum Ziel
        Vector3 dir = target.transform.position - transform.position;

        // Gewünschte Ausrichtung zum Ziel (in 2D schaut die Kamera entlang Z)
        Quaternion targetRot = Quaternion.LookRotation(Vector3.forward, dir);

        // Rakete sanft in Richtung Ziel drehen
        transform.rotation = Quaternion.RotateTowards(
            transform.rotation,
            targetRot,
            rotationSpeed * Time.deltaTime
        );
    }

    void FixedUpdate()
    {
        // Vorwärtsflug entlang der lokalen "Up"-Achse des Sprites (transform.up)
        rb.linearVelocity = transform.up * speed;
    }

    void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.CompareTag("Meteor"))
        {
            var mp = collision.GetComponent<MeteorParam>();
            if (mp != null)
            {
                mp.hp -= damage;
                if (mp.hp <= 0)
                    Destroy(collision.gameObject);
            }

            // Rakete nach dem Treffer zerstören
            Destroy(gameObject);
        }
    }
}

Füge das Skript MissileMove als Komponente zum Objekt Missile hinzu. Erstelle anschließend ein Raketen-Prefab, indem du das Objekt aus der Szene in den Ordner Assets ziehst. Wenn das Prefab fertig ist, kannst du die Rakete aus der Szene löschen.

Fertig! Im nächsten Schritt erstellen wir den Raketenturm, der solche Raketen auf ausgewählte Ziele abfeuert.

Schritt 10. Der Raketenturm

Jetzt fügen wir den Raketenturm hinzu, um große, widerstandsfähige Ziele zu bekämpfen. Dieser Turm schießt seltener, verursacht aber hohen Schaden und sucht priorisiert nach Meteoriten mit hohem Lebensvorrat (HP).

Lade das Turmbild herunter:

Importiere das Bild in Unity. Erstelle das Turmobjekt, indem du den Sprite in das Scene-Fenster ziehst, und benenne es z. B. Kiava Flow. Skaliere ungefähr auf X = 0.5, Y = 0.5, und setze Order in Layer auf 10, damit der Turm über der Rakete gerendert wird.

Erstelle ein neues MonoBehaviour-Skript namens MissileTower. In diesem Skript sucht der Turm innerhalb eines Radius nach „großen“ Meteoriten (über HP) und feuert eine Rakete darauf ab.

using UnityEngine;

public class MissileTower : MonoBehaviour
{
    // Maximale Entfernung zur Erkennung von Meteoriten
    public float maxTargetDist = 10f;

    // HP-Schwelle, ab der ein Meteorit als "groß" gilt
    public int minHpForMissile = 5;

    // Raketen-Prefab (vorab in Assets erstellt)
    public GameObject missilePrefab;

    // Verzögerung zwischen Schüssen (Sek.)
    public float shootingDelay = 1f;

    // Sound für den Raketenstart
    public AudioClip missileSound;
    public float volume = 0.7f; // Lautstärke 0..1

    void Start()
    {
        // Schuss periodisch auslösen
        InvokeRepeating(nameof(ShootBig), 1f, shootingDelay);
    }

    void ShootBig()
    {
        // Alle Meteoriten per Tag finden
        GameObject[] mets = GameObject.FindGameObjectsWithTag("Meteor");

        GameObject best = null;
        float bestSqr = maxTargetDist * maxTargetDist;
        Vector3 p = transform.position;

        foreach (var m in mets)
        {
            if (m == null) continue;
            var mp = m.GetComponent<MeteorParam>();
            if (mp == null) continue;

            // Nur "große" nach aktuellem HP-Wert berücksichtigen
            if (mp.hp < minHpForMissile) continue;

            float sqr = (m.transform.position - p).sqrMagnitude;
            if (sqr <= bestSqr)
            {
                best = m;
                bestSqr = sqr;
            }
        }

        if (best == null) return;

        // Rakete aus der Turmmitte starten
        var missile = Instantiate(missilePrefab, transform.position, Quaternion.identity);

        // Ziel der Rakete setzen
        missile.GetComponent<MissileMove>().target = best;

        // Startsound abspielen
        if (missileSound != null)
            AudioSource.PlayClipAtPoint(missileSound, Camera.main.transform.position, volume);
    }
}

Füge das Skript MissileTower als Komponente am Turmobjekt hinzu.

Lade den Sound für den Raketenstart: 🎵 Boom. Importiere ihn in Unity und wähle ihn im Skriptfeld missileSound aus.

Fülle im Inspector des Turms die Felder aus: Ziehe das Raketen-Prefab in missilePrefab und den Sound in missileSound. Nach dem Test erstelle ein Turm-Prefab, indem du das Objekt aus der Szene in den Assets-Ordner ziehst.

Schritt 11. Sockel für Türme

Jetzt erstellen wir Sockel, auf die der Spieler Türme setzen kann. Sie dienen als Platzierungspunkte und helfen, den Aufstellort zu steuern.

Lade das Sockel-Bild herunter:

Importiere das Bild in Unity und erstelle daraus ein Spielobjekt – ziehe den Sprite des Sockels in das Scene-Fenster. Benenne das Objekt Stand.

Lege anschließend einen neuen Tag Stand an und weise ihn dem Sockel zu (Inspector → Tag → Add Tag... → Stand). Diesen Tag benötigen wir später, um Sockel beim Turm-Platzieren per Mausklick zu erkennen.

Damit Meteoriten nicht mit den Sockeln kollidieren, erstellen wir eine eigene Physik-Ebene:

1. Oben rechts im Inspector auf Layer → Add Layer... klicken.
2. Eine neue Ebene mit dem Namen Stand hinzufügen.
3. Diese Ebene dem Sockelobjekt zuweisen.

Öffne danach die Projekteinstellungen: Edit → Project Settings → Physics 2D. Im Bereich Layer Collision Matrix die Kollision zwischen den Ebenen Default und Stand deaktivieren. 💡 Jetzt fliegen Meteoriten einfach durch die Sockel hindurch, ohne zu kollidieren.

Damit der Turm exakt am richtigen Punkt sitzt, verschieben wir leicht den Pivot (Bezugspunkt des Sprites):

1. Öffne den Sockel-Sprite im Sprite Editor.
2. Aktiviere den Modus Custom Pivot.
3. Verschiebe den Pivot an die Stelle, an der der Turm stehen soll.
4. Klicke auf Apply, um zu speichern.

Setze Order in Layer auf 5, damit der Sockel unter den Türmen gerendert wird. Füge die Komponente Box Collider 2D hinzu – sie wird benötigt, um den Sockel beim Platzieren der Türme per Mausklick auszuwählen.

Erstelle nun ein Sockel-Prefab: Ziehe das Objekt aus der Szene in den Assets-Ordner. Danach kannst du mehrere Sockel in der Szene platzieren – z. B. fünf Stück in einer Reihe.

💡 Wenn du einen Sockel vor der Stadt platzierst, achte darauf, dass er nicht vom Collider anderer Objekte überlappt wird. Um das zu vermeiden, kannst du den Sockel leicht entlang der Z-Achse nach vorn ziehen – gib einen kleinen negativen Wert an (z. B. -0.1). So liegt er in der Szenen-Tiefe vorn, ohne die 2D-Darstellung zu beeinflussen.

Schritt 12. Türme platzieren und die Stadt verteidigen

Jetzt kommt das Spannendste – die Stadt verteidigen! Wir schreiben ein kleines Skript, mit dem du Türme auf Sockeln platzieren kannst. Beim Klick mit der linken Maustaste wird ein Laserturm gesetzt, beim Rechtsklick ein Raketenturm. Nach der Platzierung wird der Collider des Sockels automatisch deaktiviert, damit dort kein zweiter Turm gesetzt werden kann.

Erstelle ein neues MonoBehaviour-Skript namens TowerSpawner.

using UnityEngine;

public class TowerSpawner : MonoBehaviour
{
    public GameObject laserTower;   // Prefab des Laserturms (setzt man mit LMT)
    public GameObject missileTower; // Prefab des Raketenturms (setzt man mit RMT)

    void Update()
    {
        // Linke Maustaste — Laserturm setzen
        if (Input.GetMouseButtonDown(0))
            TryPlaceTower(laserTower);

        // Rechte Maustaste — Raketenturm setzen
        if (Input.GetMouseButtonDown(1))
            TryPlaceTower(missileTower);
    }

    void TryPlaceTower(GameObject towerPrefab)
    {
        // Prüfen, ob ein Prefab zugewiesen ist
        if (towerPrefab == null) return;

        // Mausposition in Weltkoordinaten ermitteln
        Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);

        // Prüfen, ob wir einen Collider getroffen haben
        RaycastHit2D hit = Physics2D.Raycast(mousePos, Vector2.zero);
        if (hit.collider == null) return;

        // Wenn es ein Sockel ist (Tag Stand) — Turm platzieren
        if (hit.collider.CompareTag("Stand"))
        {
            Instantiate(towerPrefab, hit.transform.position, Quaternion.identity);

            // Collider des Sockels deaktivieren, damit kein zweiter Turm gesetzt wird
            hit.collider.enabled = false;
        }
    }
}

Erstelle in der Szene ein leeres Objekt (seine Position ist egal) und füge ihm die Komponente TowerSpawner hinzu.

Trage im Inspector die Prefab-Referenzen ein:

• Im Feld Laser Tower das Prefab des Laserturms Gemeni Analyzer.
• Im Feld Missile Tower das Prefab des Raketenturms Kiava Flow.

Die Basiskomponente zum Platzieren ist damit fertig! Starte die Szene, klicke auf die Sockel und baue die Stadtverteidigung auf. Laser und Raketen erhellen den Himmel – und der echte Kampf ums Überleben beginnt! ⚡