Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir beginnen, die grundlegende Bewegungslogik für unseren Player zu erstellen.

Nur mit den Logic Bricks von Cave Engine werden wir eine einfache Sprungmechanik durch visuelle Logik implementieren. Dies hilft dir auch, eines der wichtigsten Konzepte hinter Logic Bricks zu verstehen: wie Ereignisse, Bedingungen und Aktionen zusammenarbeiten, um das Verhalten des Spiels zu steuern.

In diesem Fall wird die Logik sehr einfach sein:

1. Überprüfen, ob der Spieler die Springtaste gedrückt hat.
2. Überprüfen, ob der Player springen darf.
3. Wenn alles korrekt ist, rufe die Sprungfunktion aus der Charakterkomponente des Players auf.

Dies ist ein gutes erstes Beispiel, da der Sprung eine sehr gängige Spielmechanik ist, aber es führt auch die grundlegende Struktur ein, die du viele Male verwenden wirst, wenn du Spiele mit Logic Bricks erstellst.

1. Sprung hinzufügen

Um die Bewegungslogik für den Player zu erstellen, müssen wir zunächst die Spiel Ereignisse abrufen.

Das Ereignisse-Objekt gibt dir Zugriff auf eingabeverwandte Informationen, wie z. B. Tastaturtasten, Maustasten und andere Ereignisprüfungen, die während des Spiels stattfinden.

Im Bearbeitungsbereich der Logic Bricks klickst du mit der rechten Maustaste, um das Knoten-Suchmenü zu öffnen.

Um schnell einen Knoten zu finden, verwende das Suchfeld, das durch das Lupe-Symbol gekennzeichnet ist, und tippe den Namen des Knotens ein, den du möchtest.

Die Knoten Entity, Scene und Events werden sehr häufig verwendet, daher sind sie bereits oben im Suchfenster hervorgehoben. Aus diesem Grund musst du sie normalerweise nicht manuell nach Namen suchen.

Wähle Get Events, um einen Events-Knoten zu deiner Logik hinzuzufügen.

Füge jetzt den Pressed-Knoten hinzu.

Dieser Knoten ist dafür verantwortlich, zu überprüfen, ob eine bestimmte Taste vom Spieler gedrückt wird.

Mit anderen Worten, dies ist die Bedingung, die unserer Logik sagt: „Der Spieler möchte jetzt springen.“

Wähle die Taste, die verwendet werden soll, um den Sprung auszuführen.

In den meisten Spielen wird die Space-Taste häufig zum Springen verwendet, daher werden wir sie auch hier verwenden.

Nachdem du die Sprungtaste konfiguriert hast, müssen wir überprüfen, ob diese Taste tatsächlich vom Spieler gedrückt wurde.

Dafür verwenden wir einen If (Bool)-Knoten.

Der If (Bool)-Knoten erhält einen booleschen Wert, was bedeutet, dass ein Wert entweder True oder False sein kann. Wenn die Bedingung wahr ist, setzt die Logik den Fluss über den True-Ausgang fort. Ist die Bedingung falsch, setzt sie den Fluss über den False-Ausgang fort.

In diesem Fall wird die Bedingung sein, ob die Space-Taste gedrückt ist oder nicht.

Jetzt, genau wie wir den Events-Knoten hinzugefügt haben, müssen wir auch unsere aktuelle Entity abrufen.

Das ist wichtig, denn die Sprungaktion gehört nicht zum Ereignisobjekt. Das Ereignisobjekt sagt uns nur, ob die Taste gedrückt wurde. Das tatsächliche Sprungverhalten gehört zur Player-Entity, genauer gesagt zu seiner Character Component.

Durch den Entity-Knoten können wir auf die Komponenten zugreifen, die an den Player angehängt sind.

Von der Output der Character Component ziehe eine Verbindung und suche nach Jump.

Dieser Knoten ist dafür verantwortlich, den Charakter-Sprung auszuführen, wenn die Bedingung erfüllt ist.

Also, an diesem Punkt sagen wir im Grunde:

„Wenn der Spieler die Sprungtaste drückt, hole die Charakterkomponente des Players und rufe ihre Sprungfunktion auf.“

Dies wird der Hauptfluss der Sprunglogik sein:

Entity → Character Component → Jump

Mit diesem Fluss greifen wir auf die Charakterkomponente von der Entity zu und verwenden dann die Sprungfunktion.

Verbinde nun den True-Ausgang des If (Bool)-Knotens mit dem Flow-Eingang des Jump-Knotens.

Das bedeutet, dass wenn die Space-Taste gedrückt wird, die Bedingung wahr sein wird und der Player den Sprung ausführt.

Wenn die Taste nicht gedrückt ist, wird die Bedingung falsch sein und es passiert nichts.

Damit diese Logik tatsächlich ausgeführt werden kann, muss sie mit einem Flow-Ereignis verbunden werden.

Logic Bricks werden nicht zufällig ausgeführt. Sie benötigen einen Einstiegspunkt, der der Knoten ist, der den Ausführungsfluss startet.

Der On Start-Knoten wird nur einmal ausgeführt, wenn die Entity startet. Dies ist nützlich für Initialisierungslogik, wie das Setzen von Variablen, Vorbereiten von Referenzen oder das Konfigurieren von etwas zu Beginn des Spiels.

Der On Update-Knoten wird in jedem Frame ausgeführt. Dies ist nützlich für Logik im Gameplay, die ständig überprüft werden muss, wie Bewegung, Eingabe, Kamerasteuerung oder alles, was sich während des Spiels ändern kann.

Da wir kontinuierlich überprüfen müssen, ob der Spieler die Sprungtaste gedrückt hat, werden wir unsere Logik mit On Update verbinden.

Dies garantiert, dass die Überprüfung der Sprungtaste während des Gameplays ständig erfolgt.

Mit dieser Logik sollte der Charakter bereits in der Lage sein zu springen.

Um deine Logic Bricks organisiert zu halten, kannst du alle Knoten, die für diese Funktionalität verwendet wurden, auswählen, indem du mit der rechten Maustaste klickst und ziehst oder sie einzeln bei gedrückter Shift-Taste auswählst.

Nachdem du die Knoten ausgewählt hast, drücke C, um einen Kommentar zu erstellen.

Dies ist eine sehr nützliche Organisationspraktik. Wenn deine Logik wächst, helfen dir Kommentare, verschiedene Teile des Verhaltens visuell zu trennen, wie Sprung, Bewegung, Kamera, Angriffe, Interaktionen usw.

Selbst wenn die Logik jetzt einfach ist, wird es dir viel leichter fallen, dein Projekt später zu verstehen, wenn du dich früh daran gewöhnst, deine Knoten zu organisieren.

2. Überprüfung des Bodens hinzufügen

An diesem Punkt hast du wahrscheinlich ein kleines Problem bemerkt: Wenn wir die Space-Taste weiter drücken, kann der Charakter möglicherweise ununterbrochen springen.

Das passiert, weil unsere Logik immer noch nicht überprüft, ob der Charakter tatsächlich an diesem Moment springen darf. Sie prüft nur, ob die Sprungtaste gedrückt wurde, und ruft dann sofort die Sprungfunktion auf.

In den meisten Spielen wollen wir nicht, dass der Spieler unendlich in der Luft springt. Normalerweise sollte der Spieler nur springen können, wenn er den Boden berührt.

Glücklicherweise ist es in Cave sehr einfach, dies zu lösen.

Dafür verwenden wir den On Ground-Knoten.

Der On Ground-Knoten gibt einen booleschen Wert zurück, der angibt, ob der Charakter derzeit den Boden berührt oder nicht.

Jetzt, anstatt nur eine Bedingung zu überprüfen, werden wir zwei Bedingungen überprüfen:

1. Ist die Sprungtaste gedrückt?
2. Ist der Charakter auf dem Boden?

Nur wenn beide Bedingungen wahr sind, sollte der Jump-Knoten ausgeführt werden.

Die Logik wird:

• Zuerst überprüfen, ob die Space-Taste gedrückt wurde.
• Wenn wahr, überprüfen, ob der Player auf dem Boden ist.
• Wenn der Player auf dem Boden ist, Jump ausführen.
• Wenn der Player nicht auf dem Boden ist, nichts tun.

Dies verhindert, dass der Charakter unendlich springt, während er bereits in der Luft ist.

Mit dieser Bodenerkennung wird die Sprunglogik viel korrekter für einen grundlegenden Player-Controller.

Jetzt wird der Player nur springen, wenn die Sprungtaste gedrückt wird und die Charakterkomponente meldet, dass der Player derzeit auf dem Boden ist. Dies ist die grundlegende Struktur, die du für viele Gameplay-Aktionen in Cave verwenden wirst: Zuerst die Eingabe überprüfen, dann überprüfen, ob die Aktion erlaubt ist, und erst dann die Aktion ausführen.