Unity Tutorial deutsch Teil 10

Unity Tutorial deutsch – Scripting in Unity mit C# (10/10)

Gefällt Dir der Artikel? Dann teile ihn doch, um diese Informationen auch anderen zugänglich zu machen!

Seiteninhalt

Die Welt der Spiele- und Anwendungsentwicklung hat sich enorm weiterentwickelt. Die Erstellung von Anwendungen geht weit über das Einfügen von Grafiken und Animationen hinaus. Interaktivität, komplexe Funktionen und Spiellogik sind von großer Bedeutung, um ein fesselndes Erlebnis zu bieten. Dabei spielt das Scripting in Unity eine entscheidende Rolle.

In diesem Teil des Unity Tutorials erkläre ich dir Schritt für Schritt die Grundlagen des C#-Scriptings in Unity. Wir starten damit, wie du Skripte in Unity erstellst und wie du sie mit GameObjects verknüpfen kannst. Zudem blicken wir auf die verschiedenen Methoden, um Spielelemente zu steuern.

Damit bildest du eine solide Grundlage für das C#-Scripting in Unity. Der Artikel ist sowohl für Einsteiger als auch für fortgeschrittene Entwickler geeignet. Wenn du bereit bist, die spannende Welt des Unity-Scriptings zu erkunden, dann lass uns gleich loslegen!

Warum Scripting in Unity?

Unity ist eine flexible und leistungsstarke Entwicklungsumgebung, mit der du Spiele und Anwendungen entwickeln kannst. Das können sowohl einfache 2D-Puzzle, komplexe Open-World-Spiele als auch VR- und AR-Anwendungen sein. Doch all diese Projekte haben eines gemeinsam: die Notwendigkeit, Interaktivität und Funktionalität zu integrieren.

Dabei kommt das Scripting in Unity ins Spiel. Unity verwendet C# als Hauptsprache für die Entwicklung von Skripten. Darüber besteht die Möglichkeit, die Verhaltensweise von GameObjects, die Steuerung von Charakteren, die Kollisionserkennung, die Animationen und vieles mehr zu definieren. Scripting ist die Grundlage, auf der du deine kreativen Ideen in die Realität umsetzen kannst.

Warum also Scripting in Unity? Ganz einfach, weil es die Erstellung von individuellen Funktionen und die Anpassung an die spezifischen Anforderungen eines Projektes ermöglicht. Kurz gesagt, das Scripting ist der Schlüssel zur Umsetzung deiner Ideen und zur Gestaltung von Nutzererlebnissen. Lass uns also gleich darauf schauen, wie du Skripte in Unity erstellen kannst.

Scripting in Unity mit C#

Das Erstellen von Skripten in Unity ist der erste Schritt auf dem Weg zu interaktiven Spielen und Anwendungen. C# ist die bevorzugte Programmiersprache von Unity. Und sie bietet eine leistungsstarke Plattform, um die Funktionalität und das Verhalten deiner Projekte zu definieren.

Hinweis: Mit dem ultimativen Unity Cheat Sheet erhältst du einen detaillierten Überblick über Tipps & Tricks mit dem Umgang von Unity. Sichere dir jetzt das Cheat Sheet, um deine Anwendungen noch einfacher und effektiver erstellen zu können!

Das Erstellen von Skripten in Unity

Der Prozess zur Erstellung von Skripten beginnt in der Unity-Entwicklungsumgebung. Hier kannst du eine neue C#-Datei erstellen, die als Skript für dein Projekt dient. Um eine gute Struktur und Organisation umzusetzen, bietet es sich an, einen neuen Ordner Scripts in deinem Projekt zu erstellen. Im Anschluss kannst du über einen Rechtsklick in diesem Ordner zu Create → C# Script navigieren. Und vergiss nicht dem Skript einen passenden Namen zu geben. Der Name sollte einen Hinweis auf die Funktion des Skripts geben, um die spätere Verwendung zu erleichtern.

Unity Scripts Ordner

Nachdem du dein erstes Skript erstellt hast, kannst du es in der integrierten Entwicklungsumgebung (IDE) von Unity öffnen. Standardmäßig wird MonoDevelop oder Visual Studio verwendet. Je nachdem, welches Tool du installiert hast. Hier erhältst du eine Übersicht, wie du die IDE in Unity ändern kannst.

Unity bietet eine Vielzahl von vordefinierten Funktionen und Klassen, die du in deinen Skripten verwenden kannst. Diese Funktionen decken verschiedene Aspekte ab, wie die Steuerung von Bewegungen, die Handhabung von Kollisionen, die Animation und vieles mehr. Du kannst auch eigene Funktionen erstellen und sie in deinen Skripten aufrufen, um individuelles Verhalten zu erzeugen. Lass uns aber einmal darauf blicken, wie du Skripte mit GameObjects verknüpfen kannst.

Verknüpfung von Skripten mit GameObjects

Die Verknüpfung von Skripten mit GameObjects ist ein zentraler Aspekt in Unity. Damit kann das Verhalten von GameObjects in der Szene gesteuert werden. Ein GameObject ist eine virtuelle Entität in der Szene. Es kann alles darstellen, von Charakteren über Objekte bis hin zu Lichtquellen und Kameraansichten. Die GameObjects sind die Bausteine deiner Szene. Und Skripte sind die Anweisungen, die diesen Bausteinen Leben einhauchen.

Move Object Skript in GameObject

Um ein Skript mit einem GameObject zu verknüpfen, musst du es zunächst in dein Unity-Projekt importieren. Du kannst aber auch ein neues Skript erstellen.

Sobald du ein geeignetes Skript hast, kannst du es einem GameObject zuweisen. Wähle dazu das entsprechende GameObject in der Hierarchie aus. Der Inspector zeigt nun die Eigenschaften und Komponenten des GameObjects an. Ziehe das Skript einfach per Drag-and-Drop aus dem Projektfenster in den Inspector des GameObjects. Du kannst auch auf Add Component klicken, nach dem Skript suchen und es hinzufügen.

Im Inspector kannst du die Parameter und Eigenschaften des Skripts anpassen, die speziell für dieses GameObject relevant sind. Diese Einstellungen variieren, je nachdem, wie du das Skript geschrieben hast und welche Funktionen es bietet.

Die Verknüpfung eines Skripts mit dem GameObject ermöglicht den Zugriff auf das GameObject und seine Components. Du kannst jetzt Funktionen im Skript aufrufen, um das Verhalten des GameObjects zu ändern, seine Position zu aktualisieren, Animationen auszulösen und vieles mehr. Wie das genau geht, sehen wir uns jetzt an.

GameObject- und Transform-System

Jedes GameObject besitzt eine Vielzahl von Komponenten, die sein Verhalten und seine Eigenschaften definieren. Das Transform-System ist eine dieser Komponenten und sie beinhaltet Informationen zur Position, Rotation und Skalierung des GameObjects.

Nachdem das Skript als Komponente zu einem GameObject zugewiesen wurde, kannst du auf weitere Komponenten per Scripting zugreifen. Die GetComponent-Methode ermöglicht es dir, eine Referenz auf eine Komponente zu legen, die an das GameObject angehängt ist. Damit kannst du das Verhalten und die Eigenschaften von GameObjects durch Skripte steuern und anpassen.

Sehen wir uns dazu ein kleines Beispiel an. Die Transform-Component enthält die Position, Rotation und Skalierung eines GameObjects. Soll die Position über ein Skript verändert werden, so lässt sich das über das folgende Skript umsetzen.

				
					using UnityEngine;

public class MoveObject : MonoBehaviour
{
    private Transform objectTransform;

    private void Start()
    {
        // Initialisiere die Transform-Referenz
        objectTransform = GetComponent<Transform>();
    }

    private void Update()
    {
        // Setze die neue Position des GameObjects
        Vector3 newPosition = new Vector3(5f, 4f, 5f);

        // Neue Zielposition anwenden
        objectTransform.position = newPosition;
    }
}
				
			

In der Start-Methode wird die Referenz über GetComponent<Transform>() auf die Transform-Component gelegt. Die Variable objectTransform besitzt nun die Informationen zur Position, Rotation und Skalierung des GameObjects, an dem das Skript hängt. In der Update-Methode wird zunächst eine neue Position festgelegt und anschließend über objectTransform.position gesetzt.

Das Transform-System ist nur eine von vielen möglichen Komponenten. Du kannst auf andere Komponenten zugreifen, indem du ähnliche Techniken verwendest. Zum Beispiel könntest du auf einen Collider zugreifen, um Kollisionen zu erkennen. Oder auf ein Skript, um bestimmte Aktionen auszulösen. Die Methode GetComponent<BoxCollider>() lässt sich verwenden, um auf eine Komponente vom Typ BoxCollider zuzugreifen. Falls das GameObject über keine BoxCollider-Komponente verfügt, wird null zurückgegeben.

Verwendung von Feldern und Eigenschaften

In Unity können C#-Skripte Eigenschaften und Felder verwenden, um Daten und das Verhalten zu organisieren und zu steuern. Lass uns einen kurzen Blick auf die Verwendung von Eigenschaften und Feldern in Unity werfen.

1. Felder (Fields):

Felder sind Variablen, die in einem C#-Skript deklariert werden, um Daten zu speichern. Sie können als öffentlich (public), privat (private) oder geschützt (protected) deklariert werden.

Sie werden häufig verwendet, um Daten wie Positionen, Geschwindigkeiten, Punktzahlen und mehr zu speichern. Beispielsweise könnte ein Feld private Vector3 position; die Position eines GameObjects speichern. Im nachfolgenden Skript wird die Position eines GameObjects beim Drücken der Leertaste verändert.

				
					using UnityEngine;

public class FieldExample : MonoBehaviour
{
    // Ein Feld, um die Position des GameObjects zu speichern
    private Vector3 position;

    private void Start()
    {
        // Die Anfangsposition des GameObjects festlegen
        position = transform.position;
    }

    private void Update()
    {
        // Prüfen, ob die Leertaste gedrückt wurde
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Die Position des GameObjects um 1 Einheit in Richtung der X-Achse erhöhen
            position.x += 1f;

            // Die Position des GameObjects aktualisieren
            transform.position = position;
        }
    }
}
				
			

Im Skript wird ein private Field position vom Typ Vector3 deklariert. Dieses Feld wird verwendet, um die Position des GameObjects zu speichern. In der Start()-Methode wird die Anfangsposition des GameObjects in der position-Variable gespeichert, indem transform.position verwendet wird, um die aktuelle Position des GameObjects abzurufen.

Die Update()-Methode wird in jedem Frame aufgerufen. Hier wird überprüft, ob die Leertaste auf der Tastatur gedrückt wurde. Wenn die Leertaste gedrückt wurde, wird die Position des GameObjects um 1 Einheit in Richtung der x-Achse erhöht. Und zu guter Letzt wird die Position auf die aktualisierte position-Variable gesetzt, um die tatsächliche Verschiebung auszuführen.

2. Eigenschaften (Properties):

Eigenschaften wiederum sind spezielle Methoden, die den Zugriff auf private Felder kontrollieren. Sie bieten eine Möglichkeit, den Lese- (get) und Schreibzugriff (set) auf Daten zu steuern und Berechnungen durchzuführen, wenn auf diese Daten zugegriffen wird.

				
					using UnityEngine;

public class PropertyExample : MonoBehaviour
{
    private Transform _transform;

    // Eine Eigenschaft (Property) für den Zugriff auf die Position des GameObjects
    public Vector3 Position
    {
        get { return _transform.position; }
        set { _transform.position = value; }
    }

    private void Start()
    {
        // Die Transform-Komponente des GameObjects abrufen
        _transform = transform;

        // Die Anfangsposition des GameObjects über die Eigenschaft festlegen
        Position = new Vector3(2f, 0f, 0f);
    }

    private void Update()
    {
        // Prüfen, ob die Leertaste gedrückt wurde
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Die Position über die Eigenschaft ändern
            Position += Vector3.up; // Erhöhe die Y-Position um 1 Einheit
        }
    }
}
				
			

In diesem Skript wurde eine Eigenschaft Position erstellt, die den Zugriff auf die Position des GameObjects ermöglicht. Der get-Teil der Eigenschaft gibt die Position zurück und der set-Teil ermöglicht das Festlegen der Position. Über die Start()-Methode wird die Transform-Komponente des GameObjects abgerufen und über die Position-Eigenschaft die Anfangsposition festgelegt. In der Update()-Methode wird zunächst geprüft, ob die Leertaste gedrückt wurde. Abhängig davon wird die Position des GameObjects über die Position-Eigenschaft verändert.

Ein weiteres Beispiel kann die Eigenschaft rotation der Transform-Component sein. Damit lässt sich die Rotation auslesen und steuern. Sehen wir uns auch dazu ein einfaches Skript an. Die rotation Eigenschaft wird bereits über eine API von Unity bereitgestellt.

				
					using UnityEngine;

public class PropertyExample: MonoBehaviour
{
    private Transform objectTransform;

    private void Start()
    {
        // Initialisiere die Transform-Referenz
        objectTransform = GetComponent<Transform>();
    }

    private void Update()
    {
        // Setze die neue Rotation des GameObjects als Quaternion
        Quaternion newRotation = Quaternion.Euler(0f, 45f, 0f);

        // Neue Zielrotation anwenden
        objectTransform.rotation = newRotation;
    }
}
				
			

Hierbei wird in der Start-Methode die Referenz auf die Transform-Component gelegt. In der Update-Methode wird die Eigenschaft rotation verwendet, um die neue Rotation des GameObjects festzulegen. Hier findest du übrigens alle Eigenschaften der Transform-Component und aller weiterer Komponenten.

Insgesamt bieten Felder und Eigenschaften in Unity eine flexible Möglichkeit, Daten zu organisieren, auf GameObject-Komponenten zuzugreifen und die Interaktion zwischen Skripten und Spielobjekten zu steuern.

Die wichtigsten Unity-Methoden

Unity-Methoden sind wichtig für die Erstellung von Skripten. Damit können der Lebenszyklus von GameObjects und die Reihenfolge, in der bestimmte Aktionen ausgeführt werden, gesteuert werden. Hier sind einige der wichtigsten Unity-Methoden.

  1. Awake(): Die Methode Awake() wird aufgerufen, wenn ein GameObject zum ersten Mal initialisiert wird. Das ist oft der Fall, um Referenzen zu initialisieren oder Setup-Aufgaben durchzuführen, die nur einmal ausgeführt werden müssen.
  2. Start(): Diese Methode wird nach Awake() aufgerufen und dient dazu, Initialisierungsaufgaben auszuführen, die sich auf andere GameObjects oder Komponenten beziehen. Hier können beispielsweise Verknüpfungen zu anderen GameObjects hergestellt oder grundlegende Einstellungen vorgenommen werden.
  3. Update(): Update() ist eine der wichtigsten Methoden in Unity. Sie wird in jedem Frame aufgerufen, um kontinuierlich laufende Logik oder Berechnungen zu aktualisieren. Beispiele hierfür sind die Bewegung eines Charakters oder die Aktualisierung eines Countdown-Timers.
  4. FixedUpdate(): Im Gegensatz zu Update() wird FixedUpdate() in festen Zeitschritten aufgerufen, wenn es um physikalische Berechnungen geht. So zum Beispiel die Bewegung eines Rigidbody-Körpers.
  5. LateUpdate(): Diese Methode wird nach Update() aufgerufen und ist hilfreich, um sicherzustellen, dass andere GameObjects bereits die Update()-Methode ausgeführt haben. Sie wird oft für die Verfolgung von GameObjects verwendet.
  6. OnDestroy(): OnDestroy() wird aufgerufen, um ein GameObject zu zerstören. Das ist der Fall, um Ressourcen freizugeben.
  7. OnCollisionEnter() und OnCollisionExit(): Diese Methoden werden aufgerufen, wenn ein GameObject mit einem anderen GameObject kollidiert oder die Kollision beendet. Sie sind wichtig, um auf Kollisionen zu reagieren und entsprechende Aktionen auszuführen.
  8. OnTriggerEnter() und OnTriggerExit(): Ähnlich wie bei den Kollisionsmethoden, werden diese Methoden aufgerufen, wenn ein GameObject einen Trigger auslöst oder ihn verlässt. Trigger werden oft für Interaktionen verwendet, bei denen keine physikalischen Kollisionen auftreten.

Diese Unity-Methoden sind der Schlüssel zur Kontrolle und Steuerung von GameObjects. Sie bieten die Möglichkeit, das Verhalten von GameObjects in verschiedenen Situationen und während des Lebenszyklus des Spiels anzupassen und zu steuern.

Hinweis: Du möchtest eigene 2D/3D Spiele und Anwendungen erstellen? Dann teste jetzt nobreakpoints Pro. Dort findest du in verschiedenen Online-Kursen und Workshops das nötige Wissen, um deine Ideen in die Wirklichkeit umzusetzen.

85%

Rabatt

Keine Extra-Kosten.
Jederzeit kündbar.

Bist du bereit atemberaubende Spiele und 3D Anwendungen zu erstellen?

*Nach 1 Monat wird die Mitgliedschaft automatisch auf monatlicher Basis zum Premium-Preis von 47€ verlängert, bis du kündigst. Angebot kann nur einmal pro Nutzer beansprucht werden.

Gefällt Dir der Artikel? Dann teile ihn doch, um diese Informationen auch anderen zugänglich zu machen!