Öffnen von Türen mit Schlüsseln

Da der Spieler jetzt Schlüssel im Spiel aufheben kann, fügen Sie die Funktionalität hinzu, Türen zu entsperren und zu öffnen, wenn der Spieler den erforderlichen Schlüssel aufgehoben hat. In diesem Teil des Tutorials werden Sie den Blueprint BP_DoorFrame modifizieren und Funktionen in Blueprints erkunden.

Durch aufschließbare Türen lässt sich der Spielfluss steuern und der Spieler bekommt das Gefühl, Fortschritte zu machen. Das Projekt, an dem wir gerade arbeiten, ist in Räume unterteilt. Daher bietet das Aufheben von Schlüsseln zum Aufschließen von Türen dem Spieler einen logischen Fortschrittspfad.

Bevor du anfängst

Du solltest unbedingt die Themen verstehen, die in den vorherigen Abschnitten der Tutorialreihe Entwerfen eines Rätsel-Abenteuers behandelt wurden:

• Blueprint-Grundlagen, einschließlich Blueprint-Interfaces.

• Erstellen von Varianten eines Objekts mit einer Map-Variable.

Sie benötigen die folgenden Assets, die im vorherigen Tutorial Erstellen eines Schlüssels erstellt wurden:

• BP_Key

• Blueprint-Funktionsbibliothek BPL_FPGame

• Blueprint-Interface BPI_PlayerKeys

• Drei BP_DoorFrame-Instanzen, die in Ihrem Level zwischen Räumen oder Fluren platziert sind.

Hinzufügen von Farboptionen zur Tür

Da die First-Person-Vorlage bereits über einen Tür-Blueprint verfügt, können Sie den bestehenden Blueprint modifizieren, um die Funktionalität des Öffnens von Türen mit einem Schlüssel hinzuzufügen. 

Damit Ihre Tür mit dem Schlüsselsystem funktioniert, das Sie im vorherigen Teil dieses Tutorials definiert haben, sind einige Dinge erforderlich. Wie beim Schlüssel muss Ihre Tür wissen, dass der Actor, der mit ihr interagiert, das Interface BPI_PlayerKeys implementiert. 

Die Tür sollte ihre Farbe ändern, um dem akzeptierten Schlüssel zu entsprechen. Das bedeutet, dass sie wissen muss, mit welchem ​​Schlüsseltyp sie geöffnet werden kann. Zuletzt wird dieselbe KeyMap-Variable mit den Farbkombinationen Rot, Gelb und Blau benötigt.

Erstellen von Variablen für die Interaktion mit Spieler und Tasten

Führen Sie die folgenden Schritte aus, um neue Variablen zum Blueprint BP_DoorFrame hinzuzufügen

1. Gehen Sie im Inhaltsbrowser zum Ordner LevelPrototyping > Interactable > Door und öffnen Sie den Blueprint BP_DoorFrame.

2. Füge im Panel Mein Blueprint im Abschnitt Variablen eine neue Variable mit dem Namen UseKey und dem Typ Boolean hinzu. Dadurch wird festgelegt, ob die Tür einen Schlüssel zum Öffnen erfordert.

3. Erstellen Sie eine weitere Variable mit dem Namen RequiredKey vom Typ Enum Key Type. Dadurch wird der Schlüssel festgelegt, der zum Öffnen der Tür erforderlich ist. 

   

4. Klicke auf das Augen-Symbol neben beiden Variablen, sodass das Auge geöffnet ist und sie bearbeitbar sind.

5. Wählen Sie die Variable UseKey aus. Gib im Details-Panel Einrichtung als Kategorie ein.

6. Wählen Sie RequiredKey aus und ändern Sie Kategorie auf Einrichtung.

7. Erstellen Sie eine neue Variable mit dem Namen Other Actor des Typs Actor > Objekt-Referenz. Dies speichert den Actor, der mit der Tür interagiert, und du verwendest es, um zu prüfen, ob es eine Überlappung zwischen Spieler und Tür-Volumen gibt.

   

Erstellen der Schlüsselzuordnungsvariable

Genau wie du es in BP_Key getan hast, fügst du die Map-Variable hinzu, die Schlüsseltypen Materialfarben zuordnet. Bei der Tür möchten Sie aber nicht, dass die Tür-Meshs ihre Formen ändern. Deshalb fügen Sie der Map keine neuen Mesh-Formen hinzu.

Führen Sie die folgenden Schritte aus, um die KeyMap-Variable der Tür zu erstellen:

1. Erstellen Sie eine Variable mit dem Namen KeyMap vom Typ Enum Key Type. 

2. Klicken Sie auf diese Variable und klicken Sie im Details-Panel auf die Dropdown-Liste Container und wählen Sie Map aus. 

3. Ändern Sie den Werttyp der Map zu Struct Key Data.

   

4. Kompilieren Sie den Blueprint, um KeyMap-Werte hinzuzufügen.

5. Fügen Sie unter der Sektion Standardwert der Map 3 neue Elemente zur Key Map hinzu (+). 

   Wenn Sie den ersten Eintrag hinzufügen, ändern Sie den Typ in eine andere Farbe, damit Sie weitere neue Einträge hinzufügen können. Sie können den gleichen Eintrag nicht mehr als einmal hinzufügen.

   

6. Fügen Sie für jedes Map-Element das entsprechende Key Material hinzu:

   1. M_BasicColor_Yellow

   2. M_BasicColor_Red

   3. M_BasicColor_Blue

   

7. Stelle für jedes Element sicher, dass Schlüssel-Mesh auf Kein gesetzt ist. Um ein Mesh zu entfernen, klicken Sie auf die Dropdown-Liste und wählen Sie Löschen oben in der Liste aus. 

8. Speichern und kompilieren Sie den Tür-Blueprint.

Hinzufügen der Farbwechsel-Blueprint-Logik

Wenn deine Variablen eingerichtet sind, kannst du die Funktionalität für die Farbänderung hinzufügen, indem du das Blueprint-Diagramm änderst.

Zuerst müssen Sie die Tür so ändern, dass sie über die Farboptionen rot, blau und gelb verfügt, die von der neu hinzugefügten Variable RequiredKey gesteuert werden. Die Tür sollte ihre Farbe ändern, wenn Sie sie im Level festlegen, nicht erst, wenn das Gameplay beginnt. Daher verwenden Sie den Tab Construction Script, um diese Funktionalität zu erstellen. 

Um die Farboptionen der Tür hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Navigieren Sie zum Tab Construction Script für die Tür, wo Sie die Funktionalität für die Erstellung der Tür erstellen können. Suchen im Diagramm den violetten Knoten Construction Script, der die Logik in dieser Funktion startet.

2. Verwenden Sie im Knoten Sequence, der mit dem Construction Script verbunden ist, Pin Hinzufügen (+), um einen weiteren Pin zu erstellen, den Sie dann Then 2 nennen, und den Sie verwenden können, um auf der Kette aufzubauen.

   

   Der Knoten Sequence wird verwendet, um eine Sequenz von Aktionen zu erstellen, in der Then 0 zuerst ausgeführt wird, danach Then 1 und so weiter, abhängig von der Anzahl der Pins, die Sie hinzufügen möchten. Sie helfen Ihnen, Ihr Diagramm zu organisieren und verhindern, dass eine Logikkette zu lang wird.

3. Ziehen Sie den Pin Then 2n zu einem leeren Teil des Diagramm und erstellen Sie einen Knoten vom Typ Branch. 

4. Ziehen Sie den Pin Condition des Knotens Branch und erstellen Sie einen Knoten vom Typ Get Use Key. Jetzt prüft der Verzweigungsknoten, ob die Tür Schlüssel verwenden soll oder nicht. 

   

5. Ziehen Sie den Pin True des Knotens Branch und erstellen Sie einen Knoten vom Typ Fn BPLSet. Das ist die Bibliotheksfunktion, die eine neue Materialfarbe (und ein Mesh, sofern bereitgestellt) auf ein Array von statischen Meshs anwendet.

6. Ziehen Sie am Pin Statisches-Mesh-Array des Knotens Fn BPLSet Key und erstelle einen Knoten vom Typ Make Array. 

7. Klicken Sie auf die Schaltfläche Pin hinzufügen (+) auf dem Knoten Make Array.

8. Ziehen Sie vom Knoten Make Array den ersten Pin [0] und erstellen Sie einen Knoten vom Typ Door abrufen. 

   Wenn Sie in der Liste Variablen > Komponenten in der im Mein Blueprint-Panel nachsehen, sehen Sie, dass die Tür über die Statisches-Mesh-Komponenten Door und Door2 verfügt. Das sind die Elemente, deren Farbe Sie ändern möchten.

9. Ziehen Sie den zweiten Pin, [1], und erstellen Sie einen Knoten vom Typ Get Door 2. Dadurch wird ein Array erstellt, das auf den beiden Statisches-Mesh-Komponenten Door und Door 2 basiert. 

10. Ziehen den Pin Key Map des Knotens Fn BPLSet Key und erstellen Sie einen Knoten vom Typ Get Key Map. Das ist eine Referenz auf die Variable KeyMap der Tür.

11. Ziehen Sie dann den Pin Key und erstellen einen Knoten vom Typ Get Required Key, der eine Referenz auf die Variable RequiredKey ist, die Sie zuvor hinzugefügt haben.

12. Kompilieren und speichern Sie den Blueprint.

Das Konstruktions-Script der Tür sollte nun nach dem Pin Then 3 des Knotens Sequence Folgendes haben:

Hier findest du eine kopierbare Version dieser Logik:

Testen der Türfarben

Nachdem Sie das Türspielobjekt farblich gekennzeichnet haben, können Sie festlegen, dass sich die Türen nur öffnen, wenn der Spieler den richtigen Schlüssel hat.

Wählen Sie in Ihrem Level eine Ihrer BP_DoorFrame-Instanzen aus.

Geben Sie im Details-Panel „Key“ in das Suchfeld oben ein. Sie sehen nun zwei Optionen: Use Key und Required Key. Ändern Sie Required Key zu einem anderen Schlüsseltyp. Die Farbe der Tür sollte sich ändern, um zum Schlüsseltyp zu passen.

Zur Erinnerung: Das ist der Vorteil des Diagramm-Tabs Construction Script im Blueprint-Editor. Sie können Änderungen im Level-Editor sehen, anstatt warten zu müssen, bis der Spiel-Modus aktiviert wird.

Schlüsselbasierte Türlogik erstellen

Als Nächstes können Sie die Funktionalität bauen, um zu prüfen, welche Schlüssel der Spieler hat. Dafür definierst du eine benutzerdefinierte Funktion mit dem Namen fnHasKey im BP_DoorFrame-Blueprint, die prüft, ob der Spieler über den erforderlichen Schlüssel verfügt.   

Erstellen einer Funktion, die auf Schlüssel prüft

Diese Funktion vergleicht den für die Tür erforderlichen Schlüssel mit dem Schlüssel-Array des Spielercharakters und gibt den booleschen Wert „True“ oder „False“ zurück. Für diesen booleschen Ergebniswert verwendest du eine lokale Variable.

Führen Sie die folgenden Schritte aus, um eine Funktion mit einer lokalen Variable zu erstellen:

1. Klicke im BP_DoorFrame-Blueprint im Panel Mein Blueprint auf Hinzufügen (+) neben dem Abschnitt Funktionen. Das ähnelt dem Hinzufügen einer Variablen, aber stattdessen fügen Sie eine Funktion hinzu. 

2. Geben Sie der neuen Funktion den Namen fnHasKey. 

   

3. Da eine Funktion über einen eigenen Satz von Knoten verfügen kann, wird sie in einem eigenen Tab fnHasKey mit einem separaten Knoten-Diagramm geöffnet. Wenn Sie diesen Tab schließen und erneut öffnen müssen, doppelklicken Sie auf die Funktion in der Liste Funktionen.

4. Im Mein Blueprint-Panel sehen Sie unten eine neue Sektion mit der Bezeichnung Lokale Variablen (FnHasKey). Erstellen Sie mit Hinzufügen (+) neben dieser Sektion eine neue Lokale Variable. 

5. Geben Sie der Variablen den Namen HasRequiredKey und legen Sie den Typ auf Boolean fest.

   

   Lokale Variablen ähneln regulären Variablen, sind aber lokal für eine bestimmte Funktion. Sie sind nützlich, um temporäre Werte zu speichern, während die Funktion ausgeführt wird. Sie können diesen Wert dann mithilfe eines Rückgabeknotens an den Rest des Blueprints zurückgeben.

Wenn die Funktion eingerichtet ist, können Sie eine Logik hinzufügen, die prüft, ob der Spieler den richtigen Schlüssel hat.

Um zu prüfen, ob der Actor im Volumen der Tür den erforderlichen Schlüssel hat, führen Sie die folgenden Schritte aus:

1. Ziehen Sie den Pin der Funktion fnHasKey und erstellen Sie einen Knoten vom Typ Sequence. Das organisiert die Logik der Funktion in einer Sequenz von Aktionen, die der Reihe nach ausgeführt werden.

2. Ziehen Sie den Pin „Then 0“ des Knotens „Sequence“ und erstellen Sie einen Knoten vom Typ Fn BPIGet Keys (Message). Das ist die Interface-Funktion, die ein Array von Schlüsseln zurückgibt, die der Spieler bereits gefunden hat.

3. Ziehen Sie den Pin Target des Knotens Fn BPIGet Keys und erstellen Sie einen Knoten vom Typ Get Other Actor. Sobald Sie das Event-Diagramm der Tür eingerichtet haben, speichert diese Variable den Actor, der das Volumen der Tür überlappt.

   

4. Ziehen Sie die lokale Variable HasRequiredKey in die Nähe des Knotens Fn BPIGet Keys und wählen Sie Festlegen aus.

5. Ziehen Sie den Pin Ausführung (Exec) des Knotens FN BPIGet Keys und verbinden Sie ihn mit dem Knoten Set HasRequiredKey.

6. Ziehen Sie den Pin HasRequiredKey des Knotens Set HasRequiredKey und erstellen einen Knoten vom Typ Contains Item, der in der Sektion Array der Suche aufgeführt ist. Dieser Knoten prüft, ob ein spezifischer Gegenstand in einem Array vorhanden ist und gibt True oder False zurück.

   Sie können auch nach Array Contains Item suchen, um die Suche auf diese bestimmte Option einzuschränken.

7. Ziehen Sie den Pin Target Array (der quadratische Pin) des Knotens Contains Item und verbinden Sie ihn mit dem Pin Held Keys des Knotens Fn BPIGet Keys. 

8. Ziehen Sie den Pin Item to Find (der wie ein Kreis aussieht) des Knotens Contains Item und erstellen Sie einen Knoten vom Typ Get Required Key.

  So sollte das Diagramm Ihrer Funktion jetzt aussehen:

Diese Aktionssequenz prüft, ob die von OtherActor (Variable) gehaltenen Schlüssel den RequiredKey (Variable) enthalten. Wenn ja, wird HasRequiredKey auf True festgelegt. 

Übergeben Sie nun das Ergebnis von HasRequiredKey an den Rest des Blueprints. Verwenden Sie dazu einen Knoten vom Typ Return, der die Ausführung einer Funktion stoppt und einen Wert an den Blueprint zurückgibt, der die Funktion aufgerufen hat. 

Führen Sie die folgenden Schritte aus, um die Funktion mit einem Knoten vom Typ Return zu beenden:

1. Ziehen Sie den Pin Then 1 des Knotens Sequence, suchen Sie in der Aktionsliste des Knotens nach Return, und wählen Sie Add Return Node aus.

2. Damit die Funktion einen Wert zurückgibt, benötigt sie einen Output. Klicken Sie auf Return Node, um ihn zu hervorheben.

3. Klicken Sie im Details-Panel auf Hinzufügen (+) neben der Sektion Outputs ganz unten. Dadurch wird ein neuer Output hinzugefügt, der den Wert darstellt, der aus dieser Funktion übergeben wird.

4. Nennen Sie diesen Output KeyFound und ändern Sie den Typ in Boolean.

5. Zurück im Diagramm ziehen Sie den Pin Key Found des Knotens Return und erstellen Sie einen Knoten vom Typ Get HasRequiredKey.

Das fertige FnHasKey-Funktionsdiagramm sollte nun in etwa so aussehen:

Sperren und entsperren von Türen mit Schlüsseln

Nun können Sie die Tür so modifizieren, dass sie sich öffnet, wenn alle nötigen Bedingungen erfüllt sind. 

Genau wie beim Schlüssel müssen Sie prüfen, ob der Charakter das Interface BPI_PlayerKeys (der „Erlaubnisschein“ des Spielers) implementiert, bevor er versuchen kann, eine Tür mit Schlüsseln zu öffnen.

Bevor sie sich öffnet, muss die Tür also prüfen, ob folgende Bedingungen erfüllt sind:

• Die Tür ist für die Verwendung von Schlüsseln eingerichtet (UseKey = True).

• Der überlappende Actor ist der Spieler (implementiert BPI_PlayerKeys).

• Der Spieler hat den erforderlichen Schlüsseltyp.

Um zu testen, ob der Actor, der mit der Tür interagiert, der Spieler ist, führen Sie die folgenden Schritte aus:

1. Suchen Sie im EventGraph von BP_DoorFrame den Knoten Event ActorBeginOverlap. Diese Sammlung von Knoten steuert, was passiert, wenn ein Charakter das Kollisionsvolumen der Tür betritt. Sie fügen ein Blueprint-Interface und einer Schlüsselanforderung zu dieser Logik hinzu, sodass sich die Tür nur öffnet, wenn der Actor der Spieler ist und den richtigen Schlüssel besitzt. 

   Mit Strg + F können Sie nach dem Namen eines Knoten suchen. Klicken Sie auf das Suchergebnis, um direkt zu dem Knoten zu gelangen.

2. Trennen Sie die Verbindung des Knotens Event ActorBeginOverlap vom Knoten Door Control, indem Sie Alt gedrückt halten und auf die Verbindung zwischen den beiden Knoten klicken. Verschieben Sie den Event-Knoten nach hinten, um Raum für mehr Knoten-Actions vor dem Knoten Door Control zu schaffen.

   Verbindung zu Blueprint-Knoten trennen

3. Ziehen Sie den Pin des Knotens Event ActorBeginOverlap und fügen Sie einen Knoten vom Typ Set Other Actor hinzu. Verbinden Sie den Pin Other Actor des Event-Knotens mit dem Pin Other Actor des Knotens Set.

   

   Dadurch wird der Actor gespeichert, der sich mit dem Türbereich überlappt.

4. Ziehen Sie vom Knoten Set Other Actor den blauen Pin Value und erstellen Sie einen Knoten vom Typ Does Object Implement Interface. Legen den Wert von Interface auf BPI_PlayerKeys fest.

   

5. Ziehen Sie vom Knoten Set Other Actor den Pin Ausführung (Exec) und erstellen Sie einen neuen Knoten vom Typ Branch. 

Führen Sie die folgenden Schritte aus, um zu prüfen, ob die Tür Schlüssel verwendet:

1. Ziehen Sie den Pin True des Knotens Branch und erstelle einen Knoten vom Typ Fn Has Key. Das ist die Funktion, die Sie zuvor in diesem Tutorial erstellt haben. Sie nimmt den Schlüsseltyp, der zum Öffnen der Tür erforderlich ist, und prüft das Array Held-Keys des Spielers auf diesen Schlüsseltyp. Mit dem Abruf dieser Funktion werden die darin enthaltenen Knoten ausgeführt. 

2. Ziehen Sie aus dem Knoten Fn Has Key den Pin Ausführung (Exec) und erstellen Sie einen neuen Knoten vom Typ Branch. 

3. Verbinden Sie den Pin Key Found des Knoten Fn Has Key mit dem Pin Condition des Knotens Branch.

4. Verbinden Sie den Pin True des neuen Knotens Branch mit dem Pin Play des Knotens Door Control.

   

Bisher kann die Tür mit dieser Logik nur geöffnet werden, wenn der Spieler den richtigen Schlüssel besitzt. Die Tür sollte sich auch öffnen, wenn:

• Die Tür keine Schlüssel braucht, oder

• Ein Nicht-Spieler-Charakter versucht, durch die Tür zu gehen.

Der erste Branch-Knoten und der erste And-Knoten testen diese beiden Bedingungen. Ist eine der beiden False, ist Branch ebenfalls False. 

Um sicherzustellen, dass sich die Tür für NPCs öffnet und keine Schlüssel benötigt werden, führen Sie die folgenden Schritte aus:

1. Verbinden Sie den Pin False des ersten Branch-Knotens direkt mit dem Pin Play des Knotens Door Control. Sie können Connectors verwenden, indem Sie auf eine Verbindung zwischen zwei Knoten doppelklicken, um Ihre Blueprints zu organisieren.

   

2. Kompilieren und speichern Sie den Blueprint.

Wenn der Actor nun das Schlüssel-Interface nicht implementiert oder die Tür keine Schlüssel benötigt(UseKeys = False), öffnet sich die Tür trotzdem.

Die neue EventGraph Logik von BP_DoorFrame sollte in etwa so aussehen:

Hinzufügen von Kommentaren zu einem Blueprint

Sie können Kommentarblöcke zu Ihren Blueprints hinzufügen, um visuelle Notizen zu erstellen, die Knoten gruppieren und erklären, was die einzelnen Teile des Blueprints bewirken. Kommentare helfen Ihnen und Ihren Teammitgliedern, auf einen Blick zu erkennen, welche Funktionalität Ihre Knoten ausführen, und helfen Ihnen, Ihre Blueprints zu organisieren.

Konzentrieren Sie sich beim Erstellen der Blueprint-Logik zunächst auf die Erstellung der Funktionalität und markieren Sie dann die hinzugefügten Knoten und fügen Sie einen Kommentar hinzu, um sie einzuschließen und zu beschreiben.

Um einen Kommentar in einen Blueprint hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Klicken Sie auf das Diagramm, um sicherzustellen, dass es das aktive Panel ist.

2. Drücke C auf Ihrer Tastatur. Dadurch wird ein Kommentarfeld hinzugefügt.

3. Doppelklicken Sie auf das Textfeld oben in der Box, um einen Kommentar einzugeben.

4. Um die Größe des Kommentars zu ändern, stelle sicher, dass der Kommentar ausgewählt ist (mit einem gelben Umriss) und ziehen Sie eine Kante oder Ecke.

5. Um Notizen innerhalb eines Kommentars zu gruppieren, ziehen Sie die Knoten innerhalb der Grenzen des Kommentars.

Sie können auch einen oder mehrere Knoten auswählen und C drücken, um einen Kommentar hinzuzufügen, der die ausgewählten Knoten enthält. 

Testen Ihrer Türen

Kehren Sie im Level-Editor zu Ihrem Level zurück. Verwenden Sie die Eigenschaft „Required Key“ Ihrer Türen, um diese in verschiedenen Farben einzurichten, und fügen Sie für jede Farbe einen BP_Key hinzu.

Spielen Sie jetzt das Spiel. Wenn Sie zur Tür gehen, ohne den Schlüssel aufzuheben, öffnet sich die Tür nicht.

Aber wenn Sie den Schlüssel aufheben, öffnet sich die Tür, wenn Sie sich ihr nähern. Wenn Sie sich weit genug entfernen, schließt sie sich automatisch. 

Nachdem Sie eine Schlüsselfarbe gewählt haben, versuche Sie, eine Tür mit einer anderen Farbe zu öffnen. Die Tür sollte geschlossen bleiben.

Wenn Sie mit dem Beispiel-Level dieses Tutorials arbeiten, wählen Sie die Tür aus, die zum Flur 2 führt, und ändern Sie den erforderlichen Schlüssel zum blauen Schlüssel. Wählen Sie als Nächstes die Tür aus, die zum Flur 3 führt, und ändern Sie den erforderlichen Schlüssel in den roten Schlüssel. Machen Sie die Tür zum Flur 1 gelb.

Hinzufügen von Feedback mit Debug-Nachrichten

Wenn Sie prüfen möchten, was im Gameplay in einem Blueprint passiert, können Sie Knoten vom Typ Print String verwenden, um Nachrichten auf dem Bildschirm anzuzeigen. Unreal Engine zeigt diese Nachrichten im endgültigen Spiel nicht an.

Versuchen sie, einen Knoten vom Typ Print String hinzuzufügen, um den Typ des Schlüssels zu bestätigen, den der Spieler aufgehoben hat.

Um eine Debug-Nachricht mit Knoten „Print String“ anzuzeigen, führen Sie die folgenden Schritte aus:

1. Gehen Sie im Event Graph BP_AdventureCharacter zu den Knoten, die mit Event fnBPIAddKey beginnen, und fügen Sie Schlüssel zum Array HeldKeys hinzu.

2. Ziehen Sie vom Pin Ausführung (Exec) des Knotens Add und fügen Sie einen Knoten vom Typ Print String hinzu.

3. In-String ist der Text, der auf dem Bildschirm erscheint. Geben Sie benutzerdefinierten Text ein oder verbinden Sie den Pin Key Type des Knotens Event mit In String. Dadurch wird der Schlüssel angezeigt, den der Spieler aufhebt.

   

4. Kompilieren Sie den Blueprint.

5. Spielen Sie Ihr Spiel erneut und heben Sie die Schlüssel auf. Es erscheint ein Debugging-Text, der jede Schlüsselfarbe bestätigt, wenn Sie sie aufheben. 

6. Wenn Sie fertig sind, kehren Sie zurück zum Knoten-Diagramm und löschen Sie die Knoten Print String und Enum to String. Kompilieren und speichern Sie den Blueprint.

Wenn etwas in einem Blueprint nicht wie erwartet funktioniert, können Sie nach Berechnungen, Events oder Funktionsaufrufen „Print String“-Knoten hinzufügen, um zu verfolgen, was mit Werten und Datenabläufen passiert.

Platzieren von Gegenständen zum Aufheben

Bisher haben Sie Schlüssel auf den Boden platziert. Um dies für den Spieler interessanter und spannender zu gestalten, sollten Sie ein Plattform-Element einbauen. 

Im Beispiel-Level dieses Tutorials haben wir etwas Vertikalität hinzugefügt, indem wir den Schlüssel an einer hohen Stelle platziert haben, sodass der Spieler zum Schlüssel springen muss. Hier ist das Risiko geringer, zu fallen und von vorne anfangen zu müssen.

Der Spieler übt das Springen auf der ersten und zweiten Plattform, bevor er mit dem schwierigeren letzten Sprung zur Säule auf die Probe gestellt wird.

Testen des Beispiel-Levels

Wenn Sie die neuen Teile des in diesem Teil der Tutorial-Reihe entworfenen Raums hinzufügen möchten, anstatt Ihre eigenen zu erstellen, kopieren Sie die folgenden Snippets.

Blockout des Startraums

Dieses Text-Snippet enthält die Rampe, den vertieften Boden, die Säule und zwei Plattform-Meshs, die hinzugefügt wurden, um den Pfad zum gelben Schlüssel zu erstellen.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.StaticMeshActor Name=Floor_168 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168'"
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
         End Object
         Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
            StaticMesh="/Script/Engine.StaticMesh'/Engine/MapTemplates/SM_Template_Map_Floor.SM_Template_Map_Floor'"
            bUseDefaultCollision=False
            StaticMeshDerivedDataKey="STATICMESH_34081786561B425A9523C94540EA599D_359a029847e84730ba516769d0f19427Simplygon_5_5_2156_18f808c3cf724e5a994f57de5c83cc4b_680318F3495BDBDEBE4C11B39CD497CE000000000100000001000000000000000000803F0000803F00000000000000000000344203030300000000"
            MaterialStreamingRelativeBoxes(0)=4294901760

Führen Sie die folgenden Schritte aus, um die neuen Blockout-Formen von dem Startraum zu erstellen:

• Entfernen Sie im Unreal Editor alle Schlüssel aus dem Startraum, damit sie in der neuen Geometrie nicht verloren gehen.

• Klicken Sie auf Vollständiges Snippet kopieren.

• Vergewissern Sie sich, dass im Unreal Editor der Viewport das aktive Panel ist (klicken Sie irgendwo im Viewport oder Outliner und drücken Sie Esc), und drücken Sie dann Strg + V.

  Wenn Sie einen der Blockout-Räume aus dem vorherigen Teil dieses Tutorials verschoben haben, werden die neuen Meshs möglicherweise nicht an der richtigen Stelle angezeigt. Verschieben Sie sie nach Bedarf.

• Drei Bodenteile bedecken den neuen vertieften Boden. Klicken Sie im Viewport auf die einzelnen Elemente und drücken Sie Entf.

  

Als Nächstes

Ihr Spieler-Charakter kann Schlüssel aufheben, aber Sie erhalten kein Feedback, was er bisher aufgehoben hat. Im nächsten Abschnitt erstellen Sie ein Heads-up-Display (HUD) für den Spieler, das die Schlüssel in seinem Inventar anzeigt.

• 

  Spieler-HUD

  Erstelle ein einfaches Heads-up-Display (HUD), das aktualisiert wird, wenn der Spieler einen Gegenstand aufhebt.