Fallen und Schaden

Umweltgefahren spielen eine große Rolle bei der Gestaltung des Gameplays. Durch den Einsatz von Gefahren und Fallen fügst du dem Spieler Konsequenzen hinzu und steigerst den Schwierigkeitsgrad und die Spannung, während er ein Rätsel oder Level durchspielt. 

In diesem Teil der Tutorial-Reihe erstellst du eine Stachelfalle und eine Feuerfalle, die dem Spieler Schaden zufügen können. Dann verbindest du deine Feuerfalle und wechseln Gameplay-Objekte, um eine neue Gameplay-Mechanik und ein neues Rätsel zu erstellen. 

Da der Spieler nun Schaden nehmen und seine gesamte Gesundheit verlieren kann, richtest du auch eine Fehlerbedingung ein, die das Spiel beendet und neu startet, sodass die Spieler die Möglichkeit haben, es erneut zu versuchen. 

Bevor du anfängst

Stelle sicher, dass du die Themen verstehen, die in den vorherige Sektionen von Entwerfen eines Rätsel-Abenteuers behandelt wurden:

• Blueprints-Grundlagen wie Variablen, Funktionen, Event-Diagramme und das Hinzufügen von Knoten.

• Verwendest du Blueprint-Interface-Events, um einen Schalter zu veranlassen, ein anderes Gameplay-Objekt umzuschalten.

Du benötigst die folgenden Assets von Erstellen eines Schlüssels und Rätsel: Schalter und Würfel:

• M_BasicColor-Material undM_BasicColor_Rot-Materialinstanz

• BPI_Interaktion Blueprint-Interface

• BP_Switch Blueprint-Klasse 

Erstelle einen Satz verwandter Blueprint-Klassen

Im Laufe dieser Tutorialreihe bist du auf Unreal Engine-Assets gestoßen, die Parent-Child-Beziehungen und Vererbung verwenden. Nachlass bedeutet, eine neue Child-Klasse zu erstellen, welche die Funktionen einer vorhandenen Parent-Klasse wiederverwendet und erweitert. Die Child-Klasse kann diese Funktionen vergrößern, ohne den Parent zu ändern. Durch die Vererbung sparen Sie Zeit, da nützliche Funktionen in vielen Assets wiederverwendet werden, anstatt sie jedem neuen Asset manuell hinzuzufügen.

Ihre Materialinstanz-Assets erben Funktionen von ihren Parent-Materialien. In vielen Ihrer Blueprints hast du Komponenten erstellt, die Transformationsdaten von einer Parent-Komponente erben. 

In Spielen kommen unterschiedliche Gefahrenarten zum Einsatz, doch die Kernfunktionen sind oft dieselben. Ein Parent-Trap-Blueprint kann diese gemeinsamen Funktionen definieren, während jeder Child-Trap-Blueprint diese Funktionen erweitert und unterschiedliche visuelle Elemente und Verhaltensweisen hinzufügt. 

Ihre Basisfalle (Parent-Falle) muss Spielerüberschneidungen erkennen und die Schadensspielmechanik verwenden, um die Gesundheit der Spieler mit der Zeit zu verringern. Anschließend erstellst du Child-Traps (oder unterteilen sie in Unterklassen), um die Funktionen der Basis-Trap zu erweitern und zusätzliche visuelle Elemente oder Verhaltensweisen hinzuzufügen. Die Stachelfalle fügt ihrem Erscheinungsbild zusätzliche statische Meshs hinzu und die Feuerfalle fügt einen Feuereffekt und ein Verhalten hinzu, mit dem sie ein- und ausgeschaltet werden kann.

Ihr Level befindet sich noch in der Blockout-Phase. Konzentriere dich daher darauf, eine vereinfachte Version jeder Falle zu erstellen, die dennoch das zukünftige visuelle Design beeinflusst.

Erstelle den Basisfallen-Blueprint

Erstelle zunächst die Basis-Trap-Blueprint-Klasse als Parent und Grundlage für Ihre speziellen Traps.

Um einen Blueprint zu erstellen, der allgemeine Trap-Funktionen definiert, gehe folgendermaßen vor:

1. Im Inhaltsbrowser, gehe zum Ordner Inhalt > AdventureGame > Designer > Blueprints und erstelle einen neuen Ordner mit dem Namen Fallen.

2. Im Fallen-Ordner klicken mit der rechten Maustaste oder klicke auf Hinzufügen und erstelle eine neue Blueprint-Klasse.

3. Im Parent-Klasse auswählen-Fenster, klicke aufActor.

4. Benenne diese Klasse BP_TrapBase und öffne sie.

Komponenten hinzufügen

Für die Basisfalle erstellst du ein statisches Mesh im Blockout-Stil, um die Grenzen der Falle anzuzeigen. Alle Fallen benötigen außerdem ein Kollisionsvolumen, um zu erkennen, wann der Spieler auf sie tritt.

Um die physischen Komponenten der Basisfalle zu erstellen, gehe folgendermaßen vor:

1. Im Tab Komponenten klickst du auf Hinzufügen und suchst und fügst eine Würfel statische Meshform hinzu.

2. Benenne die Mesh-Komponente TrapBase.

3. Im Details-Panel unter Transformieren, ändere den Maßstab des Würfels auf 2, 2, 0,1, um eine flache quadratische Basis zu schaffen.

   

4. Im Tab Komponenten, wenn TrapBase ausgewählt ist, klicke auf Hinzufügen und suche und wähle eine Box-Kollision-Komponente.

5. Benenne die Kollisionskomponente TrapTrigger. Dies ist das Kollisionsvolumen, das du verwendest, um zu erkennen, wann der Spieler auf der Falle steht.

   Genau wie bei BP_Switch, befestigst du die Kollisionskomponente am Mesh. Wenn du also die Größe der Falle ändern möchtest, passt sich der Auslösebereich automatisch an.  

6. Im Details-Panel unter Transformierenändere die folgenden Eigenschaften, um eine große Kollisionsbox über dem Basis-Mesh zu erstellen:

   1. Stelle den Standort auf 0, 0, 400 ein.

   2. Stelle den Maßstab auf 1,5, 1,5, 12 ein.

   

Variablen hinzufügen

Alle Traps benötigen außerdem bearbeitbare Eigenschaften, mit denen du Folgendes anpassen kannst:

• Ob die Gefahr aktiv oder inaktiv ist.

• Der Schaden, den die Falle dem Spieler zufügt.

• Das Schadensintervall oder die Zeit zwischen den Treffern.

und die Falle muss wissen, wer mit ihr kollidiert ist.

Um der Basisfalle gemeinsame Eigenschaften hinzuzufügen, führe die folgenden Schritte aus:

1. Im Tab Mein Blueprint erstelle die folgenden Variablen:

   Variablenname	Typ	Kategorie	Standardwert
   Aktiv	boolesch	Einrichtung	Ja
   BaseDamage	Float	Einrichtung	5,0
   DamageInterval	Float	Einrichtung	1,0

      Kompiliern nach dem Erstellen einer Variable Ihren Blueprint, um einen Standardwert hinzuzufügen.

2. Klicke auf das Augensymbol jeder Variable, sodass das Auge geöffnet wird und alle drei Variablen bearbeitet und öffentlich werden.

3. Füge eine Variable mit dem Namen Anderer Actor hinzu und änder den Typ auf Actor (Objektreferenz).

   

Erstelle eine Funktion zum Anwenden von Schaden

Nachdem deine Falle nun über die grundlegenden Eigenschaften verfügt, kannst du mit der Erstellung des Verhaltens der Falle beginnen. Alle Fallen sollten die Trefferpunkte (KP) des Spielers in regelmäßigen Abständen senken, wenn der Spieler das Kollisionsvolumen überlappt. 

Unreal Engine verfügt über integrierte Lösungen für viele gängige Gameplay-Mechaniken, darunter das Zufügen und Erleiden von Schaden.

Für die Falle verwendest du den eingebauten Schaden anwenden-Funktionsknoten. Um die Schadensbehandlungslogik zu organisieren, erstelle Ihre eigene Funktion, die Schaden anwenden auf alle Charaktere aufruft, welche die Falle berühren, wenn die Falle aktiv ist.

Befolge diese Schritte, um eine Funktion zu erstellen, die dem Spieler Fallenschaden zufügt:

1. In der Sektion Funktionen klicke aufHinzufügen. Benenne diese Funktion fnApplyDamageToTargets und öffne das zugehörige Diagramm.

2. Du möchtest nur Schaden zufügen, wenn die Falle eingeschaltet und aktiv ist, also füge einen Verzweigung-Knoten hinzu, in dem der Zustand eine Referenz ist (Holen) zur Aktiv-Variable.

   

3. Später in diesem Tutorial wirst du einige NPC-Feinde hinzufügen, sodass es möglich ist, dass viele Actors gleichzeitig in der Falle stecken. Wenn die Falle aktiv ist, durchläufst du ein Array aller Actors, welche die Falle berühren:

   1. Verbinde den vom Verzweigung-Knoten besessenen True-Pin an einen Für jede Schleife-Knoten.

   2. Für den Array-Input der Schleife musst du ein Array aller überlappenden Actors erstellen. Unreal Engine erledigt dies für dich – füge ein Überlappende Actors holen (TrapTrigger)-Knoten hinzu. Der Knoten enthält eine Referenz auf TrapTrigger als sein Ziel.

   3. Ändere im Überlappende Actors erhalten-Knoten den Klassenfilter zu Charakter, damit Spieler und NPC -Charaktere zum Array hinzugefügt werden können.

      

4. Wendenst du für jedes Array-Element oder jede Iteration der Schleife die in der BaseDamage-Variable festgelegte Menge an Schaden auf den Actor in diesem Array Element an. Verbinde dazu einen Schaden anwenden-Knoten mit dem Schleifenkörper.

   

   Die Schaden anwenden-Funktion stammt aus der Spielestatistik-Bibliothek der Unreal Engine. Das Symbol in der oberen rechten Ecke bedeutet, dass die Funktion in Netzwerkspielen verwendet und auf dem Server ausgeführt werden kann.

5. Richte den Schaden anwenden-Knoten ein:

   1. Für den Beschädigter Actor-Pin, verbinde das Array-Element der Schleife.

   2. Für den Basisschaden-Pin, verbinde eine Referenz mit der Basisschaden-Variable.

   

6. Speicher und kompiliere dein Blueprint.

Ihre komplette fnApplyDamageToTarget-Funktion sollte wie folgt aussehen:

Erstelle einen Timer, der Schaden im Laufe der Zeit verursacht

Als Nächstes musst du dafür sorgen, dass die Falle in regelmäßigen Zeitabständen die Funktion „Schaden anwenden“ aufruft. Dazu verwendest du eine der Timerfunktionen der Unreal Engine, um einen Timer zu erstellen. 

In diesem Blueprint verwendest du Timer nach Funktionsnamen einstellen:

Dieser Knoten erstellt einen Timer und bindet eine Funktion an diesen Timer, sodass der Knoten nach Ablauf des Timers die Funktion aufruft und alle Actions in dieser Funktion ausführt. 

Um einen Timer für den Spielstart einzurichten, gehe folgendermaßen vor:

1. Gehe zum von BP_TrapBase besessenen Event-Diagramm-Tab. Löschst du die bereitgestellten Knoten Event ActorBeginOverlap und Event Tick.

2. Bevor die Falle irgendwelche Actions ausführt, möchtest du überprüfen, ob sie aktiv ist. Aus dem Event BeginPlay-Knoten, fügst du einen Verzweigung-Knoten hinzu, in dem der Zustand eine Referenz auf die Aktiv-Variable ist.

3. Aus dem vom Verzweigung-Knoten besessenen True-Pin, erstelle einen Timer nach Funktionsnamen einstellen-Knoten.

4. Richte den Timer-Knoten ein:

   1. Für den Zeit-Pin, verbinde eine Referenz mit der Schadensintervall-Variable.

      

   2. Klicke auf das Textfeld neben Funktionsname und gebe fnApplyDamageToTarget ein.

      Stelle sicher, dass du den Funktionsnamen richtig geschrieben hast, da die Logik sonst nicht ordnungsgemäß ausgeführt wird.

   3. Schleifen aktivieren

5. Timer einstellen-Knoten geben einen Ergebniswert namens Timer-Handle aus, das als Trackingnummer oder Controller für den Timer fungiert. Um den Timer zu stoppen, anzuhalten oder fortzusetzen, verweise auf diesen Timer-Handle. Speichere ihn daher in einer neuen Variable:

   1. Im Mein Blueprint-Panel erstelle eine neue Variable mit dem NamenTimerHandler. Ändere den Typ auf Timer-Handle.

   2. Füge einen Timer-Handler festlegen-Knoten hinzu und verbinde ihn mit dem Ergebniswert und den exec-Pins von Timer nach Event einstellen.

      

6. Wenn Unreal Engine einen Timer erstellt, beginnt dieser sofort zu laufen. Du musst den Timer also anhalten, bis ein Charakter in die Falle tritt. Verbinde einen Pausentimer per Handle-Knoten und gib ihm Ihren TimerHandler.

   

7. Speicher und kompiliere dein Blueprint.

Du kannst auch Timer mit einem Timer nach Event einstellen-Knoten erstellen. Hier verwendest du die Knotenactionsliste, um Benutzerdefiniertes Ereignis hinzufügen und verwendest du es als delegieren, um Actions an den Timer zu binden. 

Benutzerdefinierte Events sind wiederverwendbare, benannte Logikblöcke, die Funktionen ähneln. Im Gegensatz zu Funktionen können sie Verzögerungen, Zeitleistenknoten und andere latente Actions enthalten. Daher musst du diese Methode möglicherweise verwenden, wenn die Komplexität deines Spiels zunimmt.

Verbinde den quadratischen Delegate-Pin eines Events, um eine Referenz dieses Events an den Timer-Knoten zu übergeben. Dadurch wird das Event nicht ausgelöst, sondern es werden das Event und seine Actions für später gespeichert (wenn das Zeitintervall abläuft).

Starten und Stoppen von Schäden

Du hast den Schadenstimer erstellt und angehalten, sodass er bereit ist und wartet. Lass den Schaden nun wieder einsetzen, wenn ein Charakter auf den Kollisionsbereich der Falle tritt, und pausiere den Schaden, wenn die Charaktere den Bereich nicht mehr überlappen.  

Um eine Logik hinzuzufügen, die den Schaden auslöst, führe die folgenden Schritte aus:

1. Im Komponenten-Panel klicke mit der rechten Maustaste auf die Fallenauslöser-Komponente, gehe zu Event hinzufügen und wähle OnComponentBeginOverlap hinzufügen aus.

2. Nach dem Event verbinde einen Anderen Actor einstellen-Knoten, um den überlappenden Actor in der Variable zu speichern.

3. Verbinde das Event und die Andere Actor-Pins des Einstellen-Knotens.

4. Verbinde einen fnApplyDamageToTarget-Knoten, sodass der Charakter beim Berühren der Falle sofort Schaden erleidet.

   

5. Verbinde einen Timer per Handle fortsetzen-Knoten, um den Timer und die Schadensintervalle fortzusetzen. Für seine Input verarbeiten, verbinde eine Referenz mit der TimerHandler-Variable.

   

Um eine Logik hinzuzufügen, die den Schaden mit der Zeit stoppt, führe die folgenden Schritte aus:

1. Klicke mit der rechten Maustaste auf die TrapTrigger-Komponente, gehe zu Event hinzufügen > Bei Überlappung des Komponentenendes.

2. Nach dem Event verbinde einen Pausentimer per Handle-Knoten, und gebe ihm erneut eine Referenz auf TimerHandler.

   

3. Speicher und kompiliere dein Blueprint.

Die Falle erstellt, startet und pausiert jetzt einen Schadenstimer.

Das fertige BP_TrapBase-Event-Diagramm sollte wie folgt aussehen:

Weitere Informationen zu Timern und Timerverwaltung findest du unter Gameplay Timers.

Teste die Basisfalle

Um die Falle zu testen, füge eine Print String-Nachricht hinzu, die auf dem Bildschirm meldet, wenn die Falle Schaden verursacht. 

Um eine Meldung auf dem Bildschirm auszudrucken, die anzeigt, dass die Falle wie vorgesehen funktioniert, gehe wie folgt vor:

1. In BP_TrapBase, gehe zum fnApplyDamageToTarget-Tab.

2. Verbinde im Funktionsdiagramm einString ausgeben-Knoten nach dem Schaden anwenden-Knoten.

3. Ändere In String auf Spieler getroffen!

4. Klicke auf den Pfeil unten im String drucken-Knoten, um weitere Optionen anzuzeigen, und ändere die Dauer auf 5. Dadurch ist es einfacher, den Schaden im Laufe der Zeit zu erkennen.

   

5. Kompiliere und Speichere den Blueprint. Im Inhaltsbrowser, ziehe eine Instanz vonBP_TrapBase in dein Level.

6. Spiele das Level und trete in die Falle. Jede Sekunde sollte eine neue „Spieler getroffen!“-Meldung erscheinen.

   

Unterklasse einer Stachelfalle

Nachdem du deine Parent-Klasse abgeschlossen hast, ist es Zeit, mit der Unterklassenbildung zu beginnen! 

Zuerst erstellst du eine Stachelfalle, die das Erscheinungsbild der Basisfalle verändert und einige Formen hinzufügt. Eine einfache flache Falle sieht nicht gefährlich aus, aber der Spieler wird ein stacheliges Objekt als etwas interpretieren, das ihm wehtun könnte. 

Um eine Spike-Falle zu erstellen, gehe folgendermaßen vor:

1. Im Inhaltsbrowser, im Fallen-Ordner, klicke mit der rechten Maustaste auf BP_TrapBase und wähle Child-Blueprint-Klasse erstellen.

2. Benenne die Blueprint-Klasse BP_TrapSpikes und öffne sie.

3. Im Tab Komponenten, wenn DefaultSceneRoot ausgewählt ist, klicke auf Hinzufügen und suche und wähle Kegel.

   Du passt die Größe und Position der Kegel so an, dass vier Reihen mit jeweils vier Kegeln (oder insgesamt 16) Platz finden.

4. Im Details-Panel des Kegels, in der Sektion Transformieren, ändere die folgenden Eigenschaften:

   1. Ändere den Standort auf -75, -75, 25.

   2. Ändere den Maßstab auf 0,5, 0,5, 0,4.

   Jetzt befindet sich in der Ecke des Basis-Meshs ein kleinerer Dorn.

   

5. Für einen optischen Kontrast benutze in der Sektion Materialien das Dropdown-Menü, um das Material des Kegels auf M_BasicColor_Rot zu ändern.

6. Wähle aus und dupliziere (Strg + D) den Kegel dreimal und verschiebe jeden Kegel um 50 Einheiten, sodass sie in einer Reihe auf einer Seite des Basis-Meshs angeordnet sind.

   

   Du kannst Kegel im Details-Panel oder im Viewport neu positionieren. Um schnellere Anpassungen mit dem Gizmo zu erzielen, ändere Ihre Verschiebung-Andocken-Einstellungen auf 50 Einheiten.

   

7. Halte Strg gedrückt, um alle vier Kegel auszuwählen und zu duplizieren. Im Komponenten-Panel wähle die vier neuen Kegel aus (sie haben die größten Zahlensuffixe) und verschiebe sie über 50 Einheiten. Wiederhole dies noch zweimal, um ein 4x4-Raster aus Kegeln zu erstellen.

   

8. Die Neigungen und Winkel der Stacheln könnten es dem Spieler erschweren, sich von der Falle zu lösen. Um zu verhindern, dass der Spieler zwischen den Stacheln landet, füge oben auf den Stacheln einen unsichtbaren Boden hinzu:

   1. Im Tab Komponenten, dupliziere den TrapBase-Mesh und benenne ihn InvisFloor.

   2. Bewege den Boden nach oben, sodass nur noch die Spitzen der Spikes über dem Boden sichtbar sind.

      

   3. Stelle im Details-Panel in der Sektion Kollision sicher, dass Kollisionsvoreinstellungen auf BlockAllDynamic eingestellt ist. Dadurch wird allen Actors der Durchgang durch das Mesh verwehrt.

   4. In der Sektion Rendern, deaktiviere Sichtbar. Dadurch wird das Mesh in den Viewportn und während des Gameplays ausgeblendet.

      

9. Im Tab Komponenten wähle dasTrapBase-Mesh. Im Details-Panel, in der Sektion Rendern, aktiviere Im Spiel versteckt. Dadurch bleibt das Mesh in den Viewportn sichtbar, wird jedoch während des Gameplays ausgeblendet, sodass du nur die Spitzen siehst.

10. Speicher und kompiliere dein Blueprint.

Die Spike-Trap-Unterklasse weist das gesamte Verhalten Ihrer Basisfalle auf und gibt daher auch die Meldung „Spieler getroffen!“ aus, wenn die Falle funktioniert. Ziehe eine Instanz von BP_TrapSpikes in dein Level und teste es!

Unterklasse einer Feuerfalle

Als Nächstes erstellst du eine Falle, die das Verhalten der Basisfalle erweitert. Eine Feuerfalle stellt eine Gefahr dar, die der Spieler mit einem Schalter ausschalten kann. Dies ist eine Gameplay-Mechanik, die du in ein neues Rätsel verwandeln kannst.

In Rätsel: Schalter und Würfel, hast du das BPI_Interaktion-Blueprint-Interface erstellt, das ein Schalter verwenden kann, um andere Gameplay-Objekte ein- und auszuschalten. Du kannst dieses Interface auch in einem Fallen-Blueprint verwenden, sodass ein Schalter die aktive Variable der Falle während des Gameplays ändern kann.

Zunächst benötigst du ein neues Material, das du verwenden kannst, wenn die Falle deaktiviert ist. 

Um ein schwarzes Material für die Feuerfalle zu erstellen, gehe folgendermaßen vor:

1. Im Inhaltsbrowser, gehe zum Ordner AdventureGame > Designer > Materialien.

2. Klicke mit der rechten Maustaste M_BasicColor und wähle Materialinstanz erstellen.

3. Benenne die Materialinstanz M_BasicColor_Black und öffne sie.

4. Expandiere Globale Vektorparameterwerte, aktiviere Farbe und klicke auf das Farbfeld, um es in Dunkelgrau (Hex sRGB =3D3B3BFF) zu ändern. Das sieht im Spiel besser aus als reines Schwarz.

   

5. Speichere und schließe die Materialinstanz.

Um eine Feuerfalle in eine Unterklasse zu unterteilen, gehe folgendermaßen vor:

1. Im Inhaltsbrowser, klicke mit der rechten Maustaste auf BP_TrapBase und wähle Child-Blueprint-Klasse erstellen.

2. Benenne den Blueprint BP_TrapFire und öffne es.

   

3. Ändere die Farbe des Basis-Meshs, damit es eine Feuerfalle darstellt. Wähle die TrapBase-Komponente aus und im Details-Panel, in der Materialien-Sektion, ändere das Material in M_BasicColor_Rot.

   

4. Klicke über dem Viewport auf Klasseneinstellungen.

5. Im Details-Panel, in der Sektion Interfaces, neben Implementierte Interfaces klicke aufHinzufügen und suche und wähle BPI_Interaktion.

   

   Im Panel Mein Blueprint, werden fnBPISwitchOff und fnBPISwitchOn-Eventfunktionen in der Sektion „Interfaces“ angezeigt.

6. Genau wie bei BP_Switch, richte anpassbare Materialien für die Feuerfalle ein:

   1. In der Sektion Variablen des Mein Blueprint-Panels erstellst du zwei Variablen mit dem Namen OffMaterial und OnMaterial.

   2. Ändere ihren Typ auf Material-Interface (Objektreferenz).

   3. Klicke auf die Augensymbole, um sie öffentlich und bearbeitbar zu machen.

   4. Ändere ihre Kategorie auf Setup.

      

   5. Kompiliere und lege die folgenden Standardwerte fest:

      • OffMaterial: M_BaseColor_Black

      • OnMaterial: M_BaseColor_Red

7. Speichere und kompiliere den Blueprint, damit du die Interface-Events im Event-Diagramm der Falle verwenden kannst.

Erweitere das Verhalten der Falle

Genau wie beim Bau der beweglichen Plattform in Rätsel: Bewegliche Plattformen musst du den Event-Diagramm der Falle so einrichten, dass er die folgenden Actions ausführt, wenn ein Schalter fnBPISwitchOn und fnBPISwitchOff aufruft:

• Aktiviere oder deaktiviere die Falle.

• Ändere das Material der Falle.

Bei der beweglichen Plattform musste die Plattform in Bewegung gesetzt werden, wenn der Spieler den Schalter aktiviert. Für die Falle benötigst du das Gegenteil – die Falle ist aktiv, wenn das Level beginnt, und sollte sich ausschalten, wenn der Spieler den Schalter aktiviert.

Um eine Logik hinzuzufügen, die Feuerfallen deaktiviert, wenn der Spieler einen Schalter drückt, gehe folgendermaßen vor:

1. Gehe zum Event-Diagramm-Tab der Feuerfalle. Doppelklicke im Mein Blueprint-Panel in der Interfaces-Liste auf fnBPIButtonOn, um dem Diagramm einen Event-Knoten hinzuzufügen.

2. BP_TrapBase-Variablen erscheinen nicht im Mein Blueprint-Panel, du kannst jedoch über die Knoten-Actionsliste darauf zugreifen. Ziehe den vom Event fnBPISwitchOn-Knoten besessenen exec-Pin, suche nach aktive Variable und wähle Als aktiv einstellen. Halte Aktiv deaktiviert.

   

3. Nach dem Einstellen-Knoten, verbinde einen Material einstellen (TrapBase)-Knoten (in der Sektion Rendern > Material der Actionsliste).

4. Im Material festlegen-Knoten, verbinde eine Referenz auf dieOffMaterial-Variable zum Material-Pin.

   

Um eine Logik hinzuzufügen, die Feuerfallen aktiviert, wenn ein Schalter deaktiviert wird, gehe folgendermaßen vor:

1. In der Sektion Interfaces, doppelklicke Event fnBPISwitchOff, um diesen Knoten hinzuzufügen.

2. Verbinde nach dem Event einen Auf aktiv stellen-Knoten, schalte aber dieses mal Aktiv ein.

3. Nach dem Einstellen-Knoten, verbinde einen Set-Material (TrapBase)-Knoten und verbinde eine Referenz auf OnMaterial.

   

4. Speicher und kompiliere dein Blueprint.

Ihr vollständiges Feuerfallen-Event-Diagramm sollte wie folgt aussehen:

Füge eine Instanz von BP_TrapFire auf Ihr Level und probiere es aus!

Aktualisiere das HUD mit den KP des Spielers

Es ist an der Zeit, diese Print String-Knoten durch echtes Feedback für den Spieler zu ersetzen. Du änderst deine HUD, um die KP des Spielers in Echtzeit anzuzeigen.

Füge dem HUD eine KP-Variable hinzu

Um Ihrem HUD dynamische Spielergesundheit hinzuzufügen, führe die folgenden Schritte aus:

1. Im Inhaltsbrowser, öffne dein WBP_PlayerHUD Widget-Blueprint. Stellen sicher, dass du in der Designer-Ansicht bist.

2. In Hierarchie, klicke auf das txtHP-Widget. Im Details-Panel, aktiviere Ist variabel und lösche 100 aus der Text-Eigenschaft.

   

3. Gehe zur Ansicht Diagramm und richte eine neue Funktion ein, die den Wert vontxtHP einstellt:

   1. In der Sektion Funktionen, füge eine neue Funktion mit dem NamenfnSetHP hinzu.

   2. Bei ausgewählter Funktion im Details-Panel klicke auf + neben Inputs.

   3. Benenne den Input NewHP und ändere seinen Typ in Float.

      Später änderst du den Spielercharakter so, dass er diese Funktion aufruft, wenn er Schaden erleidet.

4. Im Diagramm der Funktion fnSetHP, verbinde nach dem Funktionseintrittsknoten einen SetText (Text)-Knoten.

   

   Wenn du einen Knoten in der Knotenactionsliste nicht finden kannst, deaktiviere Kontextsensitiv.

5. Richte den SetText (Text) Knoten ein:

   1. Für das Ziel, verbinde eine Referenz mit der txtHP-Variable. Dies ist das Text-Widget, das die Kondition des Spielers anzeigt.

   2. Für Im Text, verbinde den Input Pin von Neue KP des Input-Knotens der Funktion. Unreal Engine fügt automatisch einen Zum Text (Float)-Knoten hinzu, um den Wert zu konvertieren.

      

   3. Speichere und Kompilieree den Widget-Blueprint.

Das komplette Diagramm der Funktion fnSetHP sieht wie folgt aus:

Zeigt die Start-KP des Spielers an 

Richte alle verfügbaren HUD-Variablen ein, bevor du sie anzeigst. In diesem Fall kennst du die anfänglichen KP des Spielers und können diese Information beim Start des Spiels anzeigen.

Um den Blueprint des Spielercharakters zu aktualisieren und seine KP auf dem HUD anzuzeigen, führe die folgenden Schritte aus:

1. Im Inhaltsbrowser, öffne Ihren BP_AdventureCharacter-Blueprint. Suche im Event-Diagramm die Logik Event Possessed.

   

   Im Mein Blueprint-Panel, erweitere Diagramme > Event-Diagramm und doppelklicke Event besessen, um es im Diagramm hervorzuheben.

2. Zwischen dem Einstellen-Knoten und dem Zum Viewport hinzufügen-Knoten, verbinde einen fnSetHP-Knoten:

   1. Für das Ziel verwende den Output-Pin des Einstellen-Knotens, um das HUD zum Ziel zu machen.

   2. Für Neue KP, verbinde eine Referenz auf die Gesundheit-Variable des Spielers.

      

3. Stelle sicher, dass der vom Zum Viewport hinzufügen-Knotenbesessene Ziel-Pin auch mit einem HUD-Variablenknoten verbunden ist.

4. Im Mein Blueprint-Panel klicke auf die Gesundheit-Variable. Im Details-Panel änderst (oder behältst) du den Standardwert. Dieses Tutorial verwendet 100 Start-Trefferpunkte.

5. Speichern und Kompilieren.

Die neue Event besessen-Logik des Spielers sollte wie folgt aussehen:

Jetzt zeigt das HUD die Gesundheit des Spielers an, wenn das Spiel beginnt. Der letzte Teil der Logik, den du benötigst, besteht darin, das HUD zu aktualisieren, wenn der Spieler Schaden nimmt. Dazu änderst du die vorhandene Schadensbehandlungslogik des Charakters, damit sie mit Ihrem HUD funktioniert.

Aktualisiere die KP des Spielers, nachdem er Schaden erlitten hat

Um Schäden am Player zu beheben, gehe folgendermaßen vor:

1. In der unteren linken Ecke des Event-Diagramms von BP_AdventureCharacter suchst du die Logik-Sektion mit dem Label „Schadens- und Todesbehandlung“, das mit einem Event AnyDamage-Knoten beginnt. Du wirst diese Sektion ändern, um stattdessen Ihre eigene Logik auszuführen.

   

2. Lösche alle Knoten, die nach dem Verzweigung-Knoten kommen. Behalte den Verzweigung-Knoten.

   

   Diese Sektion der Logik verwendet Operatorknoten, um Berechnungen durchzuführen. Wenn der Charakter Schaden erleidet, wird der Event AnyDamage-Knoten ausgelöst, der Informationen über den verursachten Schaden, die Art des Schadens sowie den Controller und Actor weitergibt, der den Schaden verursacht hat. Als nächstes wird der Schaden von der Gesundheit-Variable des Charakters abgezogen. Sobald die Gesundheit abgezogen ist, prüft der Verzweigung-Knoten, ob die Gesundheit des Spielers 0 erreicht hat.

3. Im Moment möchtest du eine Logik erstellen, die das HUD aktualisiert, wenn die Gesundheit des Spielers größer als 0 ist. Also, vom False-Pin, verbinde einen FnSetHP-Knoten, um den neuen Gesundheitswert an das HUD zu senden.

4. Richte den fnSetHP-Knoten ein:

   1. Für das Ziel, verbinde eine Referenz auf HUD-Variable des Charakters.

   2. Für den Neue KP-Input, verbinde eine Referenz mit der Gesundheit-Variable.

      

5. Speicher und kompiliere dein Blueprint.

Jetzt zeigt das HUD die aktuelle Gesundheit des Spielers an und aktualisiert diesen Gesundheitswert, wenn der Spieler Schaden erleidet.

Spiele dein Spiel erneut und teste es!

Erstelle eine Fehler- und Respawn-Bedingung

Wenn dem Spieler die Gesundheit ausgeht und er eliminiert wird, solltest du das Spiel beenden und ihm die Chance geben, es erneut zu versuchen. In diesem Tutorial deaktiviere die Steuerung des Spielers, teilen dem Spieler mit, dass er das Spiel verloren hat, und laden das Level.

Zuerst erstellst du einen Game-Over-Widget-Blueprint, der dem Spieler mitteilt, dass er eliminiert wurde.

Füge einen Game-Over-Bildschirm hinzu

Um einen Widget-Blueprint für Ihren Game-Over-Bildschirm zu erstellen, folge diesen Schritten:

1. Im Inhaltsbrowser, im Ordner AdventureGame > Designer > Blueprints > Widgets, klicke mit der rechten Maustaste, gehe zu Benutzeroberfläche und wähle Widget-Blueprint.

2. Klicke im Fenster Parent-Klasse auswählen auf Benutzer-Widget.

3. Benenne den Widget-Blueprint WBP_EliminatedScreen und öffne ihn.

Um die Game-Over-Benutzeroberfläche einzurichten, führe die folgenden Schritte aus:

1. Im Tab Palette, suche nach Canvas und ziehe eine Canvas-Panel auf [WBP_EliminatedScreen] in der Hierarchie. Genau wie bei Ihrem HUD ist das Canvas Ihr Stamm-Widget.

2. Auf dem Canvas wird eine Nachricht zum Spielende über einem Weichzeichner-Effekt angezeigt, der die Lesbarkeit des Texts verbessert. Ziehe aus dem Palette-Tab ein Overlay, um ein Child der Canvas zu werden.

3. Wenn das Overlay ausgewählt ist, erweitere im Details-Panel, in der Sektion Slot (Canvas Panel Slot), Anker und ändere beide Maximal-Werte (X und Y) auf 1.

   Die anderen Slot-Eigenschaften (unter Anker) ändern sich in Versatz-Einstellungen.

   

   Beim Erstellen des HUD hast du alle Ankerpunkte in einer Ecke belassen, sodass diese Objekte bei einer Änderung der Bildschirmgröße am Ankerpunkt verankert bleiben. Jetzt ist das Overlay am gesamten Begrenzungsrahmen des Canvas verankert, sodass das Overlay verkleinert oder gedehnt wird, um der Bildschirmgröße zu entsprechen.

4. Als du die Ankereinstellungen geändert hast, hat der Editor einige Versatzwerte geändert, um die Standardform des Overlay-Panels beizubehalten. Um dies zu entfernen, änderst du Versatz nach rechts und Versatz nach unten auf 0. Jetzt füllt das Overlay den Bildschirm.

   

5. Aus dem Tab Palette ziehst ein Hintergrund-Weichzeichnen-Widget, um ein Child des Overlay-Panels zu sein.

6. Wenn der Weichzeichneneffekt ausgewählt ist, änderst du im Details-Panel, in der Sektion Slot (Overlay-Slot):

   1. Horizontale Ausrichtung auf Horizontal füllen.

   2. Vertikale Ausrichtung auf Vertikal füllen.

      

7. In der Sektion Aussehe, ändere die Weichzeichnenstärke auf 5.

8. Aus dem Tab Palette, füge einen Text-Widget als Child-Element des Overlay hinzu.

9. Wenn das Text-Widget ausgewählt, im Details-Panel, in der Sektion Slot (Overlay-Slot), ändere:

   1. Horizontale Ausrichtung auf Horizontal zentriert ausrichten.

   2. Vertikale Ausrichtung auf Vertikal zentriert ausrichten.

      

10. In der Sektion Inhalt, ändere Text auf Du bist eliminiert … und das Level wird neu gestartet.

11. Mache den Text im Abschnitt Aussehen größer und leichter lesbar, indem du die folgenden Eigenschaften konfigurierst:

    1. Klicke auf das Farbfeld neben Farbe und Opazität, und wähle eine Farbe für Ihren Text aus. Dieses Tutorial verwendet Pink (Farbe Hex sRGB =FF4D7AFF).

    2. Erweitere den Schriftart-Header und ändere Größe zu 60. 

    3. Expandiere Schriftart > Umrisseinstellungen und ändere die Outline-Größe auf 1.

       

12. Speicher und kompiliere dein Blueprint.

Erstelle eine Logik für eine Fehlerbedingung

Da du nun über einen Game-Over-Bildschirm verfügst, kannst du die Charakterklasse so ändern, dass sie angezeigt wird, wenn dem Spieler die KP ausgehen. In diesem Fall wird die Ausführung über das True-Ergebnis des Verzweigung-Knotens durchgeführt, mit dem du zuvor gearbeitet hast.

Um mit der Niederlage eines Spielers umzugehen, musst du: 

• Deaktiviere den Spielerinput, damit sich der Spieler nicht bewegen kann.

• Zeige den Game-Over-Bildschirm an.

• Starte das Level nach einer festgelegten Zeit neu.

Um das Spiel zu stoppen und zu laden, wenn der Spieler eliminiert ist, gehe wie folgt vor:

1. In BP_AdventurePlayer gehe zurück zur Schadensbehandlungslogik (beginnend mit Event AnyDamage) in deinem Charakter-Blueprint.

2. Nach dem vom Verzweigung-Knoten besessenen True-Ausführungs-Pin, verbinde einen Einmal machen-Knoten und Input deaktivieren-Knoten.

   

   Der Spieler kann weiterhin getroffen werden, nachdem ihm die Gesundheit ausgegangen ist. Daher stellt der Do Once-Knoten sicher, dass die Logik danach nur einmal ausgeführt wird.

3. Für den vom Input deaktivieren-Knoten besessenen Spieler-Controller-Pin, verbinde einen Player-Controller holen-Knoten (in der Sektion Spiel > Spieler der Knotenactionsliste).

   

   Es gibt einige Knoten mit dem Namen Player-Controller holen. Stelle sicher, dass der Knoten über einen Spielerindex-Input Pin verfügt. Ein Index von 0 ist der Standardindex für den ersten Spielercharakter, der im Level spawnt.

4. Nachdem du den Player-Controller deaktiviert hast, erstelle und zeige den Game-Over-Bildschirm an:

   1. Verbinde einen Widget erstellen-Knoten. Ändere im Knoten die Klasse auf WBP_EliminatedScreen.

      

   2. Verbinde die Widget-Knoten exec und Ergebniswert-Pins an einen Zum Viewport hinzufügen-Knoten.

      

5. Füge eine Zeitverzögerung hinzu, hole den aktuellen Level Name ab und lade das Level:

   1. Nach dem Zum Viewport hinzufügen-Knoten, verbinde einen Verzögerung-Knoten und ändere die Dauer auf 5 Sekunden.

   2. Nach der Verzögerung, verbinde einen Aktuellen Levelnamen holen-Knoten.

   3. Nach Aktuellen Levelnamen holen, verbinde einen Ebene öffnen (nach Name)-Knoten.

   4. Verbinde den Ergebniswert-Pin mit dem Ebenenname-Pin. Der Editor fügt automatisch einen String-zu-Name-Konvertierungsknoten hinzu.

      

6. Speichere und Kompiliere dein Spieler-Blueprint.

Diese Sektion des BP_AdventureCharacter-Event-Diagramms sollte nun wie folgt aussehen:

Spiele Ihr Level, um es zu testen. Trete in eine Falle, lasse Ihren Charakter alle KP verlieren und stelle sicher, dass das Spiel wie vorgesehen zurückgesetzt wird.

Füge Ihren Rätseln Gefahren hinzu 

In Rätsel: Schalter und Würfel hast du gelernt, wie du Gameplay-Mechaniken entwickelst, die Schwierigkeit, Spannung, Konsequenzen und Risiko-Belohnung-Entscheidungen hinzufügen. Umweltgefahren, die dem Spieler Schaden zufügen, sind ein Mechanismus, der diese Konsequenzen mit sich bringt. Du kannst die Stachelfallen verwenden, um früheren Rätseln und Hindernissen im Level Gefahr und zusätzliche Konsequenzen hinzuzufügen, und mit Schaltern betriebene Feuerfallen können dynamischere Rätsel erstellen, bei denen der Spieler mit der Umgebung interagieren muss, um sichere Wege freizulegen.

Ein wichtiger Aspekt bei der Entwicklung von Spielen zur Reduzierung des Overheads und Verbesserung der Entwicklungsgeschwindigkeit besteht darin, mehrere verschiedene Möglichkeiten zur Verwendung und Kombination von Gameplay-Objekten zu finden. Im vorherigen Sektion dieser Tutorial Reihe wurden Plattformen mit Strom versorgt, um einen Pfad nach vorwärts zu erstellen. Hier kann derselbe Schalter Feuerfallen deaktivieren, um dem Spieler einen Weg freizugeben. Dies sorgt für mehr Abwechslung im Level, ohne dass eine endlose Anzahl einzigartiger Systeme erforderlich ist. 

Ähnlich der Tür-und-Schlüssel-Spielmechanik, die du zuvor in diesem Tutorial erstellt hast, wird deine Feuerfalle zu einer weiteren Mechanik, um das Tempo des Spielers und den Zugang zur Umgebung zu steuern.

Erstelle ein Labyrinth-Rätsel mit Feuerfallen

In Raum 2 kombinierst du Schalter und Feuerfallen, um ein Labyrinth-Rätsel zu erstellen, in dem der Spieler Gefahren sorgfältig deaktivieren muss, um den letzten Schlüssel zu finden und einzusammeln. 

Oft ist es hilfreich, Rätsel zunächst auf Papier zu skizzieren. Da die Fallen 1 m x 1 m groß sind, passt in unseren Beispielraum 2 ein 7 x 9-Raster von Fallen. Zeichne zunächst einen Pfad durch das Raster, der am Schlüssel endet. Teile den Pfad dann in Abschnitte auf und platziere Schalter, um die einzelnen Abschnitte zu steuern.

Um den Schwierigkeitsgrad zu erhöhen und für mehr Enthüllungen und Überraschungen zu sorgen, füge architektonische Elemente hinzu, die die Sichtlinien blockieren. Platziere beispielsweise Schalter hinter Wänden oder Säulen, sodass der Spieler sie auf dem Weg entdecken muss.  

Dieser Schleifenpfad ermöglicht dem Spieler einen Blick auf den Schlüssel, sodass er das Ziel entdeckt, während er das erste Segment des Pfads durchquert.

Wenn dein Plan fertig ist, beginne mit der Ausarbeitung des Rätsels im Level-Editor. 

Nachdem du den Pfad zum Schlüssel und die neuen Blockout-Formen erstellt hast, fülle den Rest des Raums mit Feuerfallen aus, um den richtigen Weg zu verdecken. 

Falls gewünscht, kannst du dem Spieler beim Verlassen des Rätsels helfen, indem du unter dem Schlüssel einen letzten Schalter hinzufügst, der einige Fallen auf dem Weg nach draußen deaktiviert.   

Teste Ihr Rätsel häufig und achte dabei auf Sichtlinien, Frustrationspunkte und mögliche Abkürzungen. Bitte einen Freund um Hilfe. Er findet möglicherweise Schlupflöcher, mit denen du nicht gerechnet hast. Während des Testspiels stellst du möglicherweise fest, dass du Anpassungen vornehmen musst, um den Spieler davon abzuhalten, Teile des Rätsels zu überspringen. 

Wenn du einen Exploit entdeckst, hast du mehrere Möglichkeiten:

• Ordne den Pfad oder das Rätsel neu an.

• Füge weitere architektonische Blocker hinzu.

• Erhöhen des Schadens, sodass ein Abweichen vom Pfad härtere Konsequenzen hat.

Das Verlassen eines Exploits, aber Erhöhen der Kosten gibt dem Spieler eine Wahl und Autonomie. Du kannst wählen, ob sie mehr Zeit darauf verwenden, den sicheren Weg freizugeben, oder ob sie ihre KP opfern, um zum Schlüssel zu eilen.

Im Rätsel des Beispiellevels haben wir unter dem Torbogen zum Schlüssel etwas Schutt hinzugefügt, sodass der Spieler den Schlüssel sehen, aber nicht direkt dorthin springen kann. Wir haben die Schalter außerdem nicht nur versteckt, um lohnende Enthüllungen zu ermöglichen, sondern auch, um zu verhindern, dass dieser Teil des Pfads übersprungen wird.

Füge vergangenen Hindernissen Spikes hinzu

Fügen wir den bisherigen Rätseln Spikes hinzu, um Konsequenzen für das Fallen hinzuzufügen

Beginne mit dem Rätsel von Raum 1. Halte bei der ersten beweglichen Plattform den Einsatz niedrig, sodass der Spieler, falls er fällt, einfach wieder hochklettern und es erneut versuchen kann. Wenn du eine neue Mechanik einführst, gebe dem Spieler die Möglichkeit, in einem sicheren Umfeld zu lernen, damit er sich auf das Lernen konzentrieren kann

Ebenso kannst du im Startraum einige Stacheln in die Grube unter dem ersten Schlüssel einbringen. Der Spieler kann das Springen auf den ersten beiden Plattformen üben, um sich auf den letzten, riskanteren Sprung zum Schlüssel vorzubereiten. Jetzt wird es etwas spannender, den ersten Schlüssel unbeschadet zu holen.

Sobald der Spieler die Grundlagen versteht und etwas Übung im Bewegung von Blöcken auf Plattformen und Schaltern hat, ist es an der Zeit, Konsequenzen hinzuzufügen. Platziere unter der zweiten Plattform oder dem dritten Knopf einige Stachelfallen. Jetzt hast du die Spannung erhöht, da der Spieler Schaden nimmt, wenn er fällt, er sich aber schnell von der Falle entfernen kann, um diesen Schaden zu minimieren und weiterzumachen. 

Erhöhe schließlich für die letzte Plattform und den letzten Schalter die Gefahr weiter. Bedecke den Bereich darunter mit Stacheln, sodass sie weiter laufen müssen, um den Stacheln zu entkommen, und dadurch mehr Schaden nehmen. Zu diesem Zeitpunkt sollte der Spieler mit der Mechanik besser vertraut sein und die Konsequenzen für Fehler erscheinen gerechter, da er bereits geübt hat.

Dieses Design folgt dieser beliebten Struktur zur Einführung von Gameplay-Mechaniken für Spieler: 

1. Einführen: Die erste Plattform vermittelt die Spielmechanik sicher.

2. Entwickeln: Die zweite Plattform und der Würfel testen die wachsenden Fähigkeiten des Spielers mit mäßigem Risiko.

3. Twist: Die letzte Plattform steigert die Gefahr und fügt eine neue Bewegungsrichtung hinzu, wodurch die Mechanik zu einer spannenden Herausforderung wird.

Wie du in der Lektion Gameplay-Design in Rätsel: Bewegliche Plattformen gelernt hast, wenn du die Konsequenzen im Laufe des Rätsels steigerst, schaffst du ein Gleichgewicht zwischen Fairness und Spannung.

Den Schaden einer Falle ändern

Du kannst den Schwierigkeitsgrad ändern, indem du den Schaden einer Fallenart erhöhst oder verringerst. Du kannst dies auf zwei Arten tun:

• Im Outliner, suche nach „Spike“ oder „Feuer“ und wähle alle Fallen dieses Typs aus. Im Details-Panel, ändere Setup > Basisschaden nach Wunsch. Bei dieser Methode musst du daran denken, auch den Basisschaden aller neuen Instanzen dieser Falle zu ändern, die du Ihrem Level hinzufügst. Oder füge dem Level neue Falleninstanzen hinzu, indem du vorhandene Fallen duplizierst, um zu vermeiden, dass du jede neue Instanz bearbeiten musst.

  

  ODER

• Öffne eine Ihrer Child-Fallen-Blueprints und gehe zu ihrem Konstruktions-Script-Tab. Du kannst übernommene Variablen im Mein Blueprint-Panel nicht bearbeiten, aber du kannst Variablen im Diagramm einstellen. Nach den beiden Konstruktions-Script-Knoten, verbindest du einenBasisschaden einstellen-Knoten. Ändere im Knoten den Basisschaden-Wert wie gewünscht.

  

Um sicherzustellen, dass deine Gameplay-Objekte für den Spieler vorhersehbar sind, stelle sicher, dass alle Fallen eines Typs den gleichen Schaden verursachen. 

Im Beispiellevel des Tutorials verursachen Feuerfallen 5 Schaden pro Sekunde und Stachelfalleninstanzen werden so modifiziert, dass sie 10 Schaden pro Sekunde verursachen.

Testen des Beispiel-Levels 

Wenn du Teile des in diesem Teil des Tutorials entworfenen Raums verwenden möchtest, anstatt deine eigenen zu erstellen, kopiere die folgenden Snippets.

Blockout von Raum 2

Dieses Text-Snippet enthält den Boden, die Wände und die neuen Blockout-Formen von Raum 2, die zum Erstellen des Rätsels dieses Raums hinzugefügt wurden. Im Outliner befinden sich alle Formen in einem Ordner mit dem Namen Room2.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.TextRenderActor Name=TextRenderActor_19 Archetype="/Script/Engine.TextRenderActor'/Script/Engine.Default__TextRenderActor'" ExportPath="/Script/Engine.TextRenderActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19'"
         Begin Object Class=/Script/Engine.TextRenderComponent Name="NewTextRenderComponent" Archetype="/Script/Engine.TextRenderComponent'/Script/Engine.Default__TextRenderActor:NewTextRenderComponent'" ExportPath="/Script/Engine.TextRenderComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.NewTextRenderComponent'"
         End Object
         Begin Object Class=/Script/Engine.BillboardComponent Name="Sprite" Archetype="/Script/Engine.BillboardComponent'/Script/Engine.Default__TextRenderActor:Sprite'" ExportPath="/Script/Engine.BillboardComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.Sprite'"
         End Object
         Begin Object Name="NewTextRenderComponent" ExportPath="/Script/Engine.TextRenderComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.NewTextRenderComponent'"
            Text=NSLOCTEXT("[3C535F7772EB3B3657484B5E2D5B925D]", "2347F80B407C68C27836E990A20143CF", "Room 2")
            HorizontalAlignment=EHTA_Center

Um die gesamte Blockierung von Raum 2 zu kopieren, gehe folgendermaßen vor:

1. Entferne alles, was sich bereits in Raum 2 befindet (oder alles am Ende von Flur 2):

   • Verwende den Outliner, um den vorhandenen Inhalt von Raum 2 auszuwählen: Klicke mit der rechten Maustaste auf Room2 und wähle Auswählen > Unmittelbare Children. Drücke Löschen.

   • Oder, wechsel den Viewport zur orthografische Ansicht von Oben, um einen bestehenden Raum auszuwählen und manuell zu löschen.

2. Klicke auf Vollständiges Snippet kopieren.

3. Vergewissere dich, dass im Unreal Editor der Viewport das aktive Panel ist (klicke irgendwo im Viewport oder Outliner und drücke Esc), und drücke dann Strg + V.

Dein Level und der Outliner sollten wie folgt aussehen:

Schalter, Fallen und Schlüssel von Raum 2

Dieses Text-Snippet enthält die Schalter, Fallen und den roten Schlüssel des Rätsels. Im Outliner befinden sich alle Objekte in einem Ordner mit dem Namen Room2.

Begin Map
   Begin Level
      Begin Actor Class=/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C Name=BP_FireTrap_C_261 Archetype="/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.Default__BP_TrapFire_C'" ExportPath="/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261'"
         Begin Object Class=/Script/Engine.SceneComponent Name="DefaultSceneRoot" Archetype="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:ICH-DefaultSceneRoot_GEN_VARIABLE'" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.DefaultSceneRoot'"
         End Object
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="TrapBase" Archetype="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:TrapBase_GEN_VARIABLE'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.TrapBase'"
         End Object
         Begin Object Class=/Script/Engine.BoxComponent Name="TrapTrigger" Archetype="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:TrapTrigger_GEN_VARIABLE'" ExportPath="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.TrapTrigger'"
         End Object
         Begin Object Name="DefaultSceneRoot" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.DefaultSceneRoot'"

Um die Blueprint-Teile des Rätsels zusammenzusetzen, gehe folgendermaßen vor: 

1. Klicke auf Vollständiges Snippet kopieren.

2. Stelle im Unreal Editor sicher, dass der Viewport oder Outliner das aktive Panel ist und drücke dann Strg + V.

3. Überprüfe die Setup-Eigenschaften und verbinde gegebenenfalls jeden Schalter wieder mit seinen Brandfallen:

   1. Im Outliner, imRoom2-Ordner, klicke auf BP_Switch4.

   2. Im Details-Panel, in der Sektion Setup erweitere die Interact-Objektliste.

   3. Klicke für jedes Element in der Liste auf das Dropdown-Menü und suche nach S4 und wähle eine derS4-beschriftete Feuerfallen.

      

   4. Wiederhole diese Schritte für jeden Schalter:

      • BP_Switch5 löst BP_FireTrap_S5_0-7 aus

        

      • BP_Switch6 löst BP_FireTrap_S6_0-3 aus

        

      • BP_Switch7 löst BP_FireTrap_S7_0-4 aus

        

      • BP_Switch8 löst BP_FireTrap_S8_0-3 aus

        

      • BP_Switch9, unter dem Schlüssel, löstBP_FireTrap_S9_0-4 aus

        

Dein Level und der Outliner sollten wie folgt aussehen:

Als Nächstes

Als Nächstes erfährst du, wie du deinem Spiel eine weitere beliebte Gefahr hinzufügst: feindliche NPCs! Erfahre, wie du einen KI-Feindcharakter erstellen und Ihrem Level ein Navigationsmesh hinzufügst, damit die Feinde den Spieler finden und ihm Schaden zufügen können.

• 

  Einen Feind erstellen

  Erstelle eine Spielelogik, um feindliche Charaktere zu erstellen, die Schaden verursachen und erleiden.