Erstellen eines Schlüssels

In diesem Abschnitt erstellen Sie Ihr erstes Gameplay-Objekt: einen Schlüssel-Blueprint.

Um die Funktionalität für Gameplay-Objekte in Ihrem Level zu erstellen, verwenden Sie Blueprint-Visual-Scripting. Blueprints in Unreal Engine sind Assets mit einer physikalischen Darstellung und besonderen Funktionalitäten, wie etwa der Möglichkeit für den Spieler, sie aufzuheben.

Das Blueprint-Visual-Scripting-System kann verwendet werden, um Funktionalität zu erstellen, ohne Code zu schreiben, da Sie ein knotenbasiertes Interface verwenden, um das Verhalten eines Gameplay-Objekts zu erstellen.

Zuerst definieren Sie den In-Game-Actor des Schlüssels und fügen Komponenten hinzu, mit denen Sie die Schlüssel so konfigurieren können, dass sie in drei verschiedenen Varianten angezeigt werden: als gelbes Oval, als blaues Rechteck oder als roter Kegel. Anstatt für jede Variante separate Assets zu erstellen, können Sie mit Blueprints alle diese Optionen in einem Asset zusammenfassen.

Als Nächstes fügen Sie das Verhalten des Schlüssels hinzu – die Möglichkeit für den Spieler-Charakter, ihn aufzuheben. Das Aufheben von Objekten ist eine der häufigsten Gameplay-Mechaniken.

Bevor Sie anfangen

Stellen Sie sicher, dass Sie die folgenden Themen verstanden haben, die in den vorherigen Abschnitten von Entwerfen eines Rätsel-Abenteuers behandelt wurden:

• Unreal Editor-Benutzeroberfläche, darunter der Inhaltsbrowser und der Viewport.

• Ein Verständnis von Blueprints. Weitere Informationen dazu finden Sie in der Dokumentation zu Blueprint-Grundlagen.

Sie benötigen die folgenden Assets aus Projekteinrichtung und Level-Blockout:

• Ein Level mit „blocked-out“ Räumen.

Definieren von Schlüsseltypen und Attributen

Bevor Sie den Schlüssel-Blueprint erstellen, definieren Sie einige Schlüsseldaten, die der Blueprint verwendet, um die rote, gelbe und blaue Variante zu erstellen.

Um die verschiedenen in Ihrem Spiel verwendeten Schlüsseltypen darzustellen, verwenden Sie sowohl eine Enumeration als auch eine Struktur.

Jeder Enumerator fungiert als Label für einen Container und die Struktur entspricht dem Inhalt jedes Containers.

Definieren von Schlüsseltypen in einem Enum

Erstellen Sie zuerst ein Enumerations-Asset, das Ihre wichtigsten Varianten definiert: Rot, Gelb und Blau.  

Um ein Enum-Asset zu erstellen, führen Sie die folgenden Schritte aus:

1. Öffnen Sie den Inhaltsbrowser oder eine Inhalts-Schublade, indem Sie die Inhalts-Schublade-Schaltfläche in der unteren linken Ecke von Unreal Engine verwenden.

2. Erstellen Sie einen Ort zum Speichern der Blueprints und unterstützenden Assets, die Sie in diesem Tutorial erstellen. Gehen Sie in den Ordner Inhalt > AdventureGame > Designer. Klicken Sie mit der rechten Maustaste in diesen Ordner und klicken auf Neuer Ordner.

3. Nennen Sie den neuen Ordner Blueprints.

4. Erstellen Sie im Ordner Blueprints einen weiteren Ordner mit dem Namen Core.

5. Klicken Sie mit der rechten Maustaste in den Ordner Core, gehen Sie zu Blueprint und klicken Sie im Menü „Asset erstellen“ auf Enumeration. Geben Sie dem neuen Asset den Namen Enum_KeyType.

   

6. Doppelklicken Sie auf das Asset, um es in einem neuen Fenster zu öffnen.

Die Enumeration enthält eine Liste von Enumerator-Optionen. 

Um der Enum Schlüsseltypen hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Klicken Sie dreimal auf die Schaltfläche Enumerator hinzufügen, um der Liste drei neue Enums hinzuzufügen.

2. Ändern den Anzeigenamen des ersten Enumerators zu Blau. Ändern Sie den zweiten zu Gelb und den dritten zu Rot.

   

3. Speichern Sie die Enum-Asset-Datei, indem Sie oben links auf die Schaltfläche Speichern klicken. Alternativ können Sie STRG + S verwenden. 

Mit dem Hinzufügen eines Enumerators fügen Sie der Liste eine Option hinzu. Blau, Gelb und Rot sind alles Werte, die Sie verwenden, um zwischen den verschiedenen Schlüsseltypen zu unterscheiden.

Im Gegensatz zu Blueprints müssen Sie keine Daten-Assets kompilieren, da Sie keine Funktionalität kompilieren. 

Definieren von Attributen in einer Struktur

Erstellen Sie als Nächstes eine Struktur, die die Attribute definiert, die jeden Schlüsseltyp unterscheiden: eine Mesh-Form und eine Farbe.

Um ein Struktur-Asset (struct) zu erstellen, führen Sie die folgenden Schritte aus:

1. Gehen Sie erneut in den Inhaltsbrowser und vergewissern Sie sich, dass Sie sich noch immer im Ordner Inhalt > AdventureGame > Designer > Core befinden.

2. Klicken Sie mit der rechten Maustaste irgendwo im Ordner Core, gehen Sie zu Blueprint und klicken Sie auf Struktur. Nenne dieses Asset Struct_KeyData.

   

3. Doppelklicken Sie auf das neue Asset, um es in einem neuen Fenster mit den Eigenschaften der Struktur zu öffnen.

4. Die Struktur verfügt standardmäßig über eine Variable mit dem Namen MemberVar_0. Klicken Sie auf Variable hinzufügen, um eine zweite Variable hinzuzufügen.

5. Ändern Sie den Namen der ersten Variable in Key Material und die zweite Variable in Key Mesh.

6. Jede Variable hat ein Datentyp zugewiesen. Standardmäßig ist dieser Wert auf Boolean (ein True- oder False-Wert) festgelegt. Sie müssen den Typ beider Variablen ändern.

   Klicken für die Variable Key Material auf die Dropdown-Liste Boolean. Geben Sie Material Instance in das Suchfeld ein, bewegen Sie den Mauszeiger über Material Instance und wählen Sie Objekt-Referenz aus. 

   

7. Wiederholen Sie diese Schritte, um den Typ der Variablen von Key Mesh in Statisches Mesh > Objekt-Referenz zu ändern. 

   

8. Speichern Sie die Struktur-Asset-Datei. 

Sie haben jetzt zwei Attribute erstellt, die jeder Schlüsseltyp verwenden wird – ein Schlüsselmaterial, das die Schlüsselfarbe festlegt, und ein Schlüssel-Mesh, das die Schlüsselform festlegt. 

Sie haben nun definiert, welche Art von Daten der Schlüssel enthält. Als Nächstes richten Sie die Farben des Schlüssels ein und erstellen dann die einzelnen Schlüsseltypen.

Erstellen der Schlüsselfarben 

Nun, da Sie die Daten für blaue, gelbe und rote Schlüsseltypen haben, erstellen sie Materialien mit entsprechenden Farben, die Sie jedem Schlüsseltyp zuweisen.

In Unreal Engine definiert ein Material, wie eine Oberfläche aussieht. Es steuert Dinge wie Farbe, Textur, Glanz, Transparenz und mehr. Eine Material-Instanz ist eine Kopie eines Materials, die das Material als Grundlage verwendet, aber bestimmte Einstellungen wie Farben oder Texturen überschreiben kann, ohne ein brandneues Material von Grund auf erstellen zu müssen.

In diesem Beispiel erstellen Sie ein Basismaterial, das Attribute für alle Schlüssel im Spiel definiert. Dann erstellen Sie zwei Material-Instanzen dieses Materials, um alle Attribute zu kopieren, aber die Farben zu überschreiben.

Um ein farbiges Material-Asset zu erstellen, führen Sie die folgenden Schritte aus:

1. Gehen Sie zum Inhaltsbrowser. Navigieren Sie zum Ordner Content > AdventureGame > Designer .

2. Klicken Sie im Ordner Designer mit der rechten Maustaste und klicken Sie auf Neuer Ordner. Nennen Sie den Ordner Materialien.

3. Wechseln Sie in den Order Materialien. Klicken Sie im Ordner mit der rechten Maustaste und wählen Sie Material aus, um ein Material-Asset zu erstellen.

   

4. Ändern Sie den Namen des Material-Assets in M_BasicColor.

   Das Beispiel-Level des Tutorials verwendet das Präfix M_ als Namenskonvention zur Identifizierung von Materialien.

5. Doppelklicken Sie auf das Material, um es zu öffnen. Dadurch wird der Material-Editor in einem neuen Fenster geöffnet.

Der Material-Editor ist ein knotenbasierter Editor, was bedeutet, dass er einige Ähnlichkeiten mit Blueprint-Visual-Scripting aufweist. Sie sollten einen Knoten mit dem Namen M_BasicColor sehen, der der Knoten ist, mit dem Sie die Eigenschaften des Materials ändern können.

Die Eigenschaft Basisfarbe legt die Farbe des Materials fest. Sie können auf das graue Farbfeld neben Basisfarbe klicken, um die Farbe manuell festzulegen. 

Anstatt den Farbwähler zu verwenden, erstellen Sie einen Farbparameterknoten, den Sie in jeder Material-Instanz überschreiben können. So erstellen Sie ein Material, das viele Farben annehmen kann. Das Erstellen eines Parameters verhält sich wie das Hinzufügen einer Variable – damit wird die Materialfarbe zu einem bearbeitbaren Parameter in einer Material-Instanz.

Um einen Farbparameterknoten zu erstellen, führen Sie die folgenden Schritte aus:

1. Neben Basisfarbe sehen Sie einen Pin. Klicken Sie auf den Pin und ziehen Sie ihn zu einem leeren Bereich im Diagramm. 

   

2. Geben Sie in der Dropdown-Liste VectorParameter in das Suchfeld ein und wählen Sie VectorParameter aus.

   Dadurch wird ein neuer Knoten erstellt, der einem Farbwähler enthält. Eine Variable vom Vektortyp hat drei Werte, sodass Sie sie zum Definieren der RGB-Werte einer Farbe verwenden können.

3. Der Standardname des Knotens, Param, wird hervorgehoben, wenn Sie den Knoten zum ersten Mal erstellen. Benennen Sie den Knoten Farbe um, um ihn in Ihren Material-Instanzen leichter zu identifizieren.

   Wenn Param nicht hervorgehoben ist, klicken Sie auf den Knoten und dann auf den Namen des Knotens, um ihn umzubenennen.

4. Klicken Sie in dem neuen Knoten Farbe auf das karierte Quadrat neben Default Value, um den Farbwähler zu öffnen.

   

5. Ändern Sie im Feld „Hex sRGB“ den Wert in F7DE0000, eine gelbe Farbe, und klicken Sie auf „OK“. 

   

6. Speichern und schließen Sie das Material-Asset.

Als Nächstes erstellen Sie Material-Instanzen, um weitere Farben hinzuzufügen, ohne das Hauptmaterial neu erstellen zu müssen. 

Um drei Material-Instanzen für Ihre Schlüsselfarben zu erstellen, führen Sie die folgenden Schritte aus:

1. Klicken Sie im Inhaltsbrowser mit der rechten Maustaste auf das Asset M_BasicColor, das Sie erstellt haben. Klicken Sie oben im Kontextmenü auf Materialinstanz erstellen.

2. Geben Sie dem Material-Instanz-Asset den Namen M_BasicColor_Red. Doppelklicken Sie auf das Asset, um es zu öffnen.

   

   Sie werden feststellen, dass sich dieses Fenster vom Material-Editor unterscheidet. Das liegt daran, dass eine Material-Instanz nicht den kompletten Schnittplatz eines Materials benötigt – stattdessen konzentriert sie sich auf die Bearbeitung von Parametern, die Sie im Basismaterial definiert haben.

3. Erweitern Sie im Details-Panel oben unter Parameter Gruppen die Option Global Vector Parameter Values.

   

4. Sie sehen eine deaktivierte Farbe. Dabei handelt es sich um den VectorParameter-Knoten, den Sie dem Basismaterial hinzugefügt haben. Klicken auf das Kontrollkästchen neben „Farbe“, um es zu aktivieren und zu überschreiben.

   

5. Klicken Sie auf das Farbfeld neben „Farbe“ und legen Sie den Hex sRGB-Wert auf F7005A00 fest. Dadurch erhält die Material-Instanz eine wunderschöne, feuerrote Farbe!

6. Jetzt sind Sie an der Reihe! Wiederholen Sie diesen Vorgang, um zwei weitere Material-Instanzen zu erstellen: 

   1. Erstellen Sie eine Material-Instanz mit dem Namen M_BasicColor_Blue. Überschreiben Sie die Farbe mit Hex sRGB = 00AFF700 und speichern Sie das Asset. 

   2. Erstellen Sie eine Material-Instanz Mit dem Namen M_BasicColor_Yellow. Behalten Sie die Basismaterialfarbe bei und speichern Sie das Asset.  

Erstellen des Schlüssel-Blueprint

Nachdem Sie nun alle benötigten Teile haben, ist es an der Zeit, den Schlüssel-Blueprint zu erstellen. Der Schlüssel-Blueprint ist ein Asset, das Sie einem Level hinzufügen können, um einen instanzierten Actor zu erstellen, der vom Spieler aufgehoben werden kann.

Um eine neue Blueprint-Klasse für Ihren Schlüssel zu erstellen, führen Sie die folgenden Schritte aus:

1. Gehe zum Inhaltsbrowser und navigiere zum Ordner Inhalt > AdventureGame > Designer > Blueprints.

2. Erstellen Sie einen neuen Ordner mit dem Namen Key.

3. Gehen Sie in den Order Key. Klicken Sie mit der rechten Maustaste in den Ordner und wählen Sie Blueprint-Klasse aus.

4. Wählen Sie Actor als Parent-Klasse aus.

   

5. Nennen Sie den neuen Actor BP_Key und klicken sie doppelt auf ihn, um ihn zu öffnen.

   Das Beispiel-Level des Tutorials verwendet das Präfix BP_ als Namenskonvention zur Identifizierung von Blueprint-Klassen.

Die Parent-Klasse Actor wird üblicherweise für ein Objekt verwendet, das in einem Level platziert werden kann. Sie verfügt nicht über zusätzliche Funktionen wie Bewegung wie die Parent-Klasse „Charakter“, aber sie kann zum Erstellen von Interaktionen und Logik verwendet werden.

Sie müssen dem Schlüssel-Blueprint ein paar Dinge hinzufügen, damit er richtig funktioniert:

1. Ein statisches Mesh, um den Schlüssel in Ihrem Projekt visuell darzustellen.

2. Ein Kollisionsvolumen, das erkennt, wenn der Spieler nahe genug ist, um den Schlüssel aufzuheben.

3. Eine Möglichkeit, zu wissen, um welchen Typ Schlüssel es sich handelt.

4. Spiel-Logik, die bestimmt, was passiert, wenn der Spieler mit dem Schlüssel kollidiert.

Einrichten der Komponenten des Schlüssels 

Richten Sie zunächst die Komponenten des Schlüssels ein, damit Sie etwas haben, das Sie in der Spielwelt platzieren und mit dem Sie interagieren können.

Um dem Schlüssel eine Kollisionskomponente und Mesh-Form hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Wechseln Sie in BP_Key in den Tab Viewport.

2. Klicken Sie im Komponenten-Panel oben links auf Hinzufügen, suchen sich nach Capsule Collision und wählen Sie es aus.

   

   Dies ist das Kollisionsvolumen, das der Spieler berühren kann, um den Schlüssel aufzuheben. Ohne dies wäre der Spieler nicht in der Lage, den Schlüssel zu erkennen. 

   Sie könnten dem Schlüssel-Mesh selbst eine Kollision hinzufügen, aber eine Kollisionsform hilft dabei, komplexe Geometrie auszugleichen, wodurch die Kollisionserkennung und die Spiel-Performance verbessert wird. 

3. Wählen Sie die Kapsel-Komponente aus und klicken Sie erneut auf Hinzufügen. Suchen und wählen Sie dieses Mal eine Kugel als Grundform aus und benennen Sie sie in KeyMesh um. 

   Indem Sie die Kapsel-Komponente auswählen und dann das Kugel-Mesh hinzufügen, wird das Mesh zu einem Child der Kapsel und die Kapsel ist der Parent des Mesh. Die Child-Komponente erbt alle Eigenschaften vom Parent. 

4. Einrichten der KeyMesh-Komponente:

   1. Wählen Sie die KeyMesh-Komponente aus. Wechseln Sie im Details-Panel zur Kategorie Transformieren. Ändern Sie neben Skalierung die Werte auf 0,3, 0,3 und 1,0. 

      

      Dadurch werden die Seiten des Mesh zu einer ovalen Form verkleinert.

   2. Legen Sie in der Kategorie Kollision die Kollisionsvoreinstellungen auf NoCollision fest.

      

      Sie haben der Kapselkomponente eine Kollision hinzugefügt, sodass die Kollision im Mesh deaktiviert wird. Dadurch wird sichergestellt, dass der Spieler-Charakter den Schlüssel problemlos einsammeln kann, ohne vom statischen Mesh abzuprallen.

5. Einrichten der Kapsel-Komponente:

   • Wählen Sie die Kapsel-Komponente aus. Legen Sie im Details-Panel in der Kategorie Transformieren den Ort auf 0,0, 0,0, 80,0 fest.

     Dadurch schwebt der Schlüssel über dem Boden. Das Mesh bewegt sich mit der Kapsel, da es eine Child-Komponente ist, die alle Eigenschaften von ihrer Parent-Komponente erbt.

   • Legen Sie unter der Kategorie Form den Eintrag Capsule Half Height auf 60,0 fest. Dadurch wird das Kollisionsvolumen gestreckt, um das Mesh besser zu umgeben.  

6. Wählen Sie im Komponenten-Panel den Eintrag DefaultSceneRoot aus. Klicken Sie auf Hinzufügen und wähle Sie Rotating Movement aus. Dadurch wird Ihr Schlüssel langsam gedreht, um es für den Spieler interessanter zu machen.

   

7. Speichern und kompilieren Sie den Blueprint.

Einrichten der Eigenschaften des Schlüssels

Ihr Schlüssel muss auch Informationen speichern, z. B. um welchen Typ von Schlüssel es sich handelt und welche Materialien und Meshs zu den einzelnen Schlüsseltypen gehören. 

Um dies einzurichten, verwenden Sie die „Key Type“-Enum und die „Key Data“-Struktur, die Sie zuvor erstellt haben. 

Um dem Blueprint eine Schlüsseltypvariable hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Unter dem Komponenten-Panel sehen Sie das Mein Blueprint-Panel. Klicken Sie in der Sektion Variablen auf die Plus-Schaltfläche, um eine neue Variable hinzuzufügen.

2. Geben Sie der Variable den Namen KeyType.

3. Standardmäßig ist sie vom Typ Boolean. Klicken Sie auf die Dropdown-Liste des Typs und suchen Sie nach Enum Key Type und wählen Sie ihn aus. Dieser Variablentyp ist die Enum, die Sie zuvor erstellt haben. Es ist also an der Zeit, sie zu verwenden! Hier bedeutet das, dass die Variable KeyType auf Rot, Gelb oder Blau festgelegt werden kann.

   In Blueprints wird der Variablentyp auch Pin-Typ genannt, da Variablen als Pins in Knoten erscheinen.

4. Klicken Sie auf das Auge neben der Variable KeyType, um sie zu einer öffentlich und bearbeitbaren Variable zu machen. Dies ist wichtig, damit Sie den Wert dieser Variable später im Unreal Editor bearbeiten und den Typ jedes Schlüssels in Ihrem Level festlegen können.

   

5. Klicken Sie auf KeyType, um ihn auszuwählen. Löschen Sie im Details-Panel neben der Eigenschaft Kategorie den Eintrag Standard und geben Sie Einrichtung ein.

   Dadurch erscheint die Eigenschaft „KeyType“ im Details-Panel unter einer Kategorie mit dem Namen Einrichtung.

   

Jeder Schlüsseltyp sollte eine Form und Farbkombination haben. Im nächsten Schritt erstellen Sie eine Map-Variable, um diese Kombinationen zu definieren.

Um eine Variable einzurichten, die Schlüsseltypen bestimmten Formen und Farben zuweist, führen Sie die folgenden Schritte aus:

1. Fügen Sie im Mein Blueprint-Panel eine neue Variable mit dem Namen KeyMap hinzu, ebenfalls vom Typ Enum Key Type.

2. Wenn Sie die Variable KeyMap ausgewählt haben, finden Sie im Details-Panel neben der Dropdown-Liste des Typs ein weiteres Menü, das den Containertyp der Variable festlegt oder wie viele Werte die Variable enthält. Ändern Sie den Containertyp zu Map.

   

3. Wenn Sie den Map-Container festlegen, erscheint eine weitere Typ-Dropdown-Liste neben dem Containertyp. Dabei handelt es sich um den Typ von Daten, der in jeder Map-Option gespeichert wird. Sie haben diese Schlüsseldaten zuvor in einer Struktur definiert. Klicken Sie also auf die Dropdown-Liste und legen Sie den Datentyp auf Struct_KeyData fest.

4. Kompilieren Sie den Blueprint, damit Sie die KeyMap mit Materialien und Mesh-Formen füllen können, und richten Sie für jede KeyType-Option ein Material-Mesh-Paar ein.

5. Wechseln im Details-Panel zur Kategorie Standardwert.

6. Klicken neben Key Map auf die Plus-Schaltfläche, um der Map ein neues Element hinzuzufügen.

7. Ändern Sie den Key Type von Blau zu einer anderen Farbe. Wenn Sie dies nicht tun, können Sie möglicherweise kein neues Element hinzufügen, da bereits ein Element mit dem Standard-„Key Type“ vorhanden ist.

8. Wiederholen Sie diesen Vorgang zweimal, um das zweite und dritte Element zu erstellen.

9. Nachdem Sie die drei Map-Elemente hinzugefügt haben, richten Sie Ihre Schlüsseltypen mit den folgenden Werten ein:

   Schlüsseltyp	Schlüsselmaterial	Schlüssel-Mesh
   Rot	M_BasicColor_Red	Kegel
   Gelb	M_BasicColor_Yellow	Kugel
   Blau	M_BasicColor_Blue	Würfel

   Im Projekt gibt es mehrere Meshs mit den Namen Cube und Sphere. Die korrekten Cube- und Sphere-Meshs sollten bei der Suche an zweiter Stelle in der Liste erscheinen. Wenn Sie die Maus darüber bewegen, sollte im Tooltip der Pfad /Engine/BasicShapes erscheinen. 

   

   Ihre KeyMap sollte nun in etwa so aussehen: 

   

10. Speichern und kompilieren Sie den Blueprint. 

Schließlich benötigen Sie noch eine Variable, die eine Referenz zum Spieler-Charakter speichert, wenn dieser den Schlüssel berührt. 

Um eine Variable zu erstellen, die eine Referenz zu einem anderen Actor speichert, führen Sie die folgenden Schritte aus:

1. Fügen Sie in der Sektion Variablen eine neue Variable mit dem Namen OtherActor hinzu.

2. Ändern Sie den Typ zu Actor > Objekt-Referenz.

3. Ändern Sie im Details-Panel den Container Typ zu Single, da Sie nur auf einen Actor referenzieren müssen, der mit diesem Schlüssel interagiert – der Spieler.

Nun sollten die Variablen des Schlüssels in etwa so aussehen:

Testen des Schlüssels

Testen Sie den Schlüssel, um zu sehen, wie er jetzt aussieht. 

Kehren Sie in Ihr Level zurück und ziehen Sie BP_Key aus dem Inhaltsbrowser in ihr Level. Sie haben einen Blueprint erstellt, von dem Sie Instanzen zu Ihrem Spiel hinzufügen können, und das ist ein Grund zum Feiern! Er ist jedoch weiterhin grau.

Wechseln Sie mit ausgewähltem Schlüssel zum Details-Panel. Suchen Sie die Kategorie Einrichtung, die Sie erstellt haben, und suchen Sie die Eigenschaft Key Type. Sie können sie von Blau über Gelb zu Rot ändern, aber der graue ovale Schlüssel ändert sich noch nicht. 

Der Grund dafür ist, dass Sie Komponenten und Daten zu Ihrem Schlüssel hinzugefügt haben, aber diese Teile kommunizieren noch nicht miteinander. Hier kommt Blueprint-Visual-Scripting ins Spiel. Sie erstellen Logik (Knoten und Verbindungen), um Informationen in einem Blueprint zu übergeben und Aktionen mit diesen Informationen auszuführen.

Festlegen von Schlüsselwerten mit einer Blueprint-Funktion

Als Nächstes erstellen Sie eine Funktion, die KeyMap-Optionen mit der KeyMesh-Komponente verbindet und automatisch die korrekte Mesh-Form und Materialfarbe für einen Schlüssel basierend auf seinem Typ festlegt.

Anstatt die Funktion im Schlüssel-Blueprint zu erstellen, speichern Sie sie in einer neuen Blueprint-Funktionsbibliothek. Das ist ein Blueprint-Asset-Typ, in dem eine Sammlung wiederverwendbarer Funktionen gespeichert wird. Diese Funktionen sind nicht an einen bestimmten Blueprint oder Actor gebunden. Stattdessen sind sie global im gesamten Projekt zugänglich. Bibliotheken bewahren nützliche Funktionen an einem Ort auf, sodass Sie diese nicht mühsam in mehrere Blueprints kopieren müssen.

Um eine Blueprint-Funktionsbibliothek mit einer neuen Funktion zu erstellen, führen Sie die folgenden Schritte aus:

1. Gehen Sie zum Inhaltsbrowser und navigieren Sie zu Inhalt > AdventureGame > Designer > Core.

2. Klicken Sie mit der rechten Maustaste in den Ordner Core, gehen Sie zu Blueprint, und wähle Sie Blueprint Funktionsbibliothek aus. Nennen Sie das neue Asset BPL_FPGame und öffnen Sie es.

   

3. Im Mein Blueprint-Panel in der Sektion Funktionen beginnen Sie mit einer neuen Funktion, die hervorgehoben ist. Nennen Sie sie fnBPLSetKey.

   

   Das Beispielprojekt des Tutorials verwendet das Label BPL für Funktionen in einer Blueprint Bibliothek und das Präfix fn für Funktionen. Dies hilft dabei, zu identifizieren, was ein SetKey ist und woher er stammt, und macht es einfacher, die Funktion in der Knoten-Aktionsliste zu finden.

Richten Sie als Nächstes die Funktion mit den benötigten Inputs und Outputs ein. 

Inputs sind Werte, die Sie an eine Funktion übergeben, damit diese ihre Arbeit erledigen kann. Sie verhalten sich ähnlich wie Variablen. Die Funktion fnBPLSetKey muss Aktionen zwischen KeyType, KeyMap und KeyMesh ausführen und daher sollten diese Inputs sein.

Outputs sind Informationen, die die Funktion an den Blueprint zurückgibt, normalerweise nachdem sie ein Ergebnis erstellt hat. Die Funktion fnBPLSetKey benötigt keine Outputs. 

Führen Sie die folgenden Schritte aus, um der Funktion fnBPLSetKey Inputs hinzuzufügen:

1. Klicken Sie auf die Funktion fnBPLSetKey, um diese auszuwählen. Klicken Sie im Details-Panel neben der Kategorie Inputs auf die Plus-Schaltfläche, um einen neuen Input zu erstellen.

   Wie bei Variablen hat jeder Input einen Namen, einen Variable Pin-Typ und einen Container-Typ.

2. Ändern Sie den Namen des Inputs in Statisches-Mesh-Array.

3. Ändern Sie den Typ zu einer Statisches-Mesh-Komponente > Objekt-Referenz. Beachten Sie im Knoten-Diagramm der Funktion, dass der violette Funktionsknoten jetzt über einen Pin mit dem von Ihnen erstellten Input hat und der Stil des Pin den Typ widerspiegelt (Statisches-Mesh-Array).

4. Klicken Sie auf die Dropdown-Liste Containertyp neben dem Typ und wählen Sie Array aus.

   

   Ein Array ist eine Variable, die mehrere Werte desselben Typs in einem einzigen Container speichert. Jeder Wert wird als Array-Element gespeichert.

5. Einrichten eines weiteren Input, der der Eigenschaft KeyMap des Schlüssels entspricht:

   1. Fügen Sie einen weiteren Input hinzu und nennen Sie ihn KeyMap.

   2. Klicken Sie auf die Dropdown-Liste Pin-Typ und wählen Sie Enum Key Type aus.

   3. Klicken Sie auf die Dropdown-Liste Containertyp und wählen Sie Map aus.

   4. Klicken Sie auf die Dropdown-Liste Wertetyp und wählen Sie Struct Key Data aus.

6. Einrichten eines Schlüsseltyp-Input:

   1. Fügen Sie einen weiteren Input mit dem Namen Key hinzu.

   2. Legen Sie seinen Container auf Single fest und behalten Sie als Typ Enum Key Typ bei.

Ihre drei Inputs sollten nun so aussehen:

Nun können Sie die Knoten der Funktion erstellen. Im Diagramm-Panel sehen Sie den Funktionseintrittsknoten fnBPLSetKey mit den Inputs, die Sie gerade erstellt haben – einen Statisches-Mesh-Array, einen Key Map und einen Key.

Um der Funktion, die die Schlüssel mit einer neuen Schlüssel-Mesh-Form einrichtet, Logik hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Ziehen Sie den dreieckigen Pin Ausführung (Exec) dieses Knotens, suchen Sie nach For Each Loop und wählen Sie es in der Knotenaktionsliste aus. Dadurch wird ein neuer Knoten erstellt, der mit dem Knoten fnBPLSetKey verbunden ist.

   Mit dem Knoten For Each Loop können Sie mit jedem Element in einem Array bestimmte Aktionen durchführen. Jede Logik, die Sie mit dem Ausführungs-Pin des Schleifenkörpers verbinden, wird einmal pro Array-Element ausgeführt. Ist die Schleife fertig, wird die Ausführung über den Pin „Completed“ fortgesetzt.

   

2. Ziehen Sie den Pin Statisches-Mesh-Array des Knotens fnBPLSetKey und verbinden Sie ihn mit dem Pin Array der For Each Loop.

   

   Der Schlüssel hat nur ein Mesh, aber fnBPLSetKey verwendet ein Statisches Mesh Array, sodass Sie es mit einer Vielzahl von Level-Objekten verwenden können. Im nächsten Teil dieser Tutorial-Reihe arbeiten Sie beispielsweise mit dem Tür-Blueprint, der zwei statische Meshs für die rechte und die linke Tür enthält.

3. Ziehen als Nächstes den Pin Key Map des Knotens fnBPLSetKey und suchen Sie den Knoten Find und wählen Sie ihn aus. Dieser Knoten kann einen Schlüsseltyp entgegennehmen und das entsprechende Mesh und Material aus der KeyMap abrufen.

4. Klicken Sie mit der rechten Maustaste auf den blauen Output-Pin des Knotens Find und klicken Sie auf Struktur-Pin spalten. 

   

   Dies teilt den Output in Key Material und Key Mesh auf, die beiden Variablen in Struct_KeyData sind.

5. Verbinden Sie den Pin Key des Knotens fnBPLSetKey mit dem türkisfarbenen Pin Key des Knotens Find. 

   

6. Ziehen Sie nun im Knoten For Each Loop den Pin Loop Body und suchen Sie in der Kategorie Struct nach Is Valid. Fügen Sie den Knoten Is Valid mit dem Fragezeichensymbol (?) daneben hinzu, da Sie diesen für Strukturwerte verwenden. 

   

   Dieser Knoten prüft, ob eine gültige Mesh-Form an die Funktion übergeben wurde. Wenn dies so ist, legen Sie sowohl das statische Mesh des Objekts als auch dessen Material fest. Wenn nicht, legen Sie nur das Material fest. 

7. Verbinden Sie den Pin Key Mesh des Knotens Find mit dem Pin Input Object des Knotens Is Valid. 

   

8. Ziehen Sie im Knoten Is Valid den Pin Is Valid und schalten Sie die Option kontextabhängig auf False um.

   

9. Suchen Sie nach dem Knoten Set Static Mesh und fügen Sie ihn hinzu.

10. Ziehen Sie den Pin Array Element des Knotens For Each Loop und verbinden Sie ihn mit dem Pin Target des Knotens Set Static Mesh.

    Target ist die Entität, auf der der Knoten agiert. Sie möchten die Aktion „Set Static Mesh“ auf dem KeyMesh ausführen, daher sollte das statische Mesh-Array das Ziel sein.

11. Ziehen Sie vom Knoten Find den Pin Key Mesh und verbinden Sie ihn mit dem Pin New Mesh des Knotens Set Static Mesh. 

Das Diagramm der Funktion sollte nun so aussehen:

Sie können einen Doppelklick auf eine Verbindung zwischen zwei Knoten ausführen, um einen zusätzlichen Connector zu erstellen. Bewegen Sie den Mauszeiger über den Verbinder, bis sich der Cursor in vier Pfeile verwandelt, und ziehen Sie dann den Connector, um die Verbindungen neu zu formen. So können Sie Knoten und Linien frei positionieren.

Wählen Sie eine Verbindung aus und drücken Sie Q, um die Verbindung zu begradigen.

Sie haben die neue Mesh-Form auf dem Schlüssel festgelegt, jetzt müssen Sie nur noch das neue Material festlegen.

Um Logik hinzuzufügen, die die Schlüssel mit einer neuen Schlüsselmaterialfarbe einrichtet, führen Sie die folgenden Schritte aus:

1. Ziehen Sie am Pin Ausführung (Exec) des Knotens Set Static Mesh und suchen Sie nach dem Knoten Set Material (in der Kategorie Rendering > Material) und erstellen Sie diesen.

2. Ziehen Sie seinen Target-Pin zum Array Element des Knotens For Each Loop.

3. Ziehen Sie seinen Material-Pin zum Pin Key Material des Knotens Find.

   

4. Um sicherzustellen, dass das Material festgelegt ist, wenn kein Mesh bereitgestellt wird, verbinden Sie den Pin Is Not Valid des Knotens mit dem Exec-Pin des Knotens Set Material. Fügen Sie zwei Connectors hinzu, um die Verbindung umzuformen.

5. Speichern und kompilieren Sie den Blueprint.

Ihre fertige fnBPLSetKey-Funktion sollte nun folgendermaßen aussehen:

Initialisieren der Schlüssel

Sie sind nun bereit, die Funktionalität zu verwenden, die Sie im Schlüssel-Blueprint erstellt haben. Zuerst initialisieren Sie den Schlüssel basierend auf dem KeyType, den Sie ihm zuweisen. 

Um den Schlüssel zu initialisieren, führen Sie die folgenden Schritte aus:

1. Ziehe den Pin Ausführung (Exec) des Knotens Construction Script und suche nach der Funktion fnBPLSetKey, die du zuvor erstellt hast.

   

   Der Funktionsknoten erfordert ein Static Mesh Array, eine Key Map und einen Key, die du über BP_Key bereitstellst.

2. Erweitere im Mein Blueprint-Panel in der Sektion Variablen die Kategorie Einrichtung und ziehe die Variable KeyType in das Knoten-Diagramm neben dem Funktionsknoten. 

   

3. Sie werden gefragt, ob Sie den Wert der Variablen Abrufen oder Festlegen möchten. In diesem Fall musst du prüfen, um welchen Typ Schlüssel es sich handelt, also wähle Abrufen aus. 

4. Verbinde den Pin des neuen Knotens Get Key Type mit dem Pin Key des Knotens Fn BPLSet Key Knotens.

   

5. Wiederholen Sie diesen Vorgang für die Variable KeyMap. Ziehen Sie ihn in das Knoten-Diagramm und erstellen Sie einen Abrufen-Knoten. Verbinde den Pin dieses Knoten mit dem Pin KeyMap des Knotens Fn BPLSet Key.

   

6. Ziehe als Nächstes aus dem Komponenten-Panel das KeyMesh in das Diagramm und erstellen einen Knoten vom Typ Abrufen. 

7. Der Knoten Key Mesh enthält eine einzelne Statisches-Mesh-Komponenten-Referenz, aber der Funktionsknoten benötigt ein Array. Unreal Engine übernimmt das für dich: Verbinde den Pin Key Mesh mit dem Pin Statisches-Mesh-Array des Knotens Fn BPLSet Key.

8. Speichere und kompiliere deinen Blueprint.

  Das Konstruktions-Script des Schlüssels sollte nun so aussehen: 

Testen der Funktionalität des Schlüssels

Jetzt kannst du die Farbwechselfunktionalität testen, die du in Ihrem Schlüssel und Ihrer neuen Funktion erstellt hast. 

Schließe das Blueprint-Editor-Fenster und gehe zum Level-Editor zurück.  

Da der Standardwert für Key Type Blau ist, sollte dein Schlüssel als blaues Rechteck initialisiert werden. 

Wählen Sie den Schlüssel-Actor aus und ändern Sie im Details-Panel in der Sektion Einrichtung den Key Typ zwischen Gelb und Rot. Während Sie ihn ändern, sollten Sie sehen, wie der Schlüssel seine Farbe und Form im Level aktualisiert!

Wenn Ihr rechteckiger und ovaler Schlüssel zu groß erscheinen, haben Sie möglicherweise die falschen Mesh-Assets bei der Erstellung der KeyMap ausgewählt. Kehre zurück zu den Details deiner KeyMap und vergewissere dich, dass die Kugel- und Würfel-Meshs aus dem Pfad /Engine/BasicShapes stammen.

Gewähren von Schlüsseln an den Spieler-Charakter

Ihr Spieler muss eine Möglichkeit haben, Schlüssel aufzuheben, und andere Objekte müssen wissen, welche Schlüssel der Spieler besitzt. Um das Gewähren und den Erhalt von Schlüsseln zu verwalten, verwendest du ein Blueprint-Interface.

Verwenden eines Blueprint-Interface zur Kommunikation zwischen Blueprints 

Ein Blueprint-Interface speichert eine Liste von Funktionen, die von jedem Blueprint verwendet werden können, der Zugriff auf das Interface hat. Ein Interface zu implementieren bedeutet, deinem Entwurf die Möglichkeit zu geben, auf einen gemeinsamen Satz von Events (oder Nachrichten) zu reagieren.

In einem Spiel, in dem Spieler- und NPC-Charaktere herumlaufen, muss der Schlüssel eine Möglichkeit bieten, sicherzustellen, dass er nur mit dem Spieler-Charakter interagiert. Dazu erstellen Sie ein Blueprint-Interface, das in BP_AdventureCharacter implementiert wird. Dies fungiert als Erlaubnisschein, den der Spieler-Blueprint verwendet, um auf die Schlüssel-Aufheben-Nachricht zu hören. 

Blueprint-Interfaces sind nützlich, wenn du verschiedene Blueprints kommunizieren lassen möchtest, ohne die Details der anderen Blueprints zu kennen.

Um ein Blueprint-Interface mit zwei Funktionen zu erstellen, führe die folgenden Schritte aus:

1. Gehe in den Inhaltsbrowser und navigiere zu Inhalt > AdventureGame > Designer > Blueprints > Core.

2. Klicken Sie mit der rechten Maustaste im Ordner Core, gehe Sie zu Blueprint und erstelle Sie ein neues Blueprint-Interface. Nennen Sie das Asset BPI_PlayerKeys und öffnen Sie es mit einem Doppelklick.

   Dieses Fenster sieht ähnlich aus wie der Blueprint-Editor. Auf der rechten Seite sehen Sie das Mein Blueprint-Panel, in dem alle Funktionen des Interface aufgelistet sind. Darunter befindet sich das Details-Panel.

3. Im Mein Blueprint-Panel gibt ist bereits eine anfängliche Funktion vorhanden, die für Sie erstellt wurde. Nenne sie fnBPIAddKey.

4. Wähle die Funktion aus und klicke im Details-Panel in der Sektion Inputs auf die Plus-Schaltfläche, um einen neuen Input hinzuzufügen.

5. Nenne den Input KeyType und ändere seinen Typ in Enum Key Type.

   

6. Geben Sie im Details-Panel neben Kategorie Keys ein. Dadurch lässt sich deine Funktion in der Interface-Liste der Blueprints leichter finden.

7. Füge als Nächstes eine neue Funktion im „Mein Blueprint“-Panel mit dem Namen „fnBPIGetKeys“ hinzu, die das Abrufen von Schlüsseln übernimmt. 

   

8. Wähle die neue Funktion fnBPIGetKeys aus und klicke im Details-Panel in der Sektion Outputs auf die Plus-Schaltfläche, um einen neuen Parameter mit dem Namen Held Keys hinzuzufügen. 

9. Ändere den Typ zu Enum Key Type und den Ergebniswert zu Array , damit er die gefundenen Schlüssel des Spielers zurückgeben kann. 

   

10. Speichern und kompilieren Sie Ihr Interface. Nun kanst du das Fenster BPI_PlayerKeys schließen.

    Da ein Interface mit dem Blueprint-System zusammenhängt, musst du es wie Blueprints kompilieren.

Beachten Sie, dass Sie im Blueprint-Interface nur Funktionsdeklarationen erstellt haben. Interface-Funktionen enthalten selbst keine Logik, aber deine Einrichtung legt fest, wie du diese in Blueprints einsetzen kannst. 

Interface-Funktionen ohne Outputs (fnBPIAddKeys) agieren wie Events, während Funktionen mit Outputs (fnBPIGetKeys) wie reguläre Funktionen funktionieren, denen Sie Logik hinzufügen können.

Erstellen eines neuen Spieler-Charakters

Bevor Sie dem Charakter etwas hinzufügen, duplizieren Sie einen Standard-Spieler-Charakter, der mit dem Projekt geliefert wird, um Ihre eigene Variante zu erstellen. Du musst außerdem deine Spiel-Moduseinstellungen ändern, um deinen neuen Charakter verwenden zu können.

Um einen Spieler-Charakter zu erstellen, der in deinem Projekt verwendet werden soll, führe die folgenden Schritte aus:

1. Gehe zum Inhaltsbrowser und navigiere zum Ordner Inhalt > AdventureGame > Designer > Blueprints.

2. Erstelle einen neuen Ordner mit dem Namen Characters.

3. Gehe zum Ordner Inhalt > Variant_Shooter > Blueprints > FirstPerson.

4. Ziehe das BP_ShooterCharacter-Asset in den Ordner Characters, den du erstellt hast und wähle Hierher kopieren aus.

5. Klicke mit der rechten Maustaste auf die neue Kopie im Ordner Characters, um sie in BP_AdventureCharacter umzubenennen.

6. Gehe zu Edit > Project Settings. Gehe im linken Panel zu den Einstellungen Projekt > Karten und Modi.

7. Erweitere unter der Einstellung Standard-GameMode den Eintrag Ausgewählter GameMode.

   Ein Spiel-Modus-Asset, das einen Satz von Regeln für die Welt definiert – einschließlich des Standard-Spieler-Charakters. Sie müssen diesen ändern, um den neuen Charakter zu verwenden, den Sie erstellt haben. Du kannst die Spiel-Modus-Einstellungen hier ändern, oder indem du das Asset selbst öffnest.

8. Ändere Default Pawn Class in BP_AdventureCharacter.

   

9. Schließe das Fenster Projekt-Einstellungen.

Um die Spiel-Moduseinstellungen pro Level statt für Ihr gesamtes Projekt zu ändern, verwenden Sie Welteinstellungen. Du findest diesen Tab neben dem Details-Panel.  

Wenn du das Welteinstellungen-Panel nicht siehst, gehe in der Hauptmenüleiste zu Fenster und wähle Welteinstellungen aus. 

Hinzufügen des Blueprint-Interface zum Spieler 

In diesem Abschnitt werden Sie den Blueprint des Spieler-Charakters modifizieren. Für diesen Charakter sind bereits viele hilfreiche Funktionen und Interfaces für dich eingerichtet. Du fügst die zuvor erstellte Schnittstelle BPI_PlayerKeys hinzu, damit er Schlüssel aufheben kann.

Als Nächstes wirst du den neuen BP_AdventureCharacter so modifizieren, dass er Schlüssel verwendet. 

Um dem Charakter die Blueprint-Interface-Funktionen hinzuzufügen, führen die folgenden Schritte aus:

1. Navigiere zu deinem neuen Characters-Ordner und öffne den BP_AdventureCharacter.

2. Sie fügen das Interface BPI Player Keys hinzu, um sicherzustellen, dass der Spieler-Blueprint sie implementiert. Klicke in der Symbolleiste oben im neuen Fenster auf die Schaltfläche Klasse-Einstellungen.

3. Klicken Sie im Details-Panel auf der rechten Seite in der Sektion Interfaces > Implemented Interfaces auf Hinzufügen und wählen Sie dann BPI_PlayerKeys aus der Dropdown-Liste aus. Dadurch erhält dein Charakter die Möglichkeit, die Funktionen fnBPIGetKeys und fnBPIAddKey zu implementieren.

   

4. Kompilieren Sie den Blueprint, damit Sie die Funktionen des Interface nutzen können. In der Sektion Interfaces des Mein Blueprint-Panel sehen Sie die Kategorie Schlüssel, die fnBPIAddKey und fnBPIGetKey enthält. Das Symbol ist gelb anstatt grau, was bedeutet, dass die Funktionen wie Events agieren. 

Speichern von aufgehobenen Schlüsseln 

Der Spieler muss die eingesammelten Schlüssel speichern, also erstellen Sie dafür eine neue Variable. Die Variable muss bis zu drei Schlüssel enthalten, daher sollte sie ein Array sein.

Führe die folgenden Schritte aus, um eine Array-Variable zu erstellen, in der die Schlüssel des Spielers gespeichert werden:

1. Füge im Blueprint BP_AdventureCharacter eine neue Variable zur Variablenliste im Mein Blueprint-Panel hinzu.

2. Gib der Variable den Namen Held Keys.

3. Wählen Sie die Variable aus und legen im Details-Panel den Container auf ein Array des Typs Enum Key Type fest. Die Verwendung eines Array ist wichtig, da der Spieler mehrere Schlüssel gleichzeitig halten kann.

   

Führe die folgenden Schritte aus, um dem Array Held Keys Schlüssel hinzuzufügen, wenn der Spieler einen Schlüssel aufhebt:

1. Gehe zum Tab EventGraph des Charakters.

2. Klicken Sie mit der rechten Maustaste in das Diagramm und suchen Sie nach dem Event fnBPIAddKey. Das ist der Event-Knoten, der ausgeführt wird, wenn die Funktion fnBPIAddKey aufgerufen wird.

3. Ziehen Sie von seinem Ausführungs-Pin und suche nach Array Add und wählen Sie einen Knoten vom Typ Add aus. Dieser Knoten nimmt ein neues Element und fügt es einem Array hinzu.

4. Füge eine Referenz zur Held Keys-Variable hinzu, indem du die Variable in den EventGraph ziehst und wähle Abrufen aus.

5. Verbinden Sie den Knoten Held Keys mit dem Input Target Array des Knotens Array Add. Dieser Pin sieht aus wie ein Quadrat.

6. Verbinde den Pin Key Typ des Event-Knotens mit dem Input New Item des Add-Knotens.

   

Wenn diese Event-Funktion nun ausgelöst wird, fügt der Spieler-Charakter den bereitgestellten Key Type zu seinem Held Keys-Array hinzu.

Abrufen der Schlüsselliste des Spielers

Die Tür, mit der du im nächsten Teil dieses Tutorials arbeitest, muss alle Schlüssel des Spielers prüfen. Füge dem Spieler daher eine Funktionalität hinzu, die ein Array der von ihm aufgenommenen Schlüssel zurückgibt.

Führe die folgenden Schritte aus, um das Abrufen von Schlüsseln zu handhaben:

1. Erweitere im Blueprint BP_AdventureCharacter unter Mein Blueprint > Interfaces den die Sektion Schlüssel.

   

    In der Liste hat fnBPIGetKeys ein graues Symbol, was bedeutet, dass du es als eine reguläre Funktion und nicht nur als ein Event verwenden kannst.

2. Doppelklicke auf fnBPIGetKeys, um das Diagramm der Funktion zu öffnen.

3. Füge eine Referenz zur Variable Held Keys hinzu, indem du diese ziehen und Abrufen auswählst.

4. Verbinde den Knoten Get Held Keys mit dem Pin Held Keys des Knotens Return.

Das fnBPIGetKeys Diagramm sollte nun in etwa so aussehen:

Kollisionen der Schlüssel mit dem Spieler erkenne

Als Nächstes fügen Sie eine Funktionalität hinzu, die die Event-Funktion fnBPIGetKeys auslöst, wenn der Spieler einen Schlüssel aufhebt. Das sollte passieren, wenn der Spieler das Kollisionsvolumen des Schlüssels berührt. 

Sie fügen ein Event hinzu, das zur Kapsel-Kollisionskomponente gehört. Ein Event wird ausgelöst, wenn im Gameplay etwas passiert. In diesem Fall soll der Schlüssel einige Aktionen ausführen, wenn sich der Spieler-Actor mit der Kapsel des Schlüssels überlappt.

Führe die folgenden Schritte aus, um ein Überlappungs-Event hinzuzufügen und zu prüfen, ob der überlappende Actor der Spieler ist:

1. Öffne deinen BP_Key-Blueprint und navigiere zu einem leeren Bereich im EventGraph.

2. Klicken Sie im Komponenten-Panel mit der rechten Maustaste lauf die Kapsel-Komponente und wählen Sie dann Event hinzufügen > OnComponentBeginOverlap hinzufügen aus. Der assoziierte Knoten erscheint in Ihrem Event-Diagramm. Dieser Event- Knoten wird ausgelöst, wenn es zu einer Überlappung zwischen diesem und einem anderen Actor kommt.

   

   Der Event-Knoten enthält Informationen über dieses Event. Beispielsweise wird der überlappende Actor, der das Event ausgelöst hat, durch den Pin Other Actor geleitet.

3. Ziehen Sie Ihre OtherActor-Variable aus der Variablenliste in Ihr Diagramm und wählen Sie Festlegen aus. Ein Knoten vom Typ Set speichert einen neuen Wert in dieser Variable.

4. Ziehen Sie den Pin Ausführung (Exec) des Event-Knotens OnComponentBeginOverlap und verbinden Sie ihn mit dem Input Ausführung (Exec) des Knotens Set Other Actor. 

5. Ziehen Sie den Pin Other Actor des Event-Knotens OnComponentBeginOverlap und verbinden Sie ihn mit dem Input Other Actor des Knotens Set Other Actor.

   

6. Bevor Sie irgendetwas mit dem Schlüssel tun, prüfen Sie, ob der überlappende Actor der Spieler ist, da dies der einzige Charakter ist, der Schlüssel sammeln können sollte. Sie wissen, dass es der Spieler ist, wenn er das Blueprint-Interface besitzt.

   Klicken Sie in der Nähe des Set-Knotens mit der rechten Maustaste und fügen Sie einen Knoten vom Typ Does Object Implement Interface hinzu.

7. Ändern Sie auf im Knoten Does Object Implement Interface den Pin Interface in BPI_PlayerKeys.

8. Verbinden Sie den Input-Pin Test Object mit dem blauen Pin des Knotens Set Other Actor. Dieser Pin funktioniert wie ein Get Other Actor-Knoten.

9. Ziehen Sie im Knoten Does Object Implement Interface den Pin Return Value und fügen Sie einen Knoten vom Typ Branch hinzu. 

10. Verbinden Sie den Input Pin Ausführung (Exec) des Knotens Branch mit dem Knoten Set. 

    

Ein Branch-Knoten prüft, ob eine Bedingung True oder False ist, damit Sie für jedes Ergebnis eine andere Aktion ausführen können. Hier erstellen Sie eine Logik für zwei Szenarien, True und False, basierend darauf, was passiert, wenn der überlappende Actor der Spieler ist oder nicht. 

Führen Sie die folgenden Schritte aus, um die Schlüssel-Hinzufügen-Funktion aufzurufen, wenn der Spieler den Schlüssel berührt hat:

1. Wenn das Branch-Ergebnis True ist, kann der Actor Schlüssel aufheben und so die Event-Funktion des Interface auslösen. Ziehen Sie den Pin True des Knotens Branch und fügen Sie einen Knoten vom Typ Fn BPIAdd Key (Message) hinzu.

   Sie fügen einen Nachrichtenknoten anstelle eines regulären Funktionsknotens hinzu, da Sie beim Aufrufen einer Blueprint-Interface-Funktion eine Nachricht senden. Der Blueprint Target antwortet nur, wenn er das Interface implementiert.

2. Ziehen Sie am Pin Target des Knotens Fn BPIAdd Key und fügen Sie einen Knoten vom Typ Get Other Actor hinzu.

3. Ziehen Sie den Pin Key Type und fügen Sie einen Knoten vom Typ Get Key Type hinzu. Dies ist eine weitere Möglichkeit, Variablenreferenzen hinzuzufügen. 

   

4. Wenn der Schlüssel aufgehoben wird, sollte er nach einer kurzen Verzögerung verschwinden, sodass er nicht noch einmal aufgehoben werden kann. Ziehen Sie den Pin Ausführung (Exec) des Knotens Fn BPIAdd Key und fügen Sie einen Knoten vom Typ Delay hinzu. Behalten Sie die Standard-Dauer von 0,2 bei. 

5. Nach Ablauf des Timer sollte Ihr Schlüssel verschwinden. Verbinden Sie daher einen Knoten vom Typ Destroy Actor mit dem Pin Completed des Knotens Delay. Vergewissern Sie sich, dass Target auf Self festgelegt ist, was bedeutet, dass der Key-Actor sich selbst aus dem Level entfernen soll.

   

6. Speichern und kompilieren Sie Ihren Blueprint.

  Das vollständige Event-Diagramm des Schlüssels sollte nun wie folgt aussehen: 

Testen des endgültigen Schlüssels

Kehren Sie in Ihr Level zurück und fügen Sie einen Schlüssel in jeder Farbe hinzu. Sie können nun versuchen, die Schlüssel im Spiel aufzuheben, indem Sie über sie gehen.

Als Nächstes

Im nächsten Abschnitt werden Sie den Tür-Blueprint ändern, damit Sie wie die Schlüssel die Farbe ändern und geschlossen bleiben, bis der Spieler den entsprechenden Schlüssel aufgehoben hat.

Öffnen von Türen mit Schlüsseln

Konfigurieren Sie den BP_DoorFrame-Blueprint so, dass die Türen ihre Farbe ändern und sich nur mit dem passenden BP_Key öffnen lassen.