Cave: Einstiegshandbuch

Im vorherigen Kapitel hast du gelernt, wie Python während des Spielbetriebs Entitäten steuern kann. Aber Python in Cave ist nicht auf das laufende Spiel beschränkt. Du kannst es auch nutzen, um Editor-Tools zu erstellen, die dir helfen, dein Spiel schneller zu erstellen.

Das ist besonders nützlich, weil viele Projekte repetitive Aufgaben haben. Vielleicht platzierst du häufig Gegner, erstellst Checkpoints, organisierst Ordner, testest Werte oder überprüfst Szenendaten. Anstatt alles jedes Mal von Hand zu machen, kannst du kleine Tools erstellen, die Teile deines Workflows automatisieren. Du kannst sogar fortgeschrittenere Editoren erstellen, um prozedural generierte Levels, prozedurale Gebäude und viel mehr zu ermöglichen.

In dieser Lektion wirst du lernen:

• Den Unterschied zwischen Gameplay-Skripts und Editor-Skripts.
• Wofür ein Editor-Tool verwendet werden kann.
• Wie ein Editor-Tab-Tool strukturiert ist.
• Warum #editoronly wichtig ist.
• Wann es sich lohnt, ein benutzerdefiniertes Tool zu erstellen.

Du musst nicht sofort Tools erstellen, wenn du anfängst, aber es ist gut zu wissen, dass dieses System existiert. Es ist eines dieser Funktionen, die wertvoller werden, je mehr dein Projekt wächst.

Gameplay-Skripts vs. Editor-Tools

Kurz gesagt:

• Gameplay-Skripts laufen, während das Spiel gespielt wird.
• Editor-Tools laufen im Editor, um dir an deinem Projekt zu helfen.

Ein Beispiel: Ein Türöffnungs-Skript ist Gameplay-Logik, weil der Spieler es erleben sollte, während er das Spiel spielt. Ein Tool, das zehn Fackeln entlang eines Korridors platziert, ist Editor-Logik, weil es dir hilft, das Level zu erstellen, aber nicht im exportierten Spiel existieren muss.

Warum Editor-Tools nützlich sind

Zunächst mögen benutzerdefinierte Tools wie etwas erscheinen, das nur große Teams benötigen.

Aber selbst Solo-Entwickler können von kleinen Tools profitieren, da sie wiederholte manuelle Arbeit reduzieren. Wenn du dieselbe Aufgabe viele Male erledigst, kann ein einfaches Editor-Skript das Projekt viel schneller wirken lassen.

Editor-Tools können bei Dingen helfen wie:

• Gruppen von Entitäten zu platzieren.
• Überprüfen, ob erforderliche Komponenten fehlen.
• Gemeinsame Szeneneinrichtungen zu erstellen.
• Debug-Informationen auszudrucken.
• Werte zu testen, ohne den Spielmodus zu betreten.
• Designern zu helfen, Gameplay-Daten anzupassen.

Stell dir zum Beispiel vor, du baust ein Third-Person-Spiel mit vielen Gegnerlagern. Anstatt die gleiche Ordnerstruktur jedes Mal manuell zu erstellen, könntest du ein Tool erstellen, das automatisch eine Enemy Group, ein paar Spawn-Punkte und ein Triggergebiet hinzufügt.

Editor-Only-Skripte

Editor-Skripte beginnen normalerweise mit dieser Zeile:

#editoronly

Das sagt Cave, dass das Skript für die Verwendung im Editor gedacht ist.

Das ist wichtig, weil Editor-Tools APIs oder Verhaltensweisen verwenden können, die nur im Editor Sinn machen. Normalerweise möchtest du nicht, dass ein Level-Design-Helfer oder ein Debug-Panel Teil deines endgültigen Spielablaufs ist.

Dies ist auch wichtig, um Cave zu sagen, welche Skripte beim Spielstart ausgeführt und welche ignoriert werden sollen. Standardmäßig führt es jedes Skript aus, also wenn du möchtest, dass eines ignoriert wird, sollte es diesen Kommentar als erste Zeile enthalten.

Wenn du also ein Skript erstellst, das nur dazu dient, dir zu helfen, im Cave Editor zu arbeiten, mache es editor-only.

Editor-Tab-Tools

Eine häufige Methode zur Erstellung eines Tools ist mit einem Editor-Tab.

Ein Editor-Tab ist ein benutzerdefiniertes Panel, das im Cave Editor erscheint. Es hat eine draw()-Methode, und Cave ruft diese Methode auf, während der Tab sichtbar ist, damit das Tool Schaltflächen, Text, Eigenschaften und andere Steuerungen zeichnen kann.

Ein sehr kleiner Editor-Tab sieht so aus:

#editoronly
import cave

class ExampleTab(cave.ui.DebugTab):
    def __init__(self):
        super().__init__()
        self.counter = 0

    def draw(self):
        cave.ui.text("Dies ist ein Beispiel-Tool.")
        cave.ui.separator()

        self.counter = cave.ui.prop("Zähler", self.counter)

        if cave.ui.buttonDark("Zähler um +1 erhöhen"):
            self.counter += 1
            print("Zähler um +1 erhöht")

Das ist auch der Standardcode, wenn du einen Editor-Tab hinzufügst. Wenn du klickst, um ihn im Eigenschaften-Tab zu öffnen und dann zum Editor-Tooling-Tab gehst, wirst du sehen, dass die Beispiel-Tab-Klasse als Debug-Tab erscheint. Dann musst du nur den Tab registrieren oder neu laden, und er wird für dich in der Benutzeroberfläche verfügbar sein:

Dieses Beispiel ist einfach, zeigt aber bereits die grundlegende Idee:

• cave.ui.DebugTab erstellt einen benutzerdefinierten Editor-Tab.
• draw() definiert, was der Tab anzeigt.
• cave.ui.text() zeichnet Text.
• cave.ui.prop() zeichnet eine bearbeitbare Eigenschaft.
• cave.ui.buttonDark() erstellt einen Knopf.
• print() kann verwendet werden, um Informationen an die Konsole zu senden.

So einfach ist es, benutzerdefinierte Tools für Cave Editor zu erstellen. Du kannst diese gleiche Struktur später verwenden, um echte Tools zu erstellen.

Was die draw()-Methode bedeutet

Die draw()-Methode ist nicht wie start() in einer Gameplay-Komponente.

Sie wird wiederholt aufgerufen, während das Tool sichtbar ist, weil die Editor-Benutzeroberfläche gezeichnet und aktualisiert werden muss. Das bedeutet, der Code innerhalb von draw() sollte das aktuelle Interface des Tools beschreiben.

Zum Beispiel:

def draw(self):
    cave.ui.text("Level Helfer:")

    if cave.ui.buttonDark("Feindgruppe erstellen"):
        print("Feindgruppe angeklickt")

Die Schaltfläche wird jedes Mal gezeichnet, wenn der Tab aktualisiert wird, aber der Code innerhalb des if wird nur ausgeführt, wenn der Benutzer auf die Schaltfläche klickt.

Dieses Muster ist sehr häufig in Editor-Tools.

Eine praktische Tool-Idee

Angenommen, du baust ein Level und benötigst häufig die gleichen grundlegenden Ordner:

• Umgebung
• Gegner
• Gameplay-Trigger
• Beleuchtung
• Audio
• Debug-Helfer

Du könntest ein Editor-Tool mit einem Knopf namens Levelordner erstellen erstellen. Wenn du darauf klickst, könnte es diese Ordnerentitäten in der aktuellen Szene erstellen. Denk daran: Ein Ordner im Szenenbaum ist nur eine Entität ohne angehängte Komponenten.

Das mag klein erscheinen, aber kleine Tools wie dieses erleichtern es, große Projekte organisiert zu halten. Sie helfen dir auch, deine eigenen Projektkonventionen einzuhalten, ohne jeden Schritt manuell erinnern zu müssen.

Editor-Komponenten

Manchmal möchtest du Gameplay-Logik mit Editor-Logik mischen. Zum Beispiel möchtest du vielleicht eine Komponente an eine Entität anhängen, die auch Editor-Logik ausführt, um zum Beispiel Debug-Informationen oder eine Debug-Kugel anzuzeigen, die den Bewegung- oder Angriffsbereich eines Gegners anzeigt. In diesem Fall verwendest du anstelle von cave.Component cave.EditorComponent.

Dies ist nützlich, wenn eine Entität ein spezielles Editor-Verhalten benötigt, aber dieses Verhalten nicht Teil des tatsächlichen Spiels sein sollte.

Zum Beispiel:

• Ein Spawn-Punkt könnte Hilfsinformationen im Editor zeichnen.
• Ein Trigger-Volumen könnte Debug-Steuerelemente anzeigen.
• Ein Level-Marker könnte überprüfen, ob er korrekt konfiguriert ist.

Die wichtige Idee ist, dass Editor-Skripte für den Workflow rund um die Erstellung des Spiels gedacht sind. Gameplay-Skripte sind für das eigentliche Spiel.

WICHTIG: In diesem Fall ist das Verhalten ein bisschen anders als bei einer regulären Komponente, denn da es sich um eine Editor-Komponente handelt, wird sie eine Editor-Aktualisierungsmethode haben, die jedes Frame aufgerufen wird, während der Editor läuft und das Spiel nicht. Aber und das ist der wichtigste Unterschied, wird diese Komponente tatsächlich registriert, initialisiert und mit der Entität selbst gestartet, unabhängig davon, ob sie sich im Spielmodus befindet oder nicht. Wenn du also eine Logik in der Startmethode dieser Komponente platzierst, wird sie selbst außerhalb des Spielmodus aufgerufen.

Das kann potenziell gefährlich sein, zum Beispiel: Wenn du eine Logik in der Startmethode einer Editor-Komponente platzierst, die alle Entitäten in der Szene abruft und löscht, wird dein Spiel auf destruktive Weise vollständig im Editor gelöscht (nicht rückgängig machen). Das ist kein Fehler, es ist kein Bug, so funktioniert es gemäß dem Design. Sei dir dessen bewusst.

Wenn du eine sicherere Methode dafür haben möchtest, kannst du die Python-Code-Komponente verwenden, denn sie hat eine Editor-Aktualisierungsmethode, und das Schreiben dieser Editor-Aktualisierung wird nicht stören, ob die Start- und Endaktualisierungen im Editor aufgerufen werden oder nicht (das werden sie nicht). Schau dir den Feind im ursprünglichen Projekt an, das Cave erstellt, denn es verwendet die Python-Code-Komponente, um eine Debug-Kugel um die Gegner zu zeichnen, die den Radius anzeigt, in dem sie sich bewegen können. Es ist eine gute Möglichkeit, mehr darüber zu lernen.

Wann solltest du ein Tool erstellen?

Erstelle kein benutzerdefiniertes Tool für jede kleine Aktion.

Baue ein Tool, wenn es ein reales Workflow-Problem löst, wie zum Beispiel:

• Du wiederholst die gleiche Aufgabe viele Male.
• Ein Setup ist leicht zu vergessen.
• Eine Szene benötigt Validierung.
• Ein Designer benötigt eine klarere Benutzeroberfläche zum Ändern von Werten.
• Ein Prototyp benötigt schnelle Debug-Tasten.

Für einen Anfänger ist es besser, zunächst das Spielobjekt manuell zu erstellen. Sobald du die Schritte verstehst, kannst du den langweiligen Teil automatisieren.

Was du dir merken solltest

Python in Cave kann sowohl für Gameplay als auch für Editor-Tools verwendet werden.

Gameplay-Skripte steuern, was passiert, während das Spiel läuft. Editor-Skripte helfen dir, das Projekt innerhalb des Cave Editors zu erstellen, zu inspizieren, zu debuggen oder zu organisieren.

Du benötigst keine Editor-Tools, um dein erstes Spiel zu erstellen, aber sie sind mächtig, wenn dein Projekt zu wachsen beginnt. Ein kleines Tool, das heute fünf Minuten spart, kann später Stunden sparen.