Grundlegende Unity-Komponenten

Leeres GameObject

Ein GameObject in Unity dient als Container für Komponenten, die seine Eigenschaften und seine Rolle in der Szene bestimmen. Für sich genommen macht ein GameObject fast nichts — Verhalten, Aussehen und Interaktion entstehen erst, wenn Komponenten hinzugefügt werden.

Meist beginnt die Erstellung eines Objekts mit einem leeren GameObject. Dieses kann über das Menü GameObject → Create Empty oder mit der Tastenkombination Ctrl + Shift + N erstellt werden.

Nach der Erstellung erscheint das Objekt in der Szene und im Fenster Hierarchy. Man kann ihm einen passenden Namen geben und auch ein kleines Symbol auswählen, damit es in der Szene leichter zu finden ist und die Projektstruktur übersichtlicher bleibt.

Beim Erstellen eines GameObjects fügt Unity automatisch die erste und obligatorische Komponente hinzu — Transform. Sie steuert die Position des Objekts in der Szene und ist bei jedem GameObject vorhanden. Im nächsten Schritt werden wir sie genauer betrachten.

Transform

Transform ist eine obligatorische Komponente jedes GameObjects in Unity. Wenn ein Objekt in der Szene existiert, besitzt es eine Position, eine Orientierung und eine Größe. All diese Parameter werden in der Transform-Komponente festgelegt.

Wenn wir die Werte der Transform-Felder im Inspector ändern, verändern wir die Position des Objekts in der Szene, seine Rotation und seinen Maßstab. Fast jedes Objekt in einem Spiel nutzt diese Parameter in irgendeiner Form.

💡 Den Inspector kann man als die „Visitenkarte“ eines GameObjects betrachten. Im Inspector sehen wir alle hinzugefügten Komponenten und ihre Einstellungen. Wenn du ein Objekt in der Szene oder im Hierarchy-Fenster auswählst, zeigt Unity seine Eigenschaften im Inspector-Fenster an.

Die Werte von Komponenten können nicht nur über den Inspector, sondern auch über Skripte geändert werden — und genau so geschieht es während des Spiels meistens.

In den vorherigen Lektionen haben wir bereits über den Zugriff auf Komponenten mit GetComponent<T>() gesprochen. Für Transform macht Unity jedoch eine Ausnahme: Da jede Instanz dieses Objekt diese Komponente besitzt, kann direkt über transform darauf zugegriffen werden.

Über Transform lassen sich nicht nur die im Inspector sichtbaren Felder verändern, sondern auch zusätzliche Funktionen zur Steuerung des Objekts nutzen.

Häufig verwendete Eigenschaften und Methoden von Transform:

• transform.position = new Vector3(x, y, z);
  setzt die Position des Objekts in Weltkoordinaten.
• transform.rotation = Quaternion.Euler(x, y, z);
  setzt die Rotation des Objekts entlang der Achsen.
• transform.localScale = new Vector3(x, y, z);
  verändert die Größe (Skalierung) des Objekts.
• transform.Translate(x, y, z);
  bewegt das Objekt relativ zu seiner aktuellen Position.
• transform.Rotate(x, y, z);
  rotiert das Objekt um einen bestimmten Winkel.
• transform.localPosition = new Vector3(x, y, z);
  die Position des Objekts relativ zu seinem Elternobjekt.
• transform.SetParent(parentTransform);
  macht das Objekt zu einem Kind eines anderen Objekts.

Als Beispiel schreiben wir ein einfaches Skript, das zeigt, wie man über Code mit der Transform-Komponente interagieren kann.

using UnityEngine;

public class TransformExample : MonoBehaviour
{
    void Start()
    {
        // Setzt die Position des Objekts auf (1, 1, 0)
        transform.position = new Vector3(1f, 1f, 0f);

        // Dreht das Objekt um 45 Grad um die Z-Achse
        transform.rotation = Quaternion.Euler(0f, 0f, 45f);

        // Vergrößert das Objekt auf die doppelte Größe
        transform.localScale = new Vector3(2f, 2f, 2f);
    }

    void Update()
    {
        // Bewegt das Objekt in jedem Frame etwas nach rechts
        transform.Translate(1f * Time.deltaTime, 0f, 0f);

        // Dreht das Objekt in jedem Frame ein wenig
        transform.Rotate(0f, 0f, 90f * Time.deltaTime);
    }
}

Sprite Renderer

Die Sprite Renderer-Komponente ist dafür verantwortlich, Sprites in der Szene darzustellen. Sie sorgt dafür, dass ein GameObject sichtbar wird, indem das ausgewählte Bild gerendert wird.

💡 Um einem Objekt eine Komponente hinzuzufügen, wähle es in der Hierarchy oder direkt in der Szene aus und klicke im Inspector auf die Schaltfläche Add Component. Anschließend kannst du die gewünschte Komponente über das Suchfeld finden.

Im Gegensatz zu Transform ist die Sprite Renderer-Komponente nicht obligatorisch. Deshalb muss sie im Code zuerst über GetComponent<SpriteRenderer>() abgerufen werden.

Häufig verwendete Eigenschaften und Methoden des Sprite Renderer:

Parameter, die häufig über Skripte verändert werden:

• spriteRenderer.sprite = newSprite;
  ändert das Bild des Objekts. Nützlich für Animationen oder wenn eine Figur einen neuen Gegenstand aufnimmt.
• spriteRenderer.flipX = true;
  spiegelt das Sprite horizontal. Die einfachste Möglichkeit, eine Figur beim Laufen nach links oder rechts schauen zu lassen.
• spriteRenderer.color = Color.red;
  verändert Farbe und Transparenz. Wird häufig verwendet, um ein Objekt bei Schaden rot hervorzuheben oder halbtransparent zu machen.

Einstellungen, die sich besser im Inspector konfigurieren lassen:

• Sprite — das Basisbild des Objekts, das wir standardmäßig in der Szene sehen.
• Material — bestimmt, wie das Sprite mit Licht interagiert. Meist wird das Standardmaterial Sprites-Default verwendet.
• Sorting Layer — die Render-Ebene. Damit kann man festlegen, dass der Spieler immer über dem Hintergrund dargestellt wird und nicht hinter der Umgebung verschwindet.
• Order in Layer — die Reihenfolge innerhalb einer Ebene. Wenn zwei Objekte dieselbe Ebene haben, wird das Objekt mit dem höheren Wert darüber dargestellt.
• Draw Mode — wenn Tiled gewählt wird, kann das Sprite wie eine Tapete gestreckt werden, wobei sich das Bild wiederholt statt verzerrt zu werden.

Als Beispiel schreiben wir ein einfaches Skript, das die Sprite-Renderer-Komponente abruft und einige ihrer Parameter ändert.

using UnityEngine;

public class SpriteRendererExample : MonoBehaviour
{
    // Referenz auf die Sprite-Renderer-Komponente
    private SpriteRenderer spriteRenderer;

    // neues Sprite, das im Inspector zugewiesen werden kann
    public Sprite newSprite;

    void Start()
    {
        // Sprite-Renderer-Komponente vom Objekt abrufen
        spriteRenderer = GetComponent<SpriteRenderer>();

        // Bild des Sprites ändern
        spriteRenderer.sprite = newSprite;

        // Sprite horizontal spiegeln
        spriteRenderer.flipX = true;

        // Render-Reihenfolge festlegen
        spriteRenderer.sortingOrder = 10;
    }
}

Collider

Collider-Komponenten definieren die Grenzen eines Objekts und seine Interaktion mit anderen Objekten. Das Sprite oder Modell selbst besitzt keine physikalischen Grenzen — der Collider bestimmt die Form, mit der Unity Kollisionen und Kontakte erkennt.

Collider erfüllen in der Regel zwei Hauptfunktionen. Erstens können sie als physische Grenze dienen, sodass andere Objekte nicht durch sie hindurchgehen können. Zweitens kann ein Collider als Erkennungsbereich arbeiten, wenn der Modus Is Trigger aktiviert ist.

Im Trigger-Modus erzeugt der Collider keine normale physische Kollision, sondern meldet lediglich den Kontakt. Über ein Skript kann man erkennen, wann ein anderes Objekt den Triggerbereich betritt, sich darin befindet oder ihn wieder verlässt.

💡 Damit Trigger-Ereignisse funktionieren, muss mindestens eines der beteiligten Objekte eine Rigidbody2D-Komponente besitzen.

Zum Beispiel kann man einem Objekt einen Box Collider 2D hinzufügen und die Option Is Trigger aktivieren. Anschließend kann ein Skript erkennen, wann ein anderer Collider diesen Bereich betritt.

using UnityEngine;

public class TriggerDestroyExample : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D other)
    {
        // Wenn ein anderes Objekt den Triggerbereich betritt,
        // wird dieses Objekt zerstört
        Destroy(other.gameObject);
    }
}

In diesem Beispiel wird die Methode OnTriggerEnter2D automatisch aufgerufen, wenn ein anderes Objekt mit einem 2D-Collider den Triggerbereich betritt. Über den Parameter other erhalten wir Zugriff auf das eingetretene Objekt und können es zum Beispiel mit Destroy() entfernen.

💡 Denke daran, dass Collider in zwei Versionen existieren: 2D und 3D. 2D-Komponenten arbeiten nur mit anderen 2D-Komponenten zusammen, und 3D-Komponenten nur mit 3D-Komponenten.

Wichtige Parameter im Inspector:

• Edit Collider — eine kleine Schaltfläche, mit der man die Kollisionsgrenzen direkt in der Szene mit der Maus anpassen kann.
• Is Trigger — wenn aktiviert, ist das Objekt nicht mehr fest (andere Objekte können hindurchgehen), erkennt aber Berührungen. Ideal für Münzen, Lebenspunkte oder Fallenbereiche.
• Material — hier kann ein Physics Material 2D zugewiesen werden, damit das Objekt zum Beispiel wie ein Ball springt oder wie Eis rutschig wird.
• Used by Effector — eine fortgeschrittene Option für spezielle Effekte, zum Beispiel einseitige Plattformen (durch die man von unten springen kann, aber nicht von oben hindurchfällt).

Collider können unterschiedliche Formen haben. In 2D werden häufig Box Collider 2D, Circle Collider 2D und Polygon Collider 2D verwendet. Für 3D gibt es Varianten wie Box Collider, Sphere Collider, Capsule Collider und andere.

Je komplexer die Collider-Form ist, desto mehr Berechnungen muss die Engine durchführen. Deshalb ist es meist nicht nötig, die Form eines Sprites perfekt nachzubilden, wenn es keinen Einfluss auf das Gameplay hat. In der Praxis ist die gewünschte Funktionalität wichtiger als eine exakt passende Form.

Auch die Eigenschaften eines Colliders können angepasst werden. Zum Beispiel kann man für die 2D-Physik ein spezielles Physics Material 2D erstellen, das Reibung und Elastizität bestimmt.

Ein solches Material kann über folgendes Menü erstellt werden: Assets → Create → 2D → Physics Material 2D. Danach wählst du das erstellte Material im Project-Fenster aus und stellst seine Parameter im Inspector ein.

• Friction — bestimmt die Oberflächenreibung
• Bounciness — bestimmt, wie elastisch das Objekt ist

Anschließend kann dieses Material im Feld Material der Collider-2D-Komponente zugewiesen werden.

Rigidbody

Während ein Collider einem Objekt physische Grenzen hinzufügt, sorgt die Rigidbody-Komponente für physikalisches Verhalten: Fallen durch Gravitation, Bewegung durch Kräfte und Reaktionen auf Kollisionen.

Wenn sich in deinem Spiel ein unbewegliches Objekt befindet, zum Beispiel ein Boden oder eine Wand, reicht normalerweise ein Collider. Wenn sich ein Objekt jedoch bewegen, fallen oder auf Kräfte reagieren soll, benötigt es zusätzlich eine Rigidbody-Komponente.

💡 Denke daran, dass Rigidbody – genau wie Collider – in zwei Versionen existiert: 2D und 3D. Rigidbody2D arbeitet nur mit 2D-Collidern, während das normale Rigidbody mit 3D-Collidern verwendet wird.

Häufig verwendete Eigenschaften und Methoden von Rigidbody:

Parameter, die häufig über Skripte verändert werden:

• rb.linearVelocity = new Vector2(5f, 0f);
  setzt sofort die Bewegungsgeschwindigkeit des Objekts entlang der X- und Y-Achse. Eine der häufigsten Methoden, um eine Figur zu bewegen.
• rb.AddForce(Vector2.up * 5f, ForceMode2D.Impulse);
  stößt das Objekt mit einer Kraft (Impuls) an. Ideal für Sprünge oder Explosionseffekte.
• rb.gravityScale = 0.5f;
  erlaubt es, den Einfluss der Gravitation dynamisch zu verändern. Man kann eine Figur beim Springen „leichter“ machen oder das Fallen komplett deaktivieren.

Einstellungen, die sich besser im Inspector konfigurieren lassen:

• Body Type — definiert die „Rolle“ des Objekts: Dynamic (volle Physik), Kinematic (bewegt sich nur durch Code und ignoriert physische Kräfte) oder Static (ein unbewegliches Hindernis).
• Mass — das Gewicht des Objekts in relativen Einheiten. Es beeinflusst, wie stark das Objekt andere bei Kollisionen wegstößt.
• Linear / Angular Damping — Luftwiderstand. Je höher diese Werte sind, desto schneller stoppt das Objekt, nachdem man aufgehört hat, es zu bewegen.
• Constraints — Achsen sperren. Die wichtigste Einstellung ist Freeze Rotation Z, damit deine Figur beim Laufen nicht umkippt oder wie ein Rad rollt.
• Collision Detection — wenn sich ein Objekt sehr schnell bewegt (z. B. eine Kugel), sollte man Continuous wählen, damit es nicht durch Wände hindurchfliegt.

Die Bewegung von Objekten mit Rigidbody kann grob in zwei Arten unterteilt werden. Die erste ist die automatische Physik von Unity: Gravitation und Interaktion mit anderen Körpern. Die zweite sind Kräfte oder Änderungen, die wir über Skripte hinzufügen.

In Skripten werden meist zwei Ansätze verwendet: das Anwenden von Kräften oder das direkte Ändern der Geschwindigkeit. Kräfte sorgen für realistischere Physik, während das direkte Setzen der Geschwindigkeit eine reaktionsschnellere Steuerung ermöglicht.

Im folgenden Beispiel bewegt sich ein Objekt mit Rigidbody2D nach links und rechts mit den Pfeiltasten und erhält einen Impuls nach oben (Sprung), wenn Space gedrückt wird.

using UnityEngine;
using UnityEngine.InputSystem;

public class RigidbodyMovementExample : MonoBehaviour
{
   private Rigidbody2D rb;

public float moveSpeed = 5f;
public float jumpForce = 6f;

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

void Update()
{
    if (Keyboard.current == null) return;

    float x = 0f;

    // Bewegung nach links
    if (Keyboard.current.leftArrowKey.isPressed)
        x = -moveSpeed;

    // Bewegung nach rechts
    if (Keyboard.current.rightArrowKey.isPressed)
        x = moveSpeed;

    // Horizontale Geschwindigkeit ändern
    rb.linearVelocity = new Vector2(x, rb.linearVelocity.y);

    // Sprung durch Anwenden einer Kraft
    if (Keyboard.current.spaceKey.wasPressedThisFrame)
    {
        rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
    }
}
}

Skript

Deine Skripte in Unity sind ebenfalls Komponenten. Am häufigsten werden Skripte vom Typ MonoBehaviour verwendet. Dabei handelt es sich um normale C#-Skripte, die von der Klasse MonoBehaviour erben, um Zugriff auf Funktionen und Ereignisse von Unity zu erhalten.

Skripte definieren normalerweise die Spiellogik, speichern Daten und interagieren bei Bedarf mit anderen Komponenten eines Objekts — zum Beispiel mit Transform, Sprite Renderer oder Rigidbody.

Um ein neues Skript zu erstellen, öffne das Menü Assets → Create → MonoBehaviour Script. Danach erstellt Unity eine neue C#-Datei, die du im Code-Editor öffnen und bearbeiten kannst.

Im folgenden Beispiel wird das Skript:

• in der Szene nach einem Objekt mit dem Tag Friend suchen
• das Objekt mithilfe von Rigidbody2D bewegen
• das Sprite des Friend-Objekts ändern, wenn die Tasten 1, 2 oder 3 gedrückt werden

using UnityEngine;
using UnityEngine.InputSystem;

public class ScriptExample : MonoBehaviour
{
    // Referenz auf die Rigidbody2D-Komponente unseres Objekts
    private Rigidbody2D rb;

    // Referenz auf das Friend-Objekt
    private GameObject friend;

    // SpriteRenderer-Komponente des Friend-Objekts
    private SpriteRenderer friendRenderer;

    // Sprites, die im Inspector zugewiesen werden können
    public Sprite sprite1;
    public Sprite sprite2;
    public Sprite sprite3;

    public float moveSpeed = 5f;

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

        // Für dieses Beispiel die Gravitation deaktivieren
        rb.gravityScale = 0f;

        // In der Szene nach einem Objekt mit dem Tag "Friend" suchen
        friend = GameObject.FindWithTag("Friend");

        // Seine SpriteRenderer-Komponente abrufen
        if (friend != null)
            friendRenderer = friend.GetComponent<SpriteRenderer>();
    }

    void Update()
    {
        if (Keyboard.current == null) return;

        float x = 0f;
        float y = 0f;

        // Bewegung nach links und rechts
        if (Keyboard.current.leftArrowKey.isPressed) x = -moveSpeed;
        if (Keyboard.current.rightArrowKey.isPressed) x = moveSpeed;

        // Bewegung nach oben und unten
        if (Keyboard.current.upArrowKey.isPressed) y = moveSpeed;
        if (Keyboard.current.downArrowKey.isPressed) y = -moveSpeed;

        // Geschwindigkeit des Rigidbody2D ändern
        rb.linearVelocity = new Vector2(x, y);

        // Sprite des Friend-Objekts ändern
        if (friendRenderer != null)
        {
            if (Keyboard.current.digit1Key.wasPressedThisFrame)
                friendRenderer.sprite = sprite1;

            if (Keyboard.current.digit2Key.wasPressedThisFrame)
                friendRenderer.sprite = sprite2;

            if (Keyboard.current.digit3Key.wasPressedThisFrame)
                friendRenderer.sprite = sprite3;
        }
    }
}

💡 Skripte funktionieren wie normale Komponenten. Um ein Skript zu verwenden, füge es einem Objekt über die Schaltfläche Add Component im Inspector hinzu.

Wenn du das Skript in Aktion testen möchtest, füge den Feldern im Skript drei Sprites hinzu. Zum Testen kannst du auch die eingebauten Unity-Sprites verwenden, zum Beispiel InputFieldBackground, Knob oder UISprite.

Erstelle anschließend ein neues Objekt in der Szene: GameObject → 2D Object → Sprite → Square. Ändere danach im Inspector den Tag dieses Objekts zu Friend.

Wenn du die Szene startest, findet das Skript das Objekt mit dem Tag Friend und ändert dessen Sprite, wenn die Tasten 1, 2 und 3 gedrückt werden.

Welche Komponenten verwenden

Letztendlich bestimmt dein Spiel, welche Komponenten die Objekte in deiner Szene benötigen. Die in dieser Lektion genannten Komponenten dienen nur als Beispiele und helfen, das grundlegende Prinzip von Unity zu verstehen: Ein GameObject erhält seine Eigenschaften und sein Verhalten durch die Komponenten, die ihm hinzugefügt werden.

In der Praxis enthält Unity eine sehr große Anzahl verschiedener Komponenten, die für unterschiedliche Aufgaben gedacht sind. Zum Beispiel gibt es Komponenten für Benutzeroberflächen, Animationen, Beleuchtung, Audiosysteme, Kameras, Navigation von Charakteren und viele weitere Funktionen.

Mit der Weiterentwicklung deines Projekts wirst du nur die Komponenten hinzufügen, die tatsächlich für eine bestimmte Spielmechanik benötigt werden. Ein Objekt kann nur wenige Komponenten besitzen, während ein anderes eine ganze Reihe davon enthalten kann, die gemeinsam sein Verhalten bestimmen.

Wenn du sehen möchtest, wie verschiedene Komponenten in der Praxis verwendet werden, schau dir Beispiele für Spielmechaniken in anderen Tutorials auf dieser Website an. Dort findest du verschiedene Möglichkeiten, Unity-Komponenten in realen Spielsituationen einzusetzen.