Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir eine neue Möglichkeit erkunden, um Ereignisse im Spiel zu aktivieren.

Anstatt sammelbare Gegenstände zu verwenden, werden wir ein System basierend auf Schaltflächen erstellen, die vom Spieler aktiviert werden müssen, um eine Plattform freizugeben oder eine andere Aktion auszuführen.

Dieses Beispiel ist etwas fortgeschrittener und wird uns helfen, mehrere Konzepte zu üben, die wir bisher gelernt haben, wie Kommunikation zwischen Entities, Verwendung von Eigenschaften, Tags und Organisation der visuellen Logik.

Im ersten Teil werden wir die Logik der Plattform erstellen und lernen, wie man Eigenschaften verwendet, die direkt in der Szene gespeichert sind.

Dies ist sehr nützlich, wenn Sie Informationen zwischen verschiedenen Entities im Spiel teilen müssen. Anstatt Daten nur in einer Entity zu speichern, kann die Szene als zentraler Ort fungieren, an dem mehrere Systeme dieselben Informationen lesen und ändern können.

In diesem Beispiel werden die Schaltflächen einen Wert erhöhen, der in der Szene gespeichert ist, und die Plattform wird diesen Wert lesen, um zu wissen, wann alle Schaltflächen aktiviert wurden.

1. Erstellen der Plattform

Zuerst, so wie wir es in den vorherigen Lektionen gelernt haben, lassen Sie uns eine neue Entity Template für unsere Plattform erstellen.

Konfigurieren Sie das Mesh, das als visuelle Darstellung der Plattform verwendet wird, gemäß dem Stil und den Anforderungen Ihres Projekts.

Dann fügen Sie die Kollision hinzu und konfigurieren Sie sie, damit der Spieler korrekt mit der Plattform in der Szene interagieren kann.

In diesem Beispiel benötigt die Plattform keine spezifischen Tags oder Eigenschaften, da die Aktivierungslogik von den anderen Elementen des Systems kontrolliert wird, die wir in den nächsten Schritten erstellen werden.

2. Erstellen der Logik der Plattform

Jetzt lassen Sie uns einen neuen Logic Brick erstellen und ihn mit unserer Plattform-Entity verknüpfen.

Innerhalb dieses Logic Brick werden wir die Logik entwickeln, die für das Verhalten der Plattform und ihre Interaktion mit dem Rest des Systems verantwortlich ist.

Sie können diesen Logic Brick direkt in die Entity einfügen oder ihn über die Plattform-Template konfigurieren, so wie wir es in den vorherigen Lektionen gemacht haben.

Da diese Plattform wahrscheinlich etwas ist, das Sie wiederverwenden möchten, ist es normalerweise eine gute Wahl, sie über die Template zu konfigurieren.

Zuerst lassen Sie uns zwei Eigenschaften erstellen.

Die erste wird zum Plattform-Logic Brick hinzugefügt. Es sollte eine Int-Eigenschaft namens Buttons sein.

Diese Eigenschaft wird später die Gesamtzahl der auf der Karte verfügbaren Schaltflächen speichern.

Mit diesem Wert kann die Plattform erfahren, wie viele Schaltflächen existieren und diese Zahl mit der zu vergleichen, wie viele Schaltflächen bereits vom Spieler aktiviert wurden.

Die zweite Eigenschaft wird direkt in der Szene erstellt, sodass wir leicht von verschiedenen Teilen der Spiel-Logik darauf zugreifen können.

Um dies zu tun, klicken Sie im 3D View auf den Himmel/Hintergrund der Szene, um die Szene selbst auszuwählen.

Dann sollten Sie im Eigenschaften-Panel sehen, dass der ausgewählte Objekttyp Szene ist, zusammen mit dem Namen der aktuellen Szene.

Diese Eigenschaft wird später verwendet, um globale Informationen zu speichern und zu teilen.

Klicken Sie auf die Registerkarte Eigenschaften der Szene und erstellen Sie eine neue Eigenschaft namens Button Count.

Diese Eigenschaft wird mehr Sinn machen, wenn wir die Schaltflächen erstellen, da die Schaltflächen dafür verantwortlich sein werden, ihren Wert zu ändern, wann immer sie vom Spieler aktiviert werden.

Dennoch können wir sie jetzt schon erstellen, da sie auch bald von der Logik der Plattform verwendet wird.

Kurz gesagt:

• Buttons gehört zur Plattform und speichert, wie viele Schaltflächen existieren.
• Button Count gehört zur Szene und speichert, wie viele Schaltflächen bereits aktiviert wurden.

Jetzt, da wir die beiden Eigenschaften erstellt haben, eine in der Szene und eine im Plattform-Logic Brick, lassen Sie uns beginnen, die Logik der Plattform zu entwickeln.

Gehen Sie zurück zum Graph.

Die erste Information, die wir benötigen, ist die Gesamtzahl der Schaltflächen, die in der Karte existieren.

Da dieser Wert nur einmal beim Start des Spiels berechnet werden muss, werden wir diese Logik über On Start ausführen.

Zuerst holen Sie sich die Szene und verwenden Sie den Knoten, der alle Entities mit dem Tag button sucht.

Wir haben die Schaltflächen noch nicht erstellt, aber wir können bereits diese Logik vorbereiten, da wir später diesem Tag hinzufügen werden.

Verwenden Sie dann den Size-Knoten, um die Anzahl der in dieser Liste gefundenen Entities zu erhalten.

Dieser Wert steht für die Gesamtzahl der Schaltflächen, die in der Szene vorhanden sind.

Speichern Sie schließlich dieses Ergebnis in der Buttons-Eigenschaft der Plattform mit Set Buttons.

Jetzt lassen Sie uns die Logik erstellen, die dafür verantwortlich ist, die Plattformaktion zu aktivieren, nachdem alle Schaltflächen gedrückt wurden.

In diesem Beispiel werden wir die Plattform aus der Szene entfernen, aber Sie können diese Logik anpassen, um alles zu tun, was Sie möchten, z. B. die Plattform zu bewegen, eine Animation abzuspielen, einen Durchgang zu öffnen, ein anderes Objekt zu aktivieren oder eine Zwischensequenz auszulösen.

Für diese Überprüfung verwenden wir On Update, um sicherzustellen, dass die Bedingung kontinuierlich überprüft wird, während das Spiel läuft.

Zuerst holen Sie sich die Szene und greifen auf ihre Eigenschaften zu.

Da wir zuvor die Button Count-Eigenschaft in der Szene erstellt haben, können wir darauf über den Get Properties-Knoten zugreifen, der ein Wörterbuch enthält, das alle Eigenschaften der Szene enthält.

Verbinden Sie dieses Wörterbuch dann mit dem Get Property-Knoten und geben Sie den Namen Button Count an, um genau die Eigenschaft abzurufen, die wir in der Szene erstellt haben.

Standardmäßig ist der Output von Get Property vom Typ Any.

Da wir diesen Wert mit der Buttons-Eigenschaft der Plattform vergleichen müssen, die eine ganze Zahl ist, ändern Sie den Ausgangstyp von Get Property in Int.

Vergleichen Sie dann diesen Wert mit der Buttons-Eigenschaft der Plattform, die die gesamte Anzahl der auf der Karte verfügbaren Schaltflächen speichert.

Wenn beide Werte gleich sind, bedeutet dies, dass alle Schaltflächen vom Spieler aktiviert wurden.

In diesem Moment können wir die gewünschte Aktion ausführen.

In diesem Beispiel werden wir die Plattform-Entity aus der Szene entfernen.

Perfekt. Die Logik unserer Plattform ist jetzt bereit.

Die Plattform ist bereit, automatisch zu identifizieren, wie viele Schaltflächen zu Beginn des Spiels existieren.

Dies gibt uns die Freiheit, Schaltflächen aus der Szene hinzuzufügen oder zu entfernen, ohne dass wir manuell irgendwelche Werte ändern müssen, da die Logik die Menge jedes Mal neu berechnet, wenn das Spiel startet.

Damit kann die Plattform dynamisch bestimmen, wann alle Schaltflächen aktiviert wurden, indem sie die Gesamtzahl der Schaltflächen mit dem in der Button Count-Eigenschaft der Szene gespeicherten Wert vergleicht.

Wir haben auch die gesamte Struktur für den nächsten Schritt vorbereitet, einschließlich der Verwendung des button-Tags, der später zu den Tasten hinzugefügt wird.

Das bedeutet, dass die Kommunikation zwischen den Elementen bereits geplant ist:

• die Plattform zählt, wie viele Schaltflächen existieren
• jede Schaltfläche wird die Szene-Eigenschaft beim Aktivieren aktualisieren
• die Plattform überprüft die Szene-Eigenschaft
• wenn der Zähler mit der Gesamtzahl übereinstimmt, führt die Plattform ihre Aktion aus

Jetzt sind wir bereit, zum nächsten Schritt überzugehen: die Schaltflächen zu erstellen und die Logik zu entwickeln, die sie mit der Plattform verbindet, um die Interaktion zwischen diesen beiden Systemen abzuschließen.