Visuelles Skripting-Tutorial (Logic Bricks)

In dieser Lektion werden wir die Logik erstellen, die verwendet wird, um das Objekt mit den Logic Bricks von Cave Engine zu sammeln.

Du wirst lernen, wie man erkennt, wann der Spieler mit einem sammelbaren Objekt kollidiert, dieses Objekt mit einem Tag identifiziert, es aus der Szene entfernt und einen einfachen UI-Zähler aktualisiert, der anzeigt, wie viele Objekte gesammelt wurden.

Das ist der Beginn eines sehr gängigen Gameplay-Systems: Objektinteraktion. Dieselbe Idee kann später erweitert werden, um Münzen, Schlüssel, Munition, Gesundheitsgegenstände, Questobjekte, Power-ups oder jedes andere Objekt zu erstellen, das der Spieler sammeln kann.

1. Logik zum Sammeln des Objekts erstellen

Innerhalb der Logik unseres Spielers werden wir Kollisionen mit sammelbaren Objekten direkt vom Spieler selbst erkennen.

Nach der Bewegungslogik werden wir das System erstellen, das für die Erkennung des Kontakts mit dem Objekt und das Entfernen aus der Szene verantwortlich ist.

Zuerst rufe die Entity ab und greife mit Get Character auf ihre Character Component zu.

Von der Character Component benutze den Knoten Get Collision With. Dieser Knoten ermöglicht es uns, Kollisionen basierend auf einem bestimmten Tag zu erkennen.

In diesem Fall verwenden wir das Tag item, das wir unserem sammelbaren Objekt in der vorherigen Lektion zugewiesen haben.

Deshalb war es wichtig, ein Tag zu dem Objekt hinzuzufügen. Anstatt nach einem bestimmten Entity-Namen zu suchen, können wir einfach den Spieler fragen, ob er mit etwas kollidiert ist, das als item gekennzeichnet ist. Das macht die Logik flexibler, da jedes sammelbare Objekt mit demselben Tag vom selben System erkannt werden kann.

Das Ergebnis dieser Erkennung sollte mit einem Get-Knoten verbunden werden, der die Kollisioninformationen zurückgibt, auch bekannt als Collision Info.

Dann erhalten wir den Index 0, der die erste erkannte Kollision darstellt.

Schließlich verbinden wir dieses Ergebnis mit dem Kill-Knoten, der dafür verantwortlich ist, eine Entity aus der Szene zu entfernen.

Die Entity, die entfernt wird, stammt direkt aus der Collision Info. Mit anderen Worten, das gesammelte Objekt selbst wird als Eingabe an Kill übergeben, sodass es verschwindet, wenn es vom Spieler berührt wird.

Mit dieser Logik kann der Spieler bereits ein sammelbares Objekt erkennen und es aus der Szene entfernen.

In der Praxis bedeutet das, dass, wenn der Spieler eine Entity berührt, die als item gekennzeichnet ist, diese Entity gesammelt und aus der aktuellen Szene gelöscht wird.

2. Sammelbare UI erstellen

Jetzt müssen wir dem Spieler zeigen, dass ein Objekt tatsächlich gesammelt wurde.

Um das zu tun, werden wir eine einfache Benutzeroberfläche erstellen, die anzeigt:

• das Objekt-Icon
• die Anzahl der gesammelten Objekte
• die Gesamtanzahl der verfügbaren Objekte auf der Karte

Um zu beginnen, greife auf die Player Template zu und füge eine Interface-Komponente hinzu, speziell ein UI Element. Dieses UI Element wird für den visuellen Teil unseres HUD verantwortlich sein.

Von diesem Element aus werden wir das Icons für das sammelbare Objekt erstellen und konfigurieren. Dieses Icon dient als visuelle Basis, um die Sammlungsinformationen auf dem Bildschirm des Spielers anzuzeigen.

Im Basic-Tab des UI Elements können wir die Position und Skalierung des Icons konfigurieren.

Indem du auf das Anker-Icon der Positions-Eigenschaft klickst, kannst du es an die untere linke Ecke des Bildschirms anheften.

In der Skalierungs-Konfiguration lass den Referenzpunkt im Zentrum gesperrt und halte die Position und Skalierung gesperrt. Das macht die Werte relativ und hilft, das Layout korrekt an unterschiedliche Bildschirmauflösungen anzupassen.

Schließlich setze den Layer-Wert auf 2. Dies garantiert, dass das Icon über anderen UI Elements mit niedrigerer Priorität gerendert wird.

Passe die Scale-Werte an, bis das Icon die gewünschte Größe hat.

Verwende dann die Position-Werte, um es auf der linken Seite des Bildschirms oder in einem anderen Bereich deiner Wahl innerhalb der Benutzeroberfläche zu platzieren.

Diese Einstellungen ermöglichen es dir, sowohl die Größe als auch die Position des Elements im HUD präzise zu steuern.

Im Behaviour-Tab können wir den Default Style, der standardmäßig vorhanden ist, entfernen und eine benutzerdefinierte Texture für unser Icon hinzufügen.

Du kannst auch die Tint-Farbe und die Alpha-Transparenz anpassen, um das visuelle Ergebnis zu erzielen, das du möchtest.

Die Option 9-Slice Scaling wird verwendet, um Verzerrungen zu vermeiden, wenn ein Bild im Layout gestreckt wird. Wenn aktiviert, kannst du die Werte entsprechend den Anforderungen des Icons anpassen, um das Bild konsistent zu halten, selbst wenn es in der Größe verändert wird. In unserem Fall werden wir das 9-Slice nicht verwenden, da unser Bild ein Icon ist.

Jetzt erstellen wir 3 neue Interface Entities vom Typ Text.

Diese werden dafür verantwortlich sein, die Anzahl der gesammelten Objekte und die Gesamtanzahl der verfügbaren Objekte in der Karte anzuzeigen.

Zuerst benenne den ersten Text in TextCollect um. Dieser Text zeigt die Anzahl der vom Spieler gesammelten Objekte an.

Dann enthält der zweite Text nur das Zeichen “/”, das als visueller Trenner zwischen den Werten in der UI fungiert.

Schließlich benenne den dritten Text in TextMax um. Dieser wird die maximale Anzahl der in der Karte verfügbaren Objekte darstellen.

Jetzt greife auf den Text-Tab der UI Elements zu, die erstellt wurden.

In diesem Abschnitt gibt es ein Feld, in dem wir den Inhalt definieren können, der auf dem Bildschirm angezeigt wird.

Für die beiden Texte, die die Objektwerte repräsentieren, TextMax und TextCollect, sollten wir den Anfangswert auf 0 setzen.

Der Text, der als Separator verwendet wird, sollte nur das Zeichen “/” enthalten, um die gesammelte Menge von der Gesamtanzahl der Objekte visuell zu trennen.

Jetzt positionieren wir die UI-Texte so, dass sie ordentlich nebeneinander neben dem Icon angeordnet sind.

• Zuerst die TextCollect positionieren.
• Dann den “/” Text direkt danach platzieren.
• Schließlich TextMax nach dem Schrägstrich positionieren.

Auf diese Weise wird die UI als Fortschrittszähler organisiert, der klar etwas anzeigt wie:

gesammelte Objekte / Gesamtobjekte

Zum Beispiel:

0 / 10

Hinweis: Alternativ kannst du auch eine einzige Entity erstellen und programmatisch (über Logic Bricks) die Strings verketteten, um dasselbe Ergebnis zu erzielen.

3. Logik für den Objektzähler erstellen

Jetzt müssen wir die UI so gestalten, dass sie die gesammelten Objekte widerspiegelt.

Im Moment kann das Objekt aus der Szene entfernt werden, aber die UI weiß noch nicht, dass der Spieler etwas gesammelt hat. Jetzt werden wir die Zählerlogik implementieren.

Zuerst gehe zurück zu den Player Logic Bricks und erstelle eine neue Eigenschaft namens Collected Item, vom Typ Int.

Diese Eigenschaft speichert, wie viele Objekte der Spieler während des Spiels gesammelt hat.

Der Anfangswert dieser Eigenschaft sollte 0 sein.

In der Spieler-Logik, direkt nach dem Kill-Knoten, der das gesammelte Objekt entfernt, erstellen wir die Logik, die verantwortlich ist für die Aktualisierung der Objektanzahl.

Zuerst greife auf die Collected Item-Eigenschaft zu.

Dann addiere +1 zu ihrem aktuellen Wert.

Schließlich setze das Ergebnis zurück in die Collected Item-Eigenschaft.

Auf diese Weise wird jedes Mal, wenn der Spieler ein Objekt sammelt, der Wert von Collected Item um 1 erhöht, und der Zähler bleibt aktuell.

Dieser Wert wird jedoch nur in der Eigenschaft gespeichert. Jetzt müssen wir ihn im UI-Text anzeigen.

Direkt danach werde die Logik fortsetzen, indem wir den Fluss von Set Collected Item zu einem Set Text-Knoten verbinden.

Dieser Knoten ist verantwortlich für die Aktualisierung des Texts, der in der Benutzeroberfläche angezeigt wird.

Um Set Text zu verwenden, müssen wir zwei Dinge angeben:

• die UI Element Component, die ihren Text aktualisiert bekommen soll
• den neuen Textwert

Da die Texte als Kinder des Spielers erstellt wurden, können wir direkt über die Entity-Hierarchie auf sie zugreifen.

Dafür benutze Entity, dann Get Child, und gib den Namen des Textobjekts an. Aktiviere die Option Recursive, um sicherzustellen, dass die Suche auch in den Kindern der Kinder des Spielers erfolgt.

Dann hol dir die UI Element Component von der Entity, die gefunden wurde.

Für den Textwert hole die Collected Item-Eigenschaft, konvertiere sie in String und verbinde sie mit Set Text.

Auf diese Weise wird der UI-Text automatisch mit demselben Wert aktualisiert, der in der Spieler-Eigenschaft gespeichert ist.

Jetzt lass uns auch den Text, der die Gesamtanzahl der Objekte darstellt, zum Laufen bringen.

Immer noch in den Player Logic Bricks erstelle eine neue Eigenschaft namens Max Item, vom Typ Int.

Diese Eigenschaft speichert die Gesamtzahl der im Map verfügbaren sammelbaren Objekte.

Um die Gesamtanzahl der Objekte in der Karte in dieser Eigenschaft zu speichern, werden wir das On Start-Ereignis des Spielers verwenden.

Dieser Wert muss nur einmal zu Beginn des Spiels berechnet werden, da er angibt, wie viele sammelbare Objekte es in der Szene gibt, wenn das Spiel beginnt.

Zuerst hol dir die Scene des Spiels.

Dann verwende den Knoten, der alle Entities in der Szene zurückgibt, die durch das item-Tag gefiltert sind. Da dieses Tag nur für unsere sammelbaren Objekte vorhanden ist, wird dies die Liste aller sammelbaren Objekte in der aktuellen Karte zurückgeben.

Mit dieser Liste von Entities verwende den Knoten Size.

Der Knoten Size gibt die Gesamtanzahl der Elemente in der Liste als Ganzzahl zurück. Dieser Wert entspricht genau der Anzahl an Objekten, die in der Karte vorhanden sind.

Schließlich setze dieses Ergebnis in die Max Item-Eigenschaft, damit das Spiel mit der korrekten Gesamtanzahl an sammelbaren Objekten in der Eigenschaft beginnt.

Jetzt müssen wir diesen Wert nur noch an den UI-Text senden.

Um dies zu tun, verwenden wir die gleiche Logik, die wir für Collected Item verwendet haben.

Hole die Max Item-Eigenschaft, konvertiere den Wert in String und verbinde ihn mit dem Set Text-Knoten.

Greife dann auf das UI Element zu, das dem maximalen Elementtext entspricht, indem du die Player-Hierarchie mit Get Child verwendest, den richtigen Namen eingibst und Recursive aktivierst, falls nötig.

Verbinde schließlich diese UI Element-Komponente mit Set Text.

Auf diese Weise wird die Gesamtzahl der Elemente korrekt in der Benutzeroberfläche des Spielers angezeigt.

An diesem Punkt ist das System für sammelbare Gegenstände funktionsfähig.

Der Spieler kann sammelbare Gegenstände mit dem item-Tag erkennen, sie aus der Szene entfernen, den Zähler für gesammelte Gegenstände erhöhen und die Benutzeroberfläche aktualisieren, um sowohl die gesammelte Menge als auch die Gesamtzahl der verfügbaren Gegenstände auf der Karte anzuzeigen.