Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir beginnen, Animationen in unsere Player Logik zu integrieren.

An diesem Punkt kann der Player bereits bewegen und springen. Jetzt müssen wir sicherstellen, dass sich der Charakter visuell auf diese Zustände reagiert, indem wir die richtigen Animationen abspielen, wie idle, walking, running und falling.

Die Hauptidee ist einfach: Wir werden den aktuellen Zustand des Charakters nutzen, um zu entscheiden, welche Animation abgespielt werden soll.

Zum Beispiel:

• Wenn der Player auf dem Boden ist und sich nicht bewegt, spiele die Idle-Animation ab.
• Wenn der Player auf dem Boden ist und sich bewegt, spiele die Walking-Animation ab.
• Wenn der Player rennt, spiele die Running-Animation ab.
• Wenn der Player sich nicht auf dem Boden befindet, spiele die Falling-Animation ab.

Dies ist eines der häufigsten Muster beim Erstellen eines Charaktercontrollers. Die Bewegungslogik steuert, was der Charakter tut, und die Animationslogik liest diese Informationen, um zu entscheiden, was der Spieler sehen sollte.

1. Erstellen der Animationsausführungslogik

Jetzt, da wir gelernt haben, wie man Ereignisse erstellt und organisiert, lass uns ein neues Ereignis für den Animationslogikblock namens Update Animations erstellen.

Dieses Ereignis ist verantwortlich für die Aktualisierung des Animationszustands des Players.

Das erste, was wir tun werden, ist, dieses Ereignis mit einem If-Knoten zu verbinden, der überprüft, ob der Charakter sich derzeit auf dem Boden befindet oder nicht. Diese Information wird verwendet, um zu entscheiden, welche Animation abgespielt werden soll.

Wenn der Player auf dem Boden ist, können wir Idle-, Lauf- oder Animationsanimationen abspielen. Wenn der Player sich nicht auf dem Boden befindet, können wir stattdessen eine Falling-Animation abspielen.

Als Nächstes müssen wir auf die Animation Component zugreifen, die dafür verantwortlich ist, die Charakteranimationen zu verwalten und abzuspielen.

Dazu holen wir zuerst die Entity, dann verwenden wir den Child-Knoten, um das Kindobjekt namens Mesh zu erhalten, das das Mesh-Objekt unseres Players ist. Von dieser Kind-Entity aus können wir auf die Animation Component zugreifen.

Da wir wahrscheinlich mehrmals auf die Animation Component zugreifen müssen, können wir die Knoten Get Entity, Get Child und Get Animation Component in eine wiederverwendbare Funktion umwandeln.

Dazu wähle die Knoten aus, die du möchtest, klicke mit der rechten Maustaste und wähle Promote Selection To Function.

Dies erstellt eine Funktion mit dieser Logik, die das Diagramm klarer und einfacher zu verstehen macht. Es ermöglicht uns auch, diesen gleichen Ablauf an anderen Stellen des Logic Bricks wiederzuverwenden, ohne die gleichen Knoten erneut erstellen zu müssen.

Lass uns diese Funktion in Play Animation umbenennen.

Klare und beschreibende Namen sind beim Arbeiten mit visueller Logik sehr wichtig. Während dein Diagramm wächst, helfen gute Namen, schnell zu verstehen, was jedes Ereignis, jede Funktion und jeder Logikblock verantwortet.

Doppelklicke jetzt auf die Play Animation Funktion, um sie zu öffnen und zu bearbeiten.

Rechtsklicke dann auf den Function Inputs Knoten und füge zwei neue Eingabepins hinzu.

Der erste Input wird sein:

• Animation, vom Typ String.

Dieser Input wird verwendet, um den Namen der Animation anzugeben, die abgespielt werden soll.

Der zweite Input wird sein:

• Blend, vom Typ Float.

Dieser Input wird verwendet, um die Übergangszeit zwischen den Animationen zu steuern.

Diese Parameter machen die Funktion viel flexibler.

Anstatt einen anderen Block von Knoten für jede Animation zu erstellen, können wir dieselbe Play Animation Funktion verwenden und einfach bei jedem Aufruf einen anderen Animationsnamen und Blendwert übergeben.

Füge aus dem Output der Get Animation Component den Knoten Play By Name hinzu.

Dieser Knoten ist verantwortlich für das Abspielen einer Animation basierend auf ihrem Namen.

Verbinde dann die Parameter Animation und Blend, die wir im Function Inputs Knoten erstellt haben, mit den entsprechenden Feldern des Play By Name Knotens.

Das bedeutet, dass jedes Mal, wenn die Play Animation Funktion aufgerufen wird, sie den Animationsnamen und die Übergangszeit erhält und diese Werte an Play By Name weitergibt.

Vergiss nicht, die Loop-Option im Play By Name Knoten zu aktivieren.

Mit aktiver Loop wird die Animation weiter abgespielt, solange sie aktiv ist, anstatt zu stoppen, wenn sie den letzten Frame erreicht. Dies ist besonders wichtig für Animationen wie Idle, Walking, Running und Falling, da sie normalerweise kontinuierlich abgespielt werden müssen.

Schließlich verbinde den Output Flow des Play By Name Knotens mit den Function Outputs, um die Ausführung der Play Animation Funktion abzuschließen.

Jetzt ist es viel einfacher, die Animationen unseres Charakters abzuspielen.

Gehe zurück zu dem If Knoten, der überprüft, ob der Player auf dem Boden ist oder nicht, und verwende die Play Animation Funktion.

Wenn die Bedingung True ist, was bedeutet, dass der Player auf dem Boden ist, rufe die Funktion auf und übergebe "p-idle" als Animationsparameter. Dies ist die Animation, die verwendet wird, wenn der Charakter stillsteht.

Wenn die Bedingung False ist, was bedeutet, dass der Player sich nicht auf dem Boden befindet, rufe die Funktion auf und übergebe "p-fall". Dies ist die Animation, die verwendet wird, wenn der Charakter in der Luft ist.

In beiden Fällen verwende 0.1 als Blend Wert. Dies gibt der Animation eine kurze Übergangszeit, was den Wechsel sanfter macht, anstatt sofort von einer Animation zur anderen zu springen.

Jetzt müssen wir nur noch das Update Animations Ereignis im Fluss des Move Player Ereignisses aufrufen.

Auf diese Weise wird jedes Mal, wenn die Bewegungslogik des Players aktualisiert wird, auch die Animationslogik aktualisiert.

Damit kann der Player bereits zwischen p-idle und p-fall je nach aktuellem Zustand wechseln. Wenn der Player auf dem Boden ist, wird die Idle-Animation abgespielt. Wenn der Player in der Luft ist, wird die Falling-Animation abgespielt.

Perfekt. Lass uns jetzt die Animationslogik des Players weiterentwickeln, indem wir die Bewegungsanimationen hinzufügen.

Dazu hole die Walk Direction und verwende den Knoten Length, um die Intensität des Bewegungsvektors zu messen.

Die Länge des Bewegungsvektors sagt uns, ob sich der Charakter bewegt oder nicht.

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

Wenn das Ergebnis True ist, bedeutet das, dass sich der Charakter bewegt, sodass wir die Walking-Animation p-walk abspielen können.

Wenn das Ergebnis False ist, bedeutet das, dass sich der Charakter nicht bewegt, sodass wir die Idle-Animation p-idle abspielen sollten.

Dies sorgt dafür, dass der Player automatisch zwischen Stehenbleiben und Gehen wechselt, basierend auf seiner Bewegung.

Jetzt gibt es noch zwei Details, die das Bewegungsanimationsverhalten unseres Charakters vervollständigen:

Zuerst müssen wir die Running-Animation abspielen, wenn der Player rennt.

Zweitens müssen wir dafür sorgen, dass der Player in die Richtung schaut, in die er sich bewegt.

Um die Walking- und Running-Animationen zu steuern, füge direkt nach der Überprüfung, ob sich der Player bewegt, einen Sequence Knoten hinzu.

Hole dann die Is Running Eigenschaft und verwende einen If Knoten, um ihren Wert zu überprüfen.

Wenn Is Running True ist, spiele die Running-Animation ab.

Wenn Is Running False ist, spiele die Walking-Animation ab.

Auf diese Weise weiß der Player nicht nur, ob er sich bewegt oder steht, sondern auch, ob er während der Bewegung die Walking oder Running-Animation verwenden sollte.

Verwende den zweiten Then-Output der Sequenz, die wir gerade hinzugefügt haben, um den Look At Smooth Knoten zu verwenden.

Dieser Knoten wird den Charakter sanft drehen und ihn in die Richtung schauen lassen, in die er sich bewegt. Dadurch fühlt sich die Bewegung viel natürlicher an, da das Charakter-Mesh visuell in die gleiche Richtung schaut wie die Bewegung.

Wir müssen den Wert von Get Walk Direction mit -1 multiplizieren, bevor wir ihn an Look At Smooth senden.

Dies kehrt den Richtungsvektor um und korrigiert die Richtung, in die das Charakter-Mesh schaut. Je nachdem, wie das Charaktermodell importiert oder ausgerichtet wurde, könnte das sichtbare Mesh in die entgegengesetzte Richtung des Bewegungsvektors zeigen. Durch die Multiplikation mit -1 wird dies behoben und das Charakter wird in die richtige Richtung schauen, während es sich bewegt.

Verbinde danach den bereits multiplizierten Vektor mit dem Look At Smooth Knoten.

Als Nächstes müssen wir auch die Transform des Objekts bereitstellen, das rotiert werden soll.

Dazu greifst du auf die Entity zu, hole das Player Mesh und verwende den Knoten Get Transform.

Diese Transformation sollte mit Look At Smooth verbunden werden, um sicherzustellen, dass die Rotation auf das richtige Objekt, nämlich das sichtbare Mesh des Charakters, angewendet wird.

Zu diesem Zeitpunkt ist die Animationslogik des Players bereits viel umfassender.

Der Charakter kann jetzt zwischen Idle, Falling, Walking und Running Animationen wechseln, je nach aktuellem Zustand. Er dreht sich auch sanft in die Richtung der Bewegung, was den Controller natürlicher und visuell mit der Gameplay-Logik verbunden macht.