Space Shooter — Erster Flug

Schritt 1. Projekt einrichten

Wir beginnen mit einem neuen Unity-2D-Projekt, basierend auf der Vorlage Universal 2D Core. Sie bietet uns eine saubere Umgebung – perfekt vorbereitet für Sprites, Physik und Code.

Tipp: Du kannst dein Projekt SpaceShooter nennen oder dir einen anderen spaßigen Namen ausdenken – ganz wie du willst.

Schritt 2. Sprite Sheet importieren

Jetzt bringen wir unsere Grafiken in Unity.

Lade die Bilddatei space-sprites.png herunter — sie enthält alle Grafiken, die wir brauchen: Gegner, Spielerschiff, Projektil und mehr.

Öffne dein Unity-Projekt und importiere die Datei:

• Entweder ziehst du space-sprites.png direkt ins Assets-Fenster,
• Oder du machst einen Rechtsklick in Assets → Import New Asset... → wählst die Datei aus und klickst auf Import.

Nach dem Import wähle space-sprites.png im Assets-Fenster aus. Im Inspector-Panel achte darauf:

• Texture Type ist auf Sprite (2D and UI) gesetzt
• Sprite Mode ist Multiple

Dann klicke auf Apply, um die Einstellungen zu bestätigen.

Tipp: “Multiple” bedeutet, dass das Bild mehrere Sprites enthält – wie ein Blatt mit verschiedenen Figuren.

Unity sollte das Bild automatisch in einzelne Sprites aufteilen. Falls nicht, klicke auf Open Sprite Editor und verwende die Schaltfläche Slice mit Type: Automatic. Danach klicke auf Apply.

Tipp: Wenn das automatische Schneiden nicht funktioniert, kannst du auf Gitter-basiertes Schneiden umstellen oder manuell zuschneiden. Vergiss nicht, vor dem Schließen des Editors auf Apply zu klicken.

Schritt 3. Spieler-Schiff erstellen und bewegen

Jetzt bauen wir das Schiff, das wir steuern werden. In diesem Spiel benutzen wir keine Tastatur — sondern die Maus. Das Schiff soll zu dem Punkt fliegen, auf den wir klicken.

Ziehe zunächst das blaue Schiff-Sprite in die Szene. Unity erstellt ein neues GameObject. Benenne es in Player um und setze den Tag auf Player.

Jetzt fügen wir Physik hinzu. Wähle Player aus, klicke auf Add Component und füge Folgendes hinzu:

• Circle Collider 2D
• Rigidbody 2D

In den Rigidbody 2D-Einstellungen:

• Gravity Scale auf 0 setzen
• Interpolate auf Interpolate setzen
• Freeze Rotation Z in Constraints aktivieren

Erstelle nun ein neues C#-Skript mit dem Namen PlayerMove und füge es dem Objekt Player hinzu.

using UnityEngine;

public class PlayerMove : MonoBehaviour
{
    // Position, auf die der Spieler geklickt hat
    Vector3 clickPos;

    // Richtung vom Schiff zur Zielposition
    Vector3 move;

    // Bewegungsgeschwindigkeit des Schiffs
    public float speed = 1f;

    // Referenz auf das Rigidbody2D dieses Objekts
    Rigidbody2D rb;

    void Start()
    {
        // Rigidbody2D-Komponente abrufen
        rb = GetComponent<Rigidbody2D>();

        // Start ohne Bewegung
        clickPos = transform.position;
    }

    void Update()
    {
        // Wenn linke Maustaste gedrückt wird, Zielposition aktualisieren
        if (Input.GetMouseButton(0))
        {
            // Bildschirmkoordinaten in Weltkoordinaten umwandeln
            clickPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
        }

        // Richtungsvektor berechnen
        move = clickPos - transform.position;
    }

    void FixedUpdate()
    {
        // Geschwindigkeit setzen, um in Richtung des Klicks zu fliegen
        // Nur X und Y werden verwendet (2D)
        rb.linearVelocity = new Vector2(move.x, move.y) * speed;
    }
}

Speichere das Skript und kehre zu Unity zurück. Setze im Inspector den Wert Speed auf 1. Drücke auf Play und teste — das Schiff sollte sich nun zur Klickposition bewegen.

Tipp: Die Mausposition wird in Bildschirmkoordinaten (Pixel) angegeben. Um sie in eine Szene-Position umzuwandeln, verwende Camera.ScreenToWorldPoint. Das Ergebnis ist ein Punkt in der Welt — beachte: der Z-Wert entspricht der Z-Position der Kamera. Für 2D reicht das meist — wir brauchen nur X und Y.

Schritt 4. Laser hinzufügen und fliegen lassen

Jetzt geben wir unserem Schiff etwas zum Schießen — wir fügen einen Laser hinzu.

Ziehe das orangefarbene Laser-Sprite in die Szene. Unity erstellt ein neues GameObject. Benenne es in Laser um. Setze im Inspector den Order in Layer auf -10, damit der Laser hinter dem Schiff gezeichnet wird. Passe die Größe bei Bedarf an – er sollte klein und klar aussehen.

Füge dem Laser folgende Komponenten hinzu:

• Box Collider 2D — aktiviere Is Trigger
• Rigidbody 2D — setze Gravity Scale auf 0

Erstelle jetzt ein neues C#-Skript mit dem Namen LaserShot. Dieses Skript stößt den Laser nach oben, sobald er erzeugt wird, und entfernt ihn, wenn er den Bildschirm verlässt.

using UnityEngine;

public class LaserShot : MonoBehaviour
{
    // Referenz auf das Rigidbody2D dieses Objekts
    Rigidbody2D rb;

    // Geschwindigkeit des Lasers
    public float force = 5f;

    void Start()
    {
        // Rigidbody2D-Komponente abrufen
        rb = GetComponent<Rigidbody2D>();

        // Vektor nach oben erzeugen und Kraft anwenden
        Vector3 direction = new Vector3(0, force, 0);
        rb.AddForce(direction, ForceMode2D.Impulse);
    }

    // Wird aufgerufen, wenn der Laser den Bildschirm verlässt
    void OnBecameInvisible()
    {
        // Laser zerstören, um die Szene sauber zu halten
        Destroy(gameObject);
    }
}

Hänge dieses Skript an das Laser-Objekt und setze den Force-Wert z. B. auf 5.

Ziehe das Laser-GameObject ins Assets-Fenster, um ein Prefab zu erstellen. Unity erstellt es automatisch. Danach kannst du den Laser aus der Szene löschen — wir werden ihn später per Skript erzeugen.

Schritt 5. Spieler kann schießen

Der Laser kann jetzt fliegen — jetzt bringen wir dem Schiff das Schießen bei.

Wir verwenden ein neues Skript, das jedes Mal einen Laser erzeugt, wenn der Spieler die rechte Maustaste drückt. Um zu vermeiden, dass zu viele Laser gleichzeitig erscheinen, fügen wir eine kurze Verzögerung per Coroutine hinzu.

Erstelle ein neues C#-Skript mit dem Namen PlayerShoot. Es sollte so aussehen:

using UnityEngine;
using System.Collections;

public class PlayerShoot : MonoBehaviour
{
    // Laser-Prefab, das erzeugt wird
    public GameObject laser;

    // Verzögerung zwischen Schüssen
    public float delayTime = 0.5f;

    // Kann der Spieler gerade schießen?
    bool canShoot = true;

    void Update()
    {
        // Prüfen, ob rechte Maustaste gedrückt ist und Schießen erlaubt ist
        if (canShoot && Input.GetMouseButton(1))
        {
            // Schießen vorübergehend deaktivieren
            canShoot = false;

            // Laser an Spielerposition erzeugen
            Instantiate(laser, transform.position, transform.rotation);

            // Cooldown starten
            StartCoroutine(NoFire());
        }
    }

    // Kurze Wartezeit, bevor wieder geschossen werden darf
    IEnumerator NoFire()
    {
        yield return new WaitForSeconds(delayTime);
        canShoot = true;
    }
}

Hänge das PlayerShoot-Skript an das Spielerobjekt. Ziehe das Laser-Prefab in das Feld Laser. Setze Delay Time auf 0.5.

Klicke auf Play und probiere es aus — dein Schiff sollte jetzt schießen, wenn du rechts klickst!

Schritt 6. Bewegliche Minen als Gegner

Jetzt fügen wir etwas Gefahr hinzu. Wir verwenden eine kleine Minen-Gegnerin, die nach unten in Richtung Spieler treibt.

Ziehe das Minen-Sprite in die Szene. Unity erstellt ein neues GameObject — benenne es in Mine um. Setze Order in Layer auf -5 (zwischen Schiff und Laser). Passe die Größe bei Bedarf an.

Füge der Mine diese Komponenten hinzu:

• Circle Collider 2D
• Rigidbody 2D mit Gravity Scale = 0

Erstelle ein neues Tag mit dem Namen Enemy und weise es der Mine zu.

Erstelle ein neues C#-Skript mit dem Namen MineMove. Es bewegt die Mine nach unten, zerstört sie, wenn sie aus dem Bild verschwindet, und startet die Szene neu, wenn sie den Spieler trifft.

using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;

public class MineMove : MonoBehaviour
{
    // Geschwindigkeit der Mine
    public float speed = 1f;

    // Referenz auf Rigidbody2D
    Rigidbody2D rb;

    void Start()
    {
        // Rigidbody2D abrufen und Bewegung nach unten setzen
        rb = GetComponent<Rigidbody2D>();
        Vector3 move = new Vector3(0, -1, 0);
        rb.linearVelocity = move * speed;
    }

    void OnBecameInvisible()
    {
        // Mine zerstören, wenn sie nicht mehr sichtbar ist
        Destroy(gameObject);
    }

    void OnCollisionEnter2D(Collision2D collision)
    {
        // Wenn die Mine den Spieler trifft, Spiel zurücksetzen
        if (collision.gameObject.tag == "Player")
        {
            Destroy(gameObject);
            SceneManager.LoadScene(SceneManager.GetActiveScene().name);
        }
    }
}

Hänge das Skript an das Mine-Objekt. Setze Speed auf 1. Ziehe dann die Mine in das Assets-Fenster, um ein Prefab zu erstellen. Danach kannst du sie aus der Szene löschen — wir erzeugen sie später per Skript.

Schritt 7. Minen automatisch erzeugen

Jetzt automatisieren wir die Gegnerwellen. Wir richten einen Spawner ein, der neue Minen an zufälligen Positionen erzeugt.

Gehe zu GameObject → Create Empty. Unity erstellt ein neues GameObject in der Szene. Benenne es in MineSpawner um. Du kannst ihm ein benutzerdefiniertes Icon zuweisen, um es in der Szene leichter zu finden.

Verschiebe den MineSpawner in die obere linke Ecke des sichtbaren Bildschirmbereichs. Achte darauf, dass seine Z-Position auf 0 gesetzt ist, da es sich um ein 2D-Spiel handelt.

Wähle MineSpawner aus, drücke Strg + D (oder Rechtsklick → Duplizieren). Benenne das neue Objekt in RightPosition um und mache es zu einem Child von MineSpawner. Verschiebe es in die obere rechte Ecke des Bildschirms. Setze auch hier die Z-Position auf 0.

Erstelle nun ein neues C#-Skript mit dem Namen ObjectSpawner. Es wird eine zufällige X-Position zwischen den beiden Punkten auswählen und dort Minen mit Zeitverzögerung erzeugen.

using UnityEngine;
using System.Collections;

public class ObjectSpawner : MonoBehaviour
{
    // Rechter Punkt für zufällige X-Position
    public Transform RightPosition;

    // Verzögerung zwischen Spawns
    public float spawnDelay = 5f;

    // Objekt, das gespawnt wird
    public GameObject Item;

    void Start()
    {
        // Funktion regelmäßig aufrufen
        InvokeRepeating("Spawn", spawnDelay, spawnDelay);
    }

    void Spawn()
    {
        // Zufällige X-Position zwischen Spawner und rechtem Punkt wählen
        Vector3 spawnPos = new Vector3(
            Random.Range(transform.position.x, RightPosition.position.x),
            transform.position.y,
            0);

        // Objekt an der berechneten Position erzeugen
        Instantiate(Item, spawnPos, transform.rotation);
    }
}

Hänge dieses Skript an das MineSpawner-Objekt. Ziehe RightPosition in das Feld Right Position und das Mine-Prefab in das Feld Item. Setze Spawn Delay auf 5.

Klicke auf Play — nun erscheinen Minen automatisch an zufälligen Positionen oben auf dem Bildschirm.

Schritt 8. Lebenspunkte und Schaden hinzufügen

Momentan fliegen die Laser einfach durch die Minen hindurch — ohne Auswirkungen. Das ändern wir jetzt, indem wir den Minen Lebenspunkte geben und den Lasern Schaden zuweisen.

Erstelle ein neues C#-Skript mit dem Namen HpController. Es speichert die Lebenspunkte und zerstört das Objekt, wenn diese auf null fallen.

using UnityEngine;

public class HpController : MonoBehaviour
{
    // Lebenspunkte
    public int hp = 3;

    // Methode zum Anwenden von Schaden
    void MakeDamage(int damage)
    {
        hp -= damage;

        // Wenn HP auf 0 fallen, Objekt zerstören
        if (hp <= 0)
        {
            Destroy(gameObject);
        }
    }
}

Wähle das Mine-Prefab im Assets-Fenster aus und füge das HpController-Skript hinzu. Setze hp auf 3.

Öffne jetzt das LaserShot-Skript. Wir prüfen dort die Kollisionen und schicken Schaden an den Gegner.

using UnityEngine;

public class LaserShot : MonoBehaviour
{
    // Referenz auf Rigidbody2D
    Rigidbody2D rb;

    // Kraft, mit der der Laser fliegt
    public float force = 10f;

    // Schaden, den der Laser verursacht
    public int damage = 1;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        Vector3 direction = new Vector3(0, force, 0);
        rb.AddForce(direction, ForceMode2D.Impulse);
    }

    void OnBecameInvisible()
    {
        Destroy(gameObject);
    }

    void OnTriggerEnter2D(Collider2D other)
    {
        // Prüfen, ob ein Gegner getroffen wurde
        if (other.gameObject.tag == "Enemy")
        {
            // Schaden an das Ziel senden (falls vorhanden)
            other.gameObject.SendMessage("MakeDamage", damage, SendMessageOptions.DontRequireReceiver);

            // Laser zerstören
            Destroy(gameObject);
        }
    }
}

Wähle das Laser-Prefab aus und setze den Damage-Wert im Inspector auf 1.

Klicke auf Play und teste die Szene. Minen sollten nun drei Treffer benötigen, um zerstört zu werden.

Schritt 9. Ein feindliches Schiff und seine Rakete erstellen

Jetzt fügen wir einen Gegner hinzu, der zurückschießt. Wir verwenden unser bestehendes Setup und nehmen ein paar Anpassungen vor.

Ziehe das Mine-Prefab in die Szene. Benenne es in Enemy-1 um. Ändere das Sprite zum Bild des feindlichen Schiffs. Setze HP auf 1.

Klicke mit der rechten Maustaste auf den Circle Collider 2D und entferne ihn. Füge stattdessen einen Box Collider 2D hinzu. Ziehe dann Enemy-1 zurück ins Assets-Fenster, um ein neues Prefab zu erstellen. Danach kannst du es aus der Szene löschen.

Jetzt geben wir diesem Gegner eine Rakete. Ziehe das Raketen-Sprite in die Szene und benenne es in Rocket um. Setze Order in Layer auf -10. Füge einen Box Collider 2D hinzu und aktiviere Is Trigger. Füge ein Rigidbody 2D hinzu mit Gravity Scale = 0 und Interpolate = Interpolate.

Erstelle ein neues C#-Skript mit dem Namen EnemyBullet. Es soll folgendes tun:

using UnityEngine;

public class EnemyBullet : MonoBehaviour
{
    GameObject player;
    Rigidbody2D rb;

    public float force = 3f;
    public int damage = 1;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        player = GameObject.FindWithTag("Player");

        if (player != null)
        {
            // Richtung zum Spieler berechnen
            Vector3 dir = player.transform.position - transform.position;

            // Rakete auf das Ziel ausrichten
            transform.up = dir;

            // Rakete nach vorne beschleunigen
            rb.AddRelativeForce(transform.up * force, ForceMode2D.Impulse);
        }
        else
        {
            // Wenn kein Spieler gefunden wurde, Rakete entfernen
            Destroy(gameObject);
        }
    }

    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            // Schaden an den Spieler senden (falls möglich)
            other.gameObject.SendMessage("MakeDamage", damage, SendMessageOptions.DontRequireReceiver);

            // Rakete zerstören
            Destroy(gameObject);
        }
    }

    void OnBecameInvisible()
    {
        // Rakete entfernen, wenn sie den Bildschirm verlässt
        Destroy(gameObject);
    }
}

Füge das EnemyBullet-Skript dem Rocket-Objekt hinzu. Setze Force auf 3 und Damage auf 1. Erstelle ein Prefab, indem du die Rakete ins Assets-Fenster ziehst. Danach kannst du sie aus der Szene löschen.

Schritt 10. Dem Gegner das Schießen beibringen

Jetzt geben wir dem feindlichen Schiff etwas Feuerkraft. Wir fügen ein Skript hinzu, das regelmäßig eine Rakete erzeugt — alles Weitere übernimmt dann die Rakete selbst.

Erstelle ein neues C#-Skript mit dem Namen EnemyShoot.

using UnityEngine;
using System.Collections;

public class EnemyShoot : MonoBehaviour
{
    // Prefab der Rakete, die geschossen wird
    public GameObject bullet;

    // Zeit zwischen zwei Schüssen
    public float fireDelay = 2f;

    // Referenz auf den Spieler
    GameObject player;

    // Darf der Gegner gerade schießen?
    bool canShoot = true;

    void Start()
    {
        // Spieler per Tag finden
        player = GameObject.FindWithTag("Player");
    }

    void Update()
    {
        // Nur schießen, wenn Spieler existiert und Schießen erlaubt ist
        if (canShoot && player != null)
        {
            canShoot = false;

            // Rakete an aktueller Position erzeugen
            Instantiate(bullet, transform.position, Quaternion.identity);

            // Wartezeit starten
            StartCoroutine(firePause());
        }
    }

    IEnumerator firePause()
    {
        // Nach der Verzögerung darf wieder geschossen werden
        yield return new WaitForSeconds(fireDelay);
        canShoot = true;
    }
}

Wähle das Enemy-1-Prefab im Assets-Fenster aus. Füge das Skript EnemyShoot hinzu. Ziehe das Rocket-Prefab in das Feld Bullet. Setze Fire Delay auf 2.

Schritt 11. Gegner zusammen mit Minen erzeugen

Unser Enemy-1-Prefab ist fertig. Jetzt lassen wir es — genau wie die Minen — in der Szene erscheinen. Statt einen zweiten Spawner zu bauen, verbessern wir einfach den bestehenden und erlauben ihm, zufällig zwischen mehreren Objekten zu wählen.

Öffne das Skript ObjectSpawner und passe es so an, dass es ein Array von Prefabs verwendet:

using UnityEngine;

public class ObjectSpawner : MonoBehaviour
{
    // Rechter Rand für zufällige Spawn-Position
    public Transform RightPosition;

    // Verzögerung zwischen Spawns
    public float spawnDelay;

    // Liste der zu spawnenden Objekte (z. B. Minen, Gegner)
    public GameObject[] Item;

    void Start()
    {
        // Spawn-Funktion regelmäßig aufrufen
        InvokeRepeating("Spawn", spawnDelay, spawnDelay);
    }

    void Spawn()
    {
        // Zufällige X-Position zwischen Spawner und rechtem Punkt wählen
        Vector3 spawnPos = new Vector3(
            Random.Range(transform.position.x, RightPosition.position.x),
            transform.position.y,
            0
        );

        // Zufälliges Objekt aus der Liste wählen
        int i = Random.Range(0, Item.Length);

        // Gewähltes Objekt erzeugen
        Instantiate(Item[i], spawnPos, transform.rotation);
    }
}

Wähle in der Szene das Objekt MineSpawner aus und öffne die aktualisierte Item-Liste. Füge sowohl das Mine- als auch das Enemy-1-Prefab hinzu. Unity passt die Listengröße automatisch an.

Schritt 12. Eine Lebensanzeige erstellen

Unser Spieler hat derzeit keine sichtbare Gesundheit. Wir fügen eine einfache Benutzeroberfläche hinzu, um die aktuellen HP anzuzeigen. Dazu erstellen wir eine horizontale Lebensleiste mit Unitys eingebautem UI-System.

Gehe zu GameObject → UI → Image. Dadurch wird ein neues Canvas mit einem Image-Objekt erstellt. Benenne das Image in HealthBar um.

Wähle das Canvas aus. Im Inspector unter Canvas Scaler stelle UI Scale Mode auf Scale With Screen Size.

Doppelklicke nun im Hierarchy-Fenster auf Canvas — die Szene zoomt zur UI. Wähle HealthBar aus und verwende das Rect Tool, um es in die Form einer Leiste zu bringen. Du kannst sie platzieren, wo es am besten zum Layout passt.

Mit ausgewähltem HealthBar stelle folgendes ein:

• Source Image auf Background
• Image Type auf Filled
• Fill Method auf Horizontal
• Fill Origin auf Left

Hinweis: Fill Method und Origin könnten automatisch gesetzt werden, sobald du Filled auswählst. Du kannst später damit experimentieren, aber für jetzt passt es so.

Schritt 13. Spieler-Gesundheit steuern

Jetzt verbinden wir die Lebensleiste mit dem eigentlichen Spielgeschehen. Wir schreiben ein Skript, das die HP des Spielers verwaltet und die Leiste entsprechend aktualisiert.

Erstelle ein neues C#-Skript namens PlayerHp:

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

public class PlayerHp : MonoBehaviour
{
    // Referenz auf das UI-Bild (HealthBar)
    public GameObject HealthBar;

    // Interne Referenz auf die Image-Komponente
    Image img;

    // Aktuelle und maximale Gesundheit
    public int hp;
    float maxHp;

    void Start()
    {
        // Image-Komponente vom zugewiesenen Objekt holen
        img = HealthBar.GetComponent<Image>();

        // Max HP setzen
        maxHp = hp;

        // Lebensleiste auf voll setzen
        img.fillAmount = hp / maxHp;
    }

    // Wird aufgerufen, wenn der Spieler Schaden nimmt
    void MakeDamage(int damage)
    {
        hp -= damage;

        // Wenn HP aufgebraucht sind, Szene neu laden
        if (hp <= 0)
        {
            SceneManager.LoadScene(SceneManager.GetActiveScene().name);
        }

        // Lebensleiste aktualisieren
        img.fillAmount = hp / maxHp;
    }
}

Gehe nun zur Szene und wähle dein Player-Objekt aus. Füge das Skript PlayerHp hinzu. Ziehe das HealthBar-Objekt (aus dem Canvas) in das Feld Health Bar. Setze den HP-Wert auf 10.

Schritt 14. Hintergrundfarbe festlegen

Beginnen wir damit, den Hintergrund unserer Szene in ein tiefes Weltraum-Schwarz zu tauchen. Wähle die Main Camera in der Hierarchie. Im Inspector gehe zum Bereich Environment und setze die Background-Farbe auf black.

Schritt 15. Bewegte Sterne mit dem Partikelsystem hinzufügen

Für einen schönen Weltraum-Effekt verwenden wir Unitys eingebautes Partikelsystem, um sich bewegende Sterne zu simulieren.

1. Gehe zu GameObject → Effects → Particle System.
2. Benenne das neue Objekt in Stars um.
3. Setze die Z-Position auf 10 und die X-Rotation auf 90.
4. Verschiebe es nach oben, sodass es über dem sichtbaren Kamerabereich liegt.
5. In den Einstellungen des Particle System:
   • Aktiviere Prewarm.
   • Passe die Start Lifetime so an, dass Partikel den ganzen Bildschirm durchqueren.
   • Setze die Start Speed nach deinem Geschmack.
   • Setze die Start Size auf 0.2 (oder nach Wunsch).
6. Im Modul Shape:
   • Setze Shape auf Box.
   • Setze den X-Wert auf 15, damit das Sternfeld breit genug ist.
7. Im Modul Renderer:
   • Setze Order in Layer auf -100, damit die Sterne weit im Hintergrund angezeigt werden.

Schritt 16. Schussgeräusch hinzufügen

Geben wir der feindlichen Rakete einen passenden Sound. Immer wenn eine Rakete gespawnt wird, spielen wir einen kurzen Klang über Unitys integriertes Audiosystem ab.

Die Soundeffekte dieses Tutorials kannst du hier herunterladen:

• 🔊 LaserSound.wav – wird abgespielt, wenn eine Rakete oder ein Laser geschossen wird
• 💥 Boom.wav – wird abgespielt bei Explosionen (z. B. bei Zerstörung)

Öffne das Skript EnemyBullet und füge folgende Variable hinzu:

// Variable für Soundeffekt
public AudioClip BulletSound;

Füge dann innerhalb der Start()-Funktion nach dem Raketenstart diese Zeile ein:

AudioSource.PlayClipAtPoint(BulletSound, transform.position);

Dadurch wird ein temporäres Audio-Objekt erstellt, das den Sound abspielt und sich danach selbst entfernt.

Hier das vollständige, aktualisierte Skript EnemyBullet mit Ton:

using UnityEngine;

public class EnemyBullet : MonoBehaviour
{
    GameObject player;
    Rigidbody2D rb;

    public float force = 3f;
    public int damage = 1;
    public AudioClip BulletSound;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        player = GameObject.FindWithTag("Player");

        if (player != null)
        {
            Vector3 dir = player.transform.position - transform.position;
            transform.up = dir;
            rb.AddRelativeForce(transform.up * force, ForceMode2D.Impulse);

            // Schussgeräusch abspielen
            AudioSource.PlayClipAtPoint(BulletSound, transform.position);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            other.gameObject.SendMessage("MakeDamage", damage, SendMessageOptions.DontRequireReceiver);
            Destroy(gameObject);
        }
    }

    void OnBecameInvisible()
    {
        Destroy(gameObject);
    }
}

Wähle nun das Rocket-Prefab aus. Weise im EnemyBullet-Skript das Feld Bullet Sound der Audiodatei LaserSound zu.

💡 Du kannst auch deinen eigenen Sound verwenden — importiere einfach eine .wav-Datei und ziehe sie in das AudioClip-Feld.

Schritt 17. Schussgeräusch für Laser des Spielers hinzufügen

Genauso wie bei den Raketen der Gegner möchten wir auch beim Laserschuss des Spielers einen Ton hinzufügen. Öffne das LaserShot-Skript und aktualisiere es wie folgt:

using UnityEngine;

public class LaserShot : MonoBehaviour
{
    Rigidbody2D rb;
    public float force = 10f;
    public int damage = 1;
    public AudioClip LaserSound;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        Vector3 direction = new Vector3(0, force, 0);
        rb.AddForce(direction, ForceMode2D.Impulse);

        // Schussgeräusch abspielen
        AudioSource.PlayClipAtPoint(LaserSound, transform.position);
    }

    void OnBecameInvisible()
    {
        Destroy(gameObject);
    }

    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.gameObject.tag == "Enemy")
        {
            other.gameObject.SendMessage("MakeDamage", damage, SendMessageOptions.DontRequireReceiver);
            Destroy(gameObject);
        }
    }
}

Nachdem du das Skript aktualisiert hast, öffne das Laser-Prefab im Assets-Fenster und weise die Datei LaserSound.wav dem neuen Feld Laser Sound zu.

💡 Du kannst auch deine eigenen Soundeffekte verwenden — ziehe eine beliebige .wav-Datei in den Ordner Assets/sound und weise sie zu.

Schritt 18. Explosionsgeräusch beim Zerstören abspielen

Wenn Minen oder Gegner zerstört werden, wollen wir ein kurzes Explosionsgeräusch abspielen. Dazu erweitern wir das Skript HpController um ein Audiofeld und spielen den Ton ab, wenn die Lebenspunkte auf null fallen.

using UnityEngine;

public class HpController : MonoBehaviour
{
    public int hp = 3;
    public AudioClip ExplosionsSound;

    void MakeDamage(int damage)
    {
        hp -= damage;

        if (hp <= 0)
        {
            AudioSource.PlayClipAtPoint(ExplosionsSound, transform.position);
            Destroy(gameObject);
        }
    }
}

Wähle die Prefabs Mine und Enemy-1 im Assets-Fenster aus. Weise im HpController das Feld Explosions Sound mit der Datei Boom.wav zu.

Das war’s! Jetzt wird bei jeder Zerstörung ein passendes Explosionsgeräusch abgespielt.

💡 Du kannst natürlich auch eigene Sounds verwenden — einfach ins Assets/sound-Verzeichnis ziehen und zuweisen.

Schritt 19. Explosions-Effekt hinzufügen

Es fehlt noch ein Partikeleffekt, wenn ein Gegner (z. B. Mine oder Enemy-1) zerstört wird. Erstelle ein neues Particle System und benenne es KiavoBoom. Setze Position und Rotation auf 0. Nimm im Inspector folgende Einstellungen vor:

• Dauer: 1
• Looping: deaktiviert
• Start Lifetime: 1
• Start Speed: 2
• Start Size: 2
• Max Particles: 30

Öffne das Emission-Modul und füge einen Burst bei 0.0 mit 30 Partikeln hinzu.
Im Shape-Modul wähle Circle und setze den Radius auf 0.1.

Aktiviere Color over Lifetime. Stelle im Farbeditor Alpha am Ende auf 0 und wähle passende Farben. Im Renderer-Modul stelle Order in Layer auf 10.

Füge dem KiavoBoom-Objekt das Skript TimeDestroyer hinzu und setze Time To Destroy auf 2. Erstelle daraus ein Prefab und entferne es aus der Szene.

Später kannst du die Explosion noch bunter oder dramatischer gestalten — das hier ist nur der erste Effekt.

Schritt 20. Explosion auslösen, wenn Gegner zerstört wird

Jetzt haben wir ein Explosions-Prefab. Dieses soll abgespielt werden, sobald ein Gegner (z. B. Mine oder Enemy-1) zerstört wird. Öffne das Skript HpController und ändere es wie folgt:

using UnityEngine;

public class HpController : MonoBehaviour
{
    public int hp = 3;

    // Explosions-Prefab
    public GameObject Explosion;

    // Explosionsgeräusch
    public AudioClip ExplosionsSound;

    void MakeDamage(int damage)
    {
        hp -= damage;

        if (hp <= 0)
        {
            // Sound abspielen
            AudioSource.PlayClipAtPoint(ExplosionsSound, transform.position);

            // Explosion erzeugen
            Instantiate(Explosion, transform.position, Quaternion.identity);

            // Objekt zerstören
            Destroy(gameObject);
        }
    }
}

Wähle die Prefabs Mine und Enemy-1 aus. Weise im HpController dein Explosions-Prefab (z. B. KiavoBoom) dem Feld Explosion zu.

Schritt 21. Wie geht’s weiter?

Unser Spiel ist jetzt komplett — mit Bewegung, Gegnern, Schüssen, Ton und Benutzeroberfläche. Dieses Tutorial zeigt dir, wie du mit einfachen Mitteln ein funktionierendes 2D-Space-Shooter-Spiel baust.

Natürlich kannst du noch viel mehr hinzufügen: Explosionen, Effekte, Gegnerwellen, Punkte, Leben, Menüs, Bosskämpfe, Musik… oder fliegende Hühner und Weltraum-Tee ☕🛸

Aber unser Ziel war es, dir ein klares, leicht verständliches Fundament zu geben — und das hast du jetzt.

💡 Experimentiere weiter, hab Spaß und baue dein eigenes Spiel darauf auf!