Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir die grundlegende Bewegungslogik für unseren Player weiterentwickeln.

Mit den Logic Bricks von Cave Engine werden wir die Logik erstellen, die dafür verantwortlich ist, dass die Figur geht und läuft. Auf dem Weg dorthin lernen Sie, wie Sie Eingaben des Spielers erfassen, diese Eingaben in eine Bewegungsrichtung umwandeln, die Bewegungsgeschwindigkeit steuern und die visuelle Logik organisiert halten.

Diese Lektion baut auf der vorher erstellten Sprunglogik auf. Jetzt werden wir anstatt nur auf einen einzelnen Tastendruck zu reagieren, mehrere Tasten gleichzeitig ablesen und verwenden, um zu definieren, wohin sich der Player bewegen soll.

1. Hinzufügen einer Sequenz

Um die Bewegungslogik für unseren Player weiterzuentwickeln, lernen wir, wie man den Sequence-Knoten benutzt.

Der Sequence-Knoten ermöglicht es Ihnen, mehrere Flow-Ausgaben aus einem einzigen Eingang zu erstellen. Dies ist nützlich, da viele Gameplay-Systeme mehr als ein Stück Logik aus demselben Ereignis ausführen müssen.

Zum Beispiel muss unser On Update-Ereignis die Sprunglogik in jedem Frame überprüfen, aber es muss auch die Bewegungslogik in jedem Frame überprüfen. Anstatt alles in einer großen und verwirrenden Kette zu erstellen, können wir Sequence verwenden, um den Fluss in mehrere organisierte Zweige aufzuteilen.

Auf diese Weise kann dasselbe On Update-Ereignis verschiedene Logikblöcke jedes Frame auf eine sauberere und kontrollierte Weise ausführen.

2. Erstellen der Bewegungslogik

Um die Bewegung des Players zu erstellen, fangen wir an, den Events-Knoten und dann den Active-Knoten hinzuzufügen.

Der Active-Knoten prüft, ob eine Taste derzeit gedrückt gehalten wird. Das ist anders, als nur zu überprüfen, ob eine Taste einmal gedrückt wurde. Für die Bewegung wollen wir normalerweise wissen, ob der Spieler die Taste kontinuierlich gedrückt hält, denn die Figur sollte sich weiter bewegen, solange die Taste aktiv bleibt.

Das werden wir für alle Bewegungstasten tun:

• W, um vorwärts zu bewegen
• S, um rückwärts zu bewegen
• A, um nach links zu bewegen
• D, um nach rechts zu bewegen

Die Ausgabe des Active-Knotens ist ein Bool-Wert. Eine Boolean-Variable kann nur zwei Zustände haben: True oder False.

Wenn wir diesen booleschen Wert mit dem Bool To Float-Knoten in einen Float umwandeln, erhalten wir:

• 1, wenn der Wert True ist
• 0, wenn der Wert False ist

Das ermöglicht es uns, den Tastenzustand in mathematischen Operationen zu verwenden.

Zum Beispiel können wir den Wert von S vom Wert von W subtrahieren, um die Vorwärts-/Rückwärtsbewegung zu berechnen. Wir können auch den Wert von A vom Wert von D subtrahieren, um die Links-/Rechtsbewegung zu berechnen.

Das funktioniert, weil jede Taste entweder 0 oder 1 zurückgibt.

Zum Beispiel für Vorwärts- und Rückwärtsbewegung:

• Wenn W gedrückt wird und S nicht gedrückt wird, ist das Ergebnis 1 - 0 = 1, also bewegt sich der Player vorwärts.
• Wenn S gedrückt wird und W nicht gedrückt wird, ist das Ergebnis 0 - 1 = -1, also bewegt sich der Player rückwärts.
• Wenn keine Taste gedrückt wird, ist das Ergebnis 0 - 0 = 0, also gibt es keine Bewegung auf dieser Achse.
• Wenn beide Tasten gedrückt werden, ist das Ergebnis 1 - 1 = 0, also heben sie sich gegenseitig auf.

Mit diesen Ergebnissen fügen wir einen Make Vector 3-Knoten hinzu und verbinden die berechneten Werte mit den X- und Z-Achsen, die für die Bestimmung der Bewegungsrichtung verantwortlich sind.

Nun verbinden wir den ersten Then-Ausgang des Sequence-Knotens mit dem Fluss dieser Bewegungslogik, während der andere Then-Ausgang weiterhin von der in der vorherigen Lektion erstellten Sprunglogik verwendet werden kann.

Schließlich holen Sie sich die Entity, greifen auf ihre Character Component zu und verwenden den Set Walk Direction-Knoten. Verbinden Sie den Vektor, der von Make Vector 3 erstellt wurde, mit dem Richtungsparameter, damit die Character Component weiß, wohin sich der Player bewegen soll.

Jetzt müssen wir einen Begrenzer erstellen, um die Bewegungsgeschwindigkeit unseres Players zu steuern.

Anstatt die Bewegungsrichtung direkt in Set Walk Direction zu definieren, werden wir die Bewegungsrichtung zuerst in einer Eigenschaft speichern. Das gibt uns mehr Kontrolle, da wir diese Richtung ändern können, bevor wir sie auf die Figur anwenden.

Öffnen Sie die Properties-Registerkarte, erstellen Sie eine neue Eigenschaft, ändern Sie ihren Typ in Vector3 und benennen Sie sie in Move Dir um.

Diese Eigenschaft wird verwendet, um die Bewegungsrichtung des Players zu speichern und wird die Grundlage für die nächsten Anpassungen in der Logik sein.

Klicken Sie auf das Zahnradsymbol neben der Eigenschaft und wählen Sie Change Type, um ihren Typ zu ändern.

Wählen Sie dann Vector3.

Gehen Sie nun zurück zur Graph Ihrer Logic Bricks und setzen Sie die Move Dir-Eigenschaft, die wir gerade erstellt haben.

Verbinden Sie die Ausgabe des Make Vector 3-Knotens mit dem Wert der Move Dir-Eigenschaft.

Das bedeutet, dass wir anstatt die Bewegungsrichtung direkt auf die Figur anzuwenden, diesen Vektor in einer Eigenschaft speichern, sodass wir ihn in den nächsten Teilen der Logik verwenden und ändern können.

Jetzt, da wir die Bewegungsrichtung der Figur in der Move Dir-Eigenschaft speichern, erstellen wir zwei weitere Eigenschaften vom Typ Float:

• Walk Speed
• Run Speed

Diese Eigenschaften definieren die Geschwindigkeit des Players in jedem Bewegungszustand.

Die Verwendung von Eigenschaften hier ist eine gute Praxis, da sie die Bewegung später einfacher anpassbar macht. Anstatt nach fest codierten Werten im Graphen zu suchen, können Sie die Entity einfach auswählen und die Geh- und Laufgeschwindigkeit direkt im Eigenschaften-Panel anpassen.

Jetzt erstellen Sie eine weitere Eigenschaft, diesmal vom Typ Bool, namens Is Running.

Diese Eigenschaft wird den Laufzustand der Figur speichern. Sie wird der Logik sagen, ob der Player aktuell läuft oder nicht, was es uns ermöglicht, zwischen den Werten Walk Speed und Run Speed zu wählen.

Fügen Sie jetzt einen Active-Knoten hinzu, um zu überprüfen, ob die Shift-Taste gedrückt wird.

Verwenden Sie dann Set Is Running, um die Eigenschaft basierend auf dieser Bedingung zu definieren. Wenn Shift aktiv ist, sollte Is Running auf True gesetzt werden, was anzeigt, dass die Figur läuft.

Jetzt werden wir die Walk Direction unter Verwendung der in der Move Dir-Eigenschaft gespeicherten Richtung definieren und dabei die korrekte Geschwindigkeit für jeden Bewegungszustand anwenden.

Um dies zu tun, fügen Sie einen If-Knoten hinzu, der überprüft, ob die Is Running-Eigenschaft True oder False ist.

Wenn das Ergebnis True ist, holen Sie sich den Wert von Move Dir und multiplizieren Sie ihn mit der Run Speed-Eigenschaft.

Wenn das Ergebnis False ist, holen Sie sich den Wert von Move Dir und multiplizieren Sie ihn mit der Walk Speed-Eigenschaft.

Schließlich verbinden Sie das Ergebnis dieser Multiplikation mit dem Set Walk Direction-Knoten.

Auf diese Weise bleibt die Bewegungsrichtung gleich, aber ihre Intensität ändert sich je nachdem, ob der Player läuft oder geht.

Jetzt müssen wir ein kleines Problem lösen.

Wenn Sie die Figur diagonal bewegen, werden Sie möglicherweise feststellen, dass sie schneller bewegt als beim reinen Vorwärts-, Rückwärts-, Links- oder Rechtslaufen. Dies liegt daran, dass das Kombinieren von zwei Bewegungsachsen einen Vektor mit größerer Größe erzeugt.

Wenn Sie nur vorwärts bewegen, entsteht eine Richtung wie diese:

(0, 0, 1)

Aber wenn Sie gleichzeitig vorwärts und nach rechts bewegen, entsteht etwas wie:

(1, 0, 1)

Dieser diagonale Vektor ist länger als ein einachsig abgeleiteter Vektor, was die Figur dazu bringt, diagonal schneller zu bewegen.

Um dieses Verhalten zu beheben, werden wir den Richtungsvektor normalisieren, bevor wir ihn in der Move Dir-Eigenschaft speichern.

Zuerst holen Sie sich die Length des Vektors, der von Make Vector 3 erzeugt wurde.

Dann fügen Sie einen If-Knoten hinzu, um zu überprüfen, ob dieser Wert größer als 0 ist.

Diese Überprüfung ist wichtig, da wir einen leeren Vektor nicht normalisieren sollten. Ein Vektor mit der Länge 0 bedeutet, dass keine Bewegungstaste gedrückt wird, sodass es keine Richtung gibt, die normalisiert werden könnte.

Wenn die Bedingung wahr ist, verwenden Sie den Normalized-Knoten, um die normalisierte Version des Vektors zu erhalten.

Andernfalls verwenden Sie den ursprünglichen Vektor.

Verbinden Sie schließlich das Ergebnis mit dem Set Property-Knoten von Move Dir.

Das bewahrt die Bewegungsrichtung, hält jedoch ihre Größe konstant, sodass die Figur in jeder Richtung mit der gleichen Geschwindigkeit bewegt wird.

3. Verwendung von Ereignissen

Es gibt organisiertere Möglichkeiten, den Fluss unserer Logik innerhalb der Logic Bricks zu strukturieren.

Neben Kommentaren und dem Sequence-Knoten können wir auch Events verwenden, um das System sauberer und leichter verständlich zu machen.

Ereignisse erlauben es Ihnen, einen bestimmten Block Logik zu trennen und ihn von einem anderen Ort im Graphen aufzurufen. Dies ist besonders nützlich, wenn Ihr Graph wächst, da es vermieden wird, dass alles direkt mit On Update in einer großen Kette verbunden ist.

Jetzt lassen Sie uns ein neues Ereignis mit dem Namen Move Player erstellen.

Verbinden Sie dann dieses Ereignis mit dem Fluss des Playerbewegungslogikblocks.

Damit halten wir die gesamte Bewegungslogik nicht mehr direkt mit On Update verbunden, sondern rufen einfach das Ereignis Move Player innerhalb der On Update-Sequenz auf.

Das macht den Fluss sauberer, modularer und leichter verständlich, insbesondere wenn die Projektlogik komplexer wird.

An diesem Punkt verfügt der Player bereits über ein grundlegendes Bewegungssystem, das mit Logic Bricks erstellt wurde.

Die Logik prüft jetzt die Bewegungstasten, berechnet eine Bewegungsrichtung, normalisiert die Richtung, um schnellere diagonale Bewegungen zu vermeiden, speichert sie in der Move Dir-Eigenschaft, prüft, ob der Spieler rennt, wendet die korrekte Geschwindigkeit an und sendet schließlich das Ergebnis über Set Walk Direction an die Character Component.