Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir das System, das wir in der vorherigen Lektion begonnen haben, abschließen, indem wir die Schaltflächen erstellen, die mit der Plattformlogik verbunden sind und die Interaktion zwischen beiden Systemen vervollständigen.

Während dieses Prozesses werden wir mehrere wichtige Konzepte im visuellen Logiksystem von Cave erkunden. Du wirst lernen, wie man Kollisionen mithilfe eines Rigid Body erkennt, den Delay-Knoten nutzt, um zu steuern, wann Aktionen über die Zeit stattfinden, die Farbe einer Entity während des Spiels ändert und auch übst, Funktionen zu erstellen und zu verwenden, um deine Logic Bricks organisiert und wiederverwendbar zu halten.

Am Ende dieser Lektion werden wir ein komplettes System haben, bei dem Schaltflächen vom Spieler aktiviert werden können und korrekt mit der zuvor erstellten Plattform kommunizieren.

1. Erstellen der Schaltfläche

Um mit der Erstellung der Schaltfläche zu beginnen, erstelle zuerst eine neue Entity Template.

Benenne die Entity dann entsprechend ihrem Zweck um, konfiguriere das Mesh, das als visuelle Darstellung verwendet wird, und füge die notwendigen physikalischen Komponenten hinzu, damit sie im Spiel korrekt interagieren kann.

Erstelle danach einen neuen Logic Brick und verlinke ihn mit der Schaltflächen-Entity.

Dieser Prozess ähnelt sehr dem, was wir zuvor bei der Erstellung der Plattform gemacht haben, sodass dies auch eine gute Gelegenheit ist, die Konzepte zu üben, die du bereits gelernt hast.

Am Ende dieses Schrittes werden wir die Grundstruktur der Schaltfläche haben, die bereit ist, ihre Aktivierungslogik zu empfangen.

Jetzt gibt es einen sehr wichtigen Schritt: Wir dürfen nicht vergessen, das button-Tag zur Schaltflächen-Entity hinzuzufügen.

Wenn du dich erinnerst, haben wir in der vorherigen Lektion die Plattformlogik bereits vorbereitet, um automatisch zu zählen, wie viele Schaltflächen sich mit diesem genauen Tag in der Szene befinden.

Deshalb muss das Tag erstellt und der Schaltfläche mit demselben Namen zugewiesen werden, der in der Plattformlogik verwendet wurde.

Wenn der Tagname anders ist, selbst wenn es sich um ein kleines Detail handelt, kann die Plattform die Schaltflächen nicht korrekt finden und die Zählung wird nicht wie erwartet funktionieren.

Stelle also sicher, dass du das button-Tag erstellst und es der Schaltflächen-Entity hinzufügst.

Jetzt lass uns auch eine Eigenschaft zur Schaltflächen-Entity hinzufügen.

Wir verwenden das button-Tag, um die Schaltfläche im Kartenbereich zu identifizieren, aber wir werden eine Eigenschaft verwenden, um einen Teil ihres Verhaltens zu steuern.

Erstelle eine neue Eigenschaft namens Active Time, vom Typ Float.

Diese Eigenschaft wird speichern, wie lange die Schaltfläche aktiv bleiben soll, bevor sie automatisch in den inaktiven Zustand zurückkehrt.

Das macht das System flexibler, da jede Schaltfläche eine unterschiedliche Aktivierungszeit haben kann. Zum Beispiel kann eine Schaltfläche 3 Sekunden aktiv bleiben, während eine andere 10 Sekunden aktiv bleibt, ohne die Logic Brick selbst zu ändern.

2. Erstellen der Schaltflächenlogik

Jetzt, da unsere Entity bereit ist, mit dem konfigurierten Tag und der Eigenschaft, lass uns mit dem Erstellen des Schaltflächenverhaltens beginnen.

Der erste Schritt besteht darin, die Kollision zwischen der Schaltflächen-Entity und dem Spieler zu erkennen, damit wir sie aktivieren können, wenn der Spieler sie berührt.

Bevor wir jedoch diese Logik implementieren, müssen wir ein wichtiges Detail beachten: Wir möchten, dass die Schaltfläche nur aktiv ist, wenn sie derzeit inaktiv ist.

Da die Schaltfläche zwei verschiedene Zustände haben wird, aktiv und inaktiv, benötigen wir eine Möglichkeit, um zu speichern, welcher Zustand gerade verwendet wird.

Erstelle dazu eine neue Eigenschaft im Logic Brick der Schaltfläche namens Active Button, vom Typ Boolean.

Diese Eigenschaft wird den aktuellen Zustand der Schaltfläche speichern und anzeigen, ob sie aktiv ist oder nicht. Wir werden diesen Wert in den nächsten Schritten verwenden, um das gesamte Verhalten der Schaltfläche zu steuern.

Jetzt können wir beginnen, die visuelle Logik aufzubauen.

In On Update werden wir ständig überprüfen, ob die Schaltfläche aktiv oder inaktiv ist, indem wir die Active Button-Eigenschaft verwenden, die wir gerade erstellt haben.

Um dies zu tun, erhalte ihren Wert mit Get Active Button und verwende einen If-Knoten, um ihren Zustand zu überprüfen.

Wenn die Bedingung False ist, bedeutet das, dass die Schaltfläche inaktiv ist und aktiviert werden kann. In diesem Fall werden wir die Kollision zwischen der Schaltfläche und dem Spieler erkennen.

Füge dazu einen Collided With-Knoten hinzu.

Dieser Knoten benötigt eine Rigid Body Component, also nimm die Schaltflächen-Entity und erhalte von ihr die Rigid Body Component, die wir bei der Konfiguration der Physik hinzugefügt haben.

Wir müssen dem Knoten auch mitteilen, mit welchem Objekt wir erkennen möchten. Füge dazu dem Charakter ein player-Tag hinzu und übergebe dieses Tag an Collided With.

Auf diese Weise wird die Kollision nur dann als gültig betrachtet, wenn die Schaltfläche mit dem Spieler kollidiert.

Mit dieser Struktur kann die Schaltfläche nur aktiviert werden, wenn sie inaktiv ist und der Spieler tatsächlich mit ihr kollidiert.

Jetzt, da wir beide Pfade definiert haben, lass uns zunächst die Logik implementieren, wenn die Schaltfläche aktiv ist.

Danach werden wir das Verhalten erstellen, das für die Aktivierung verantwortlich ist.

Folge dazu dem True-Zustand des If-Knotens, der überprüft, ob die Schaltfläche aktiv ist oder nicht.

In diesem Fluss verwenden wir die Active Time-Eigenschaft, die wir in der Schaltflächen-Entity erstellt haben, um zu steuern, wie lange die Schaltfläche aktiv bleiben soll.

Zuerst erhältst du die Schaltflächen-Entity und greifst auf ihre Eigenschaften über den Get Properties-Knoten zu.

Verwende dann Get Property, indem du das zuvor zurückgegebene Dictionary verbindest und Active Time als den Key verwendest.

Da diese Eigenschaft ein Float ist, ändere den Ausgabetyp von Get Property auf Float, um sicherzustellen, dass wir diesen Wert im nächsten Teil der Logik korrekt verwenden können.

Jetzt gibt die Ausgabe von Get Property den Wert der Active Time-Eigenschaft zurück, der definiert, wie lange die Schaltfläche aktiv bleiben soll.

Füge als nächstes einen Delay-Knoten hinzu und verwende diesen Wert als Dauer.

Auf diese Weise wird die Wartezeit direkt durch die Entity-Eigenschaft gesteuert, sodass verschiedene Schaltflächen unterschiedliche Aktivierungszeiten haben können, ohne die Logik zu ändern.

Nachdem der Delay abgeschlossen ist, verwende Set Active Button und setze seinen Wert auf False.

Damit kehrt die Schaltfläche automatisch nach der in ihrer Eigenschaft angegebenen Zeit in den inaktiven Zustand zurück.

Sehr gut. Jetzt lass uns den anderen Pfad verfolgen und das Verhalten erstellen, das für die Aktivierung der Schaltfläche verantwortlich ist.

Die Ausgabe des Collided With-Knotens gibt einen Bool-Wert zurück.

Wenn dieser Wert True ist, bedeutet das, dass die Schaltfläche mit dem Spieler kollidiert ist.

In diesem Moment können wir einfach Set Active Button verwenden und seinen Wert auf True setzen.

Damit tritt die Schaltfläche in den aktiven Zustand ein und beginnt automatisch, die zuvor erstellte aktive Logik zu verwenden, die sie für eine bestimmte Zeit aktiv hält und dann wieder deaktiviert.

Damit haben wir einen vollständigen Verhaltenszyklus erstellt:

• wenn der Spieler mit der Schaltfläche kollidiert, wird sie aktiviert
• nach der Zeit, die in Active Time definiert ist, wird sie deaktiviert
• danach kann sie durch eine weitere Kollision erneut aktiviert werden

Auch wenn diese Logik einfach ist, gibt sie der Schaltfläche bereits zwei verschiedene Zustände und wird die Basis für die nächsten Funktionen sein, die wir hinzufügen werden.

Alles funktioniert, aber ein wichtiges Stück fehlt noch.

Obwohl die Logik für die Aktivierung und Deaktivierung der Schaltfläche bereits korrekt funktioniert, weiß unsere Plattform noch nicht, wann eine Schaltfläche aktiviert wurde.

Genau hier wird die Button Count-Eigenschaft, die wir zuvor in der Scene erstellt haben, wichtig.

Wenn du dich erinnerst, haben wir in der Plattformlogik definiert, dass die Plattform nur entfernt werden soll, wenn der Wert dieser Eigenschaft gleich der Gesamtzahl der Schaltflächen in der Karte wird.

Anders ausgedrückt, die Plattform ist bereits bereit zu reagieren, aber bisher ändert keine Schaltfläche diesen Wert.

Was wir jetzt tun müssen, ist es den Schaltflächen zu ermöglichen, die Button Count-Eigenschaft der Szene direkt zu ändern, wann immer sie aktiviert und deaktiviert werden.

Das ist eine großartige Gelegenheit, eine weitere sehr wichtige Funktion von Logic Bricks in Cave zu üben: das Erstellen von Funktionen.

Anstatt dieselbe Logik mehrmals zu wiederholen, werden wir dieses Verhalten in wiederverwendbare Funktionen kapseln, um unser Diagramm organisierter, leichter verständlich und leichter wartbar zu machen.

Da die Button Count-Eigenschaft in der Szene gespeichert ist, müssen wir sie zunächst abrufen.

Um dies zu tun, verwende Get Scene und dann Get Properties.

3. Erstellen der Funktion, die die Szeneneigenschaften steuert

Aus diesen Knoten werden wir eine Funktion erstellen.

Um dies zu tun, wähle die beteiligten Knoten aus, klicke mit der rechten Maustaste und wähle Promote Selection to Function.

Benennen wir die neue Funktion nun um in einen klaren und beschreibenden Namen, der ihren Zweck innerhalb der Projektlogik repräsentiert.

In diesem Fall verwenden wir den Namen Set Scene Property.

Lasst uns nun strukturieren, wie die Funktion Set Scene Property arbeiten wird.

Zuerst übergebe das Eigenschaften-Dictionary der Scene an den Get Property-Knoten. Dieses Dictionary kommt aus dem Get Scene → Get Properties-Fluss.

Ändere dann die Ausgabe von Get Property auf Int, um sicherzustellen, dass wir mit Ganzzahlen arbeiten.

Der Prop Name-Parameter wird als Key in Get Property verwendet, wodurch die Funktion auf die gewünschte Eigenschaft im Eigenschaften-Wörterbuch der Szene zugreifen kann.

Dann werden wir diese Eigenschaft mit Set Property aktualisieren.

Um dies zu tun, holen wir den aktuellen Wert der Eigenschaft, fügen den Value-Eingang hinzu und schreiben das Ergebnis zurück in dieselbe Eigenschaft.

Wir übergeben erneut das Eigenschaften-Wörterbuch der Szene und verwenden Prop Name als Schlüssel.

Dies erstellt eine generische und wiederverwendbare Funktion, die es ermöglicht, die Eigenschaften der Szene auf einfache und organisierte Weise zu modifizieren.

Anstatt nur einen genauen Wert festzulegen, funktioniert diese Funktion wie ein Inkrementierungssystem: Sie addiert den erhaltenen Value zum aktuellen Wert der Eigenschaft der Szene.

Mit dieser fertigen Funktion müssen wir die gesamte Kette von Knoten nicht mehr direkt im Hauptgraphen behalten.

Stattdessen rufen wir die Funktion einfach auf, nachdem wir Active Button auf True gesetzt haben.

Das bedeutet, dass wir in dem Moment, in dem der Knopf aktiviert wird, der Plattformlogik sofort mitteilen, dass ein weiterer Knopf gedrückt wurde.

Dazu übergeben wir den Eigenschaftsnamen Button Count, der die in der Szene gespeicherte Eigenschaft ist, und senden den Wert 1 als Inkrement.

Die Funktion wird automatisch +1 zum aktuellen Wert dieser Eigenschaft hinzufügen.

Auf diese Weise aktualisiert jeder aktivierte Knopf direkt den globalen Fortschritt des Systems, ohne die Logik zu duplizieren.

Es gibt uns auch mehr Flexibilität, um die Eigenschaften der Szene in Zukunft zu ändern, indem wir dieselbe Funktion wiederverwenden.

Um zu zeigen, wie einfach und flexibel dies ist, kehren wir zur Logik des aktiven Knopfes zurück.

Direkt nachdem die Aktivierungszeit endet und wir Active Button auf False gesetzt haben, werden wir Set Scene Property erneut aufrufen.

Der Prop Name-Parameter ist Button Count, wobei wir dieselbe Szene-Eigenschaft verwenden.

Aber diesmal wird der Value-Parameter -1 sein.

Da unsere Funktion den erhaltenen Wert zum aktuellen Wert der Eigenschaft der Szene hinzufügt, führt das Übergeben einer negativen Zahl automatisch dazu, dass 1 vom aktuellen Button Count subtrahiert wird.

Auf diese Weise wird der globale Fortschritt immer dann korrekt aktualisiert, wenn ein Knopf deaktiviert wird, wobei die Plattformlogik mit dem tatsächlichen Zustand der Schaltflächen in der Karte synchronisiert bleibt.

Nun funktioniert unsere Logik wie erwartet.

Es bleibt nur noch ein wichtiges Detail: einen visuellen Effekt zu erstellen, um dem Spieler klar zu machen, wann der Knopf aktiv ist.

Wann immer ein Knopf aktiviert wird, ändern wir direkt seine Farbe mit Tint, um seinen Zustand visuell hervorzuheben.

Bevor wir Active Button auf True setzen, fügen wir eine Sequence hinzu.

Da wir nicht mehr drei Flüsse benötigen, können wir einen der Ausgänge entfernen, indem wir mit der rechten Maustaste klicken und Remove Last Flow Output auswählen, sodass nur noch zwei Pfade übrig bleiben.

Dann holen wir die Kind-Entity des Knopfes, die ButtonMesh heißt, greifen auf ihre Mesh Component zu und passen den Tint-Wert an.

Im Y-Achse stellen wir den Wert auf 25, wodurch der Knopf grün erscheint, wenn er aktiviert wird.

Dies gibt dem Spieler klares visuelles Feedback, wann immer ein Knopf gedrückt wird, und verbessert die Lesbarkeit und Reaktion der Interaktion innerhalb des Spiels.

In ähnlicher Weise werden wir die ursprüngliche Farbe des Knopfes wiederherstellen, wenn er inaktiv wird.

Verwenden Sie dieselbe Logik, aber im Fluss, in dem wir Active Button auf False setzen.

In diesem Moment greifen wir erneut auf die Kind-Entity ButtonMesh zu, holen ihre Mesh Component und passen den Tint-Wert an.

Um zur Standardfarbe zurückzukehren, setzen wir einfach alle Tint-Werte wieder auf 1, wodurch der ursprüngliche visuelle Zustand des Knopfes wiederhergestellt wird.

Auf diese Weise kehrt jeder deaktivierte Knopf auch zu seinem ursprünglichen Aussehen zurück, wodurch dem Spieler klar wird, dass er erneut aktiviert werden kann.

Durch die Auswahl einer button template instance, die wir der Szene hinzugefügt haben, können wir auf ihre Eigenschaften zugreifen und den Wert von Active Time ändern.

Auf diese Weise kann jeder Knopf eine unterschiedliche Aktivierungsdauer haben und unabhängig arbeiten.

Dies gibt uns mehr Flexibilität, um vielfältige Herausforderungen im Level zu erstellen, da jeder Knopf individuell konfiguriert werden kann, ohne die Hauptlogik des Systems zu ändern.

Damit können wir beliebig viele Knöpfe zur Karte hinzufügen, jeder mit einer unterschiedlichen Aktivierungszeit und unabhängigem Verhalten.

Die Plattform folgt automatisch dieser Konfiguration, ohne manuelle Anpassungen zu erfordern, da das Zählen zur Laufzeit erfolgt.

Das System bleibt auch mit dem tatsächlichen Zustand des Spiels synchronisiert. Wenn Knöpfe aktiviert und deaktiviert werden, wird der globale Wert aktualisiert, und die Plattform reagiert, wenn die Bedingung erfüllt ist, indem sie im richtigen Moment aus der Szene entfernt wird.

Neben der Logik haben wir dem Spieler wichtiges visuelles Feedback gegeben.

Die Änderung der Knopf-Farbe, wenn er aktiviert wird, und das Wiederherstellen seines ursprünglichen Aussehens, wenn er deaktiviert wird, macht das System viel klarer und intuitiver. Der Spieler kann visuell verstehen, welche Knöpfe aktiv sind und welche noch Aufmerksamkeit benötigen.

Am Ende haben wir ein modulares und skalierbares System geschaffen, das Kommunikation zwischen Entities, zentrale Kontrolle durch die Szene und direktes visuelles Feedback in der Spielwelt kombiniert.

Dieser gleiche Aufbau kann problemlos für Türen, Plattformen, Aufzüge, Rätsel, Fallen, zeitlich begrenzte Herausforderungen und viele andere interaktive Ereignisse erweitert werden.