Rätsel: Schalter und Würfel

In diesem Tutorial erstelle ein Plattform-Rätsel, indem du zwei gängige Gameplay-Objekte erstellst:

• Ein Druckplattenschalter.

• Ein Physik Würfel, der auf den Spieler reagiert.

Du verwendest Leveldesign und Spielmechaniken wie Zeit, Physik und Schaden, um das Rätsel nach Schwierigkeit anzupassen und Konsequenzen für Spieleraktionen vorzustellen.

Bevor du anfängst

Dieses Tutorial setzt voraus, dass du bereits über Kenntnisse der folgenden Themen verfügst, die in den vorherige Sektionen von Entwerfen eines Rätsel-Abenteuers behandelt wurden:

• Materialien

• Blueprints

• Variablen

• Blueprint-Interfaces

• Play-In-Editor-Modus

Du benötigst die folgenden Assets, die inErstellen eines Schlüssels erstellt wurden.

• M_BasicColor_Blue

Ein Ansatz zum Gameplay-Design

Unabhängig vom Genre weckt ein fesselndes Gameplay bei den Spielern Gefühle: die Spannung des Spieler-gegen-Spieler-Kampfes oder den Komfort eines Landwirtschaftssimulators. Diese emotionale Reaktion trägt zum Engagement des Spielers bei. Wenn ein Spiel nicht fesselnd ist, ist es weniger wahrscheinlich, dass die Spieler weiterspielen – was sich auf den Erfolg Ihres Projekts auswirken kann.

Als Spieledesigner ist es Ihre Aufgabe, das Gameplay durch Leveldesign und Gameplay-Mechanik zu gestalten. Du kannst ein Level intuitiv entwerfen, aber für die Zwecke dieses Tutorials verwenden wir Formeln, um den Prozess zu visualisieren.

Leveldesign

Durch Leveldesign kannst du die Schwierigkeit einer Aufgabe erhöhen oder verringern. In einem Plattformer ist es Beispiel eine Aufgabe, auf eine Plattform zu springen. Wenn du eine Plattform an der oberen Grenze der Sprungdistanz eines Charakters platzierst, wird es schwieriger, die Plattform zu erreichen und die Aufgabe zu erledigen.

Wenn jedoch keine Konsequenzen für das Scheitern bestehen, selbst bei einer Aufgabe mit hohem Schwierigkeitsgrad, wird sich der Spieler wahrscheinlich sicher fühlen.

Ein Gefühl der Sicherheit ist in den Tutorial-Sektionen des Gameplays nützlich, in denen der Spieler die Steuerung ohne Konsequenzen erlernen kann. 

Ein ständiges Sicherheitsgefühl ist für Ihr Spiel jedoch möglicherweise nicht hilfreich. Ohne Spannung kann sich beispielsweise ein Bosskampf langweilig anfühlen, was zu mangelnder Spielerbeteiligung führt. 

Um den Spieler nervös zu machen, kannst du Konsequenzen einführen, indem du die Spielmechanik Schaden verwendest.

Spielmechaniken

Schaden stellt numerisch die Wahrscheinlichkeit dar, dass der Spieler etwas Wertvolles verliert, wie zum Beispiel:

• Ausrüstung

• Powerups

• Level-Fortschritt

• Ein spielbarer Charakter oder nicht spielbarer Begleiter.

Die Schwierigkeit der Aufgabe in Kombination mit der Schwere der Konsequenzen kann sich darauf auswirken, wie stark die Anspannung beim Spieler ist:

Die Spannung beim Ausführen einer Aufgabe kann sich auf die Zufriedenheit auswirken, die der Spieler empfindet, wenn er eine Gewinnbedingung erfüllt. Zufriedenheit, insbesondere in Verbindung mit einer Belohnung, schafft Motivation zum Weiterspielen.

Erstellen eines Switches

Ein Schalter ist ein Gameplay-Objekt, das einen Effekt erzeugt, wenn etwas damit interagiert.

Indem du lernst, wie man einen Schalter erstellt, kannst du Gameplay-Funktionen entwerfen, beispielsweise das Drücken einer Schaltfläche zum Öffnen einer Tür. In diesem Fall verwendest du den Schalter, um die Farbe bei Kollisionen mit Actors im Spiel zu ändern.

Mit Logik bauen

Ihr Schalter wird aktiviert, wenn ein Objekt oder Spieler ihn überlappt. Bevor du mit dem Erstellen beginnst, entwirf wir die Logik, die diese Interaktion ermöglicht, indem wir die folgenden Fragen beantworten: Was muss wem passieren – und wann?

Hier ist eine Aufschlüsselung der Logik des Schalters:

• Zur Laufzeit ist der Schalter ausgeschaltet.

• Tritt ein Spieler auf den Schalter, schaltet sich der Schalter ein.

• Wenn ein Spieler vom Schalter tritt, schaltet sich der Schalter aus.

Da der Schalter zwei Zustände hat (ein und aus), kannst du Materialien verwenden, um jeden Zustand zur Laufzeit zu visualisieren. Dadurch lässt sich beim Testen schnell überprüfen, ob die Logik korrekt funktioniert.

Materialien erstellen

Für den Aus-Zustand des Schalters verwende M_BasicColor_Blau und für den Ein-Zustand erstelle ein emittierendes Material.

  Um das Emissionsmaterial zu erstellen, gehe folgendermaßen vor:

1. Im Inhaltsbrowser, beiAdventureGame > Designer > Materialien, klicke mit der rechten Maustaste und wähle Material aus.

   

2. Benenne das neue Material M_EmissiveColor und doppelklicke darauf, um den Material-Editor zu öffnen.

3. Klicke im Materialdiagramm mit der rechten Maustaste und suche nach Vektorparameter. Klicke darauf, um es in das Diagramm zu bevölkern und Farbe zu benennen. Dadurch wird die Farbe des Materiallichts gesteuert.

   

4. Auf dem Farbe-Knoten doppelklicke auf das Farbfeld, um den Farbwähler zu öffnen.

5. Wähle Ihre eigene Farbe oder stelle sie auf Hex sRGB 27F774FF ein, um es zu verfolgen.

   

6. Klicke mit der rechten Maustaste und suche nach zwei weiteren Knoten: einem konstanten und einem multiplizieren-Knoten.

7. Verbinde den Farbe-Knoten mit dem A-Pin des Multiplizieren-Knotens. Verbinde dann die Konstante zum B-Pin des Multiplizieren-Knotens. Verbinde abschließend den Multiplizieren-Knoten mit dem Emissionsfarbe-Pin des M_EmissiveColor-Knotens.

   

8. Der Wert der Konstante steuert die Emissionsleistung oder Helligkeit des Materials. Passe es nach Wunsch an oder stelle es auf 25, um es zu verfolgen.

   

9. Speichere und schließe das Material.

Ihr Materialordner sollte jetzt folgendermaßen aussehen:

Als Nächstes baue den Schalter.

Einrichten einer Blueprint-Klasse

Der Schalter wird ein Blueprint sein, der aus einem statischen Mesh und einer Box-Kollision besteht. Die Box-Kollision erkennt den Kontakt mit dem Spieler, wodurch der Ein- und Aus-Zustand des Schalters ausgelöst wird.

Führe zunächst die folgenden Schritte aus:

1. ImInhaltsbrowser, beiAdventureGame > Designer > Blueprints, erstelle einen neuen Ordner mit dem Namen Aktivierung.

2. Klicke in der Aktivierung mit der rechten Maustaste, um eine neue Blueprint-Klasse zu erstellen.

   

3. Im Parent-Klasse auswählen wähle Actor.

   

4. Benenne den neuen Blueprint BP_Switch und doppelklicke darauf, um BP_Switch im Blueprint-Editor zu öffnen.

5. Im Tab Komponenten erstelle ein statisches Mesh, indem du aufHinzufügen klickst, nachWürfel suchst und es auswählst.

6. Benenne den Würfel Schalter.

   

7. Im Details-Panel, unter Transformieren, passe den Maßstab des Schalters auf 2.0, 2.0, 0,1 an.

   

8. Im Tab Komponenten erstelle eine Box-Kollision, indem du aufHinzufügen klickst und suche nach Box-Kollision.

9. Benenne es Trigger.

   

10. Im Details-Panel, unter Standort, passe den Z-Wert der Box-Kollision auf200 an.

11. Unter Maßstab, passe die Maßstab auf 1,5, 1,5, 5,0 an. Diese Box-Kollision ist dicker als das statische Mesh, um Kollisionen leicht zu erfassen.

    

12. Speicher und kompiliere den Blueprint.

Ihr Blueprints-Ordner sollte jetzt folgendermaßen aussehen:

Als Nächstes erstelle Variablen, um das Verhalten des Schalters zu steuern.

Erstellen von Variablen

Durch Variablen kann BP_Switch auf das Material verweisen, das du gerade erstellt hast. Anstatt ein bestimmtes Material fest in den Schalter zu codieren, können Sie Materialien im laufenden Betrieb austauschen – was Sie später in diesem Tutorial tun werden.

Erstelle vorerst die folgenden Variablen in BP_Switch:

1. Im Tab Mein Blueprint unter VARIABLEN, erstelle zwei neue Variablen, indem du zweimal auf die Schaltfläche + klickst.

2. Benenne einen OnMaterial und den anderenOffMaterial.

3. Stelle den Pin-Typ auf Material-Interface (Objektreferenz).

   

4. Wähle OnMaterial. Im Details-Panel, neben Kategorie, erstelle eine neue Kategorie mit dem Namen Einstellen.

5. Klicke auf Kompilieren, um Zugang auf seinen Standardwert zu erhalten. Unter Standardwert, wähle M_EmissiveColor. Diese Variable ist vorerst fertig.

   

6. Wähle OffMaterial. Im Details-Panel, fügst du es zur Einstellen-Kategorie hinzu.

7. Unter Standardwert, wähle M_BasicColor_Blau.

8. Speichern und Kompilieren.

Da der Blueprint nun auf die Materialien verweisen kann, verwendest du eine Logik, um dem Switch mitzuteilen, wann er sie verwenden soll.

Implementiere deine Logik

Sie sollten über eine Box-Kollision, ein statisches Mesh und zwei Materialien verfügen. Nun kann die Logik des Schalters wie folgt geschrieben werden:

• Zur Laufzeit sollte Schalter OffMaterial anzeigen.

• Wenn Trigger eine Kollision erkennt, dann setzen Sie das Material des Schalters auf OnMaterial.

• Wenn Trigger die Erkennung einer Kollision stoppt, setzen Sie das Material des Schalters auf OffMaterial.

Um diese Logik zu erstellen, verwendest du ein Konstruktions-Script, um BP_Switch anzuweisen, AusMaterial zur folgenden Laufzeit zu verwenden:

1. Im Tab Konstruktions-Script ziehe den Exec-Pin auf den Konstruktions-Script-Knoten und suche nach Material einstellen (Schalter). Klicke, um es zu erstellen.

   

2. Auf derm Material festlegen-Knoten, ziehe den Material-Pin und suche nach OffMaterial holen. Wähle es aus.

   

3. Speichern und Kompilieren.

Die restliche Logik übernehmen Sie im Event-Diagramm. Um den Schalter anzuweisen, sich bei Überlappung ein- und auszuschalten, führe die folgenden Schritte aus:

1. Löschen Sie im Event-Diagramm die Knoten Event BeginPlay, Event ActorBeginOverlap und Event Tick. Du wirst sie nicht brauchen.

2. Im Tab Mein Blueprint unter dem Komponenten-Titel, klicke mit der rechten Maustaste auf Trigger und wähle Event hinzufügen > OnComponentBeginOverlap hinzufügen.

   

3. Wiederholen Sie diesen verarbeiten, um einen OnComponentEndOverlap- Knoten hinzuzufügen.

   

4. Aus dem Exec-Pin des OnComponentBeginOverlap(Trigger)-Knotens, ziehen und suchen Sie nach SetMaterial (Schalter).

   

5. Aus dem Material-Pin des Material festlegen-Knotens, ziehen und suchen Sie nach OnMaterial holen.

   

6. Aus dem Exec-Pin des OnComponentEndOverlap(Trigger)-Knoten, ziehen und suchen Sie nach Material einstellen (Schalter).

7. Aus dem Material-Pin des Material festlegen-Knotens, ziehen und suchen Sie nach OffMaterial holen.

8. Ihr Schalter ist vorerst fertig, Speichern und Kompilieren Sie.

Ihr Konstruktions-Script-Diagramm sollte nun so aussehen:

Ihr Event-Diagramm sollte jetzt so aussehen:

Jetzt können Sie Ihr Projekt testen, um zu sehen, ob Ihr Schalter richtig funktioniert.

Ziehe eine Instanz von BP_Switch aus demInhaltsbrowser in Zimmer 1. Klicke auf das Drei-Punkte-Menü in der Spielmodus-Werkzeugleiste und wähle Aktuelle Kameraposition. Dadurch wird sichergestellt, dass Sie von Ihrer aktuellen Position im Viewport aus in den PIE-Modus wechseln, anstatt durch das gesamte Level zu laufen, um eine Funktion zu testen.

Wenn Sie im PIE-Modus auf den Schalter treten, sollte dieser aufleuchten. Wenn Sie aussteigen, sollte die Farbe wieder blau werden.

Der Vorteil der modularen Entwicklung

Angenommen, Sie möchten zwei Schalter statt einem, aber der zweite Schalter soll rot statt grün leuchten. Sie könnten einen neuen Schalter mit der gleichen Logik bauen und ein rotes Material zuweisen, aber das würde Sie Entwicklungszeit kosten und mehr Aufwand für Ihr Projekt verursachen.

Da Plattformen (Computer und Konsolen) über eine begrenzte Verarbeitungsleistung verfügen, möchten Spieleentwickler normalerweise modular arbeiten, um den Overhead zu reduzieren.

Da Sie zum Erstellen Ihres Switches Blueprints und Variablen verwendet haben, arbeiten Sie bereits modular. Lassen Sie uns Ihre Arbeit in Action sehen:

1. Öffnen Sie BP_Switch im Blueprint-Editor durch Doppelklicken im Inhaltsbrowser.

2. Unter Variablen, wähle OnMaterial und klicke auf das Symbol Auge, damit es geöffnet ist.

   

3. Wähle AusMaterial und wir werden dasselbe auf eine andere Art und Weise tun; im Details-Panel aktiviere Instanz editierbar. Du wirst feststellen, dass sich das Augensymbol öffnet; es ist jetzt eine öffentliche Variable.

   

4. Speichere, Kompiliere und schließe es.

Du solltest bereits eine Instanz von BP_Switch im Level haben, also ziehe eine zweite Instanz hinein. Wenn einer der Schalter im Viewport ausgewählt ist, wird das Details-Panel eine neue UI-Kategorie namens Einstellen anzeigen. Dies ist die Variablenkategorie, die Sie in Erstellen von Variablen erstellt haben. Setup zeigt Ihre öffentlichen Variablen als Parameter an, die Sie im Viewport im laufenden Betrieb ändern können.

Versuche, die Materialien nach Belieben zu ändern und teste, wie die Schalter im PIE-Modus reagieren. Du wirst feststellen, dass jede Instanz deines Schalters einzigartige Ein- und Aus-Materialien enthalten kann, ohne dass du neue Schalter von Grund auf neu erstellen musst. Dies beschleunigt deine Entwicklung und reduziert den Aufwand.

Erstelle einzelne und mehrere Aktivierungen

Ihr Schalter lässt sich derzeit unbegrenzt ein- und ausschalten. In bestimmten Fällen ist es sinnvoll, es nur einmal zu aktivieren. Beispielsweise möchten Sie in einem Flur, der zu Beute führt, möglicherweise einen Schalter, um eine Falle zu aktivieren, der der Spieler ausweichen muss. Wenn der Spieler der Falle erfolgreich ausweicht und die Beute einsammelt, sollte der Schalter die Falle nicht erneut aktivieren.

Anstatt das zu verwerfen, was du bereits aufgebaut hast, füge einen Booleschen Wert hinzu, um nur eine Verwendung Ihres Schalters zuzulassen.

Führe dazu die folgenden Schritte aus:

1. Im Blueprint-Editor für BP_Switch, unter Variablen klicke auf die Schaltfläche +, um eine neue Variable hinzuzufügen.

2. Benenne es Einmal aktivieren und stelle den Pin-Typ auf Boolescher Wert.

3. Im Details-Panel überprüfen Sie die Box Instanz editierbar.

4. Klicke auf das Dropdown-Menü neben Kategorie und wähle Setup aus.

5. Klicke auf Kompilieren, um auf den Standardwert der Variable zuzugreifen und vergewissere dich, dass sie nicht markiert ist. Dies bedeutet, dass ActivateOnce für diesen Blueprint nicht standardmäßig aktiviert ist.

   

6. Klicke mit der rechten Maustaste in den Event-Diagramm und suche nach einem Verzweigung-Knoten.

7. Aus dem Zustand-Pin auf dem Verzweigung-Knoten, ziehe und suchen nach ActivateOnce holen.

   

8. Ziehe den Exec-Pin des Bei Überlappung der Komponentenenden (Trigger)-Knotens zum Exec-Pin des Verzweigung-Knotens. Die Verbindung zum SetMaterial-Knoten sollte getrennt werden.

   

9. Verbinde den False-Pin des Verzweigung-Knotens mit dem Exec-Pin des Material festlegen-Knotens. Das bedeutet, dass beim Verlassen des Schalters eine Entscheidung getroffen wird: wenn Einmal aktivieren auf True umgeschaltet ist, erkennt der Schalter keine Kollisionen mehr. Wenn Einmal aktivieren umgeschaltet ist auf False, funktioniert der Schalter unbegrenzt.

   

10. Speichere, Kompiliere und schließe den Blueprint.

11. Wähle BP_Switch im Viewport aus. Im Details-Panel sollte ActivateOnce für diese Instanz ein umschaltbares Kontrollkästchen sein. Aktivieren Sie es, um zu sehen, wie es funktioniert.

    

Ihr Event-Diagramm sollte jetzt so aussehen:

Klicke auf Spielen, um deine Variable im PIE-Modus zu testen. Wenn ActivateOnce aktiviert ist, sollte der Schalter auch dann leuchten, wenn Sie ihn verlassen.

Schalter mit Physik aktivieren

Später in diesem Tutorial muss Ihr Spieler den Schalter gedrückt halten, während er durch den Rest des Levels navigiert. Aus diesem Zweck erstelle das zweite Gameplay-Objekt dieses Rätsel: den Physikwürfel. Dies beinhaltet die Spielmechanik, Physik, in das Rätsel, das Sie entwerfen.

Um einen Physikwürfel mit Blueprints zu erstellen, gehe folgendermaßen vor:

1. ImInhaltsbrowser, navigiere zu AdventureGame > Designer > Blueprints > Aktivierung, klicke mit der rechten Maustaste und erstelle eine neue Blueprint-Klasse.

2. Im Parent-Klasse auswählen wähle Actor.

3. Benenne den neuen Blueprint BP_Cube.

4. Doppelklicke darauf, um BP_Cube im Blueprint-Editor zu öffnen.

5. Im Tab Komponenten erstelle ein statisches Mesh, indem du aufHinzufügen klickst, nachWürfel suchst und es auswählst.

6. Benenne das Mesh Würfel.

   

7. Im Details-Panel, unter Statisches Mesh, suche und wähle SM_ChamferCube.

   

8. Stelle den Standort Z auf 50,0 ein.

9. Unter Materialien, stelle Element 0 auf M_BasicColor_Blau ein.

   

10. Unter Physik, aktivieren Sie Physik simulieren. Diese Einstellung ermöglicht die Verwendung des Chaosphysik-Motors von UE, der den Würfel auf das Schieben des Spielers reagieren lässt.

    

11. Speichern und Kompilieren.

Um die Funktionalität zu testen, ziehe eine Instanz von BP_Cube in dein Level, in die Nähe deines Schalters. Drücken Sie Spielen, um in den PIE-Modus zu wechseln und die Buchstaben WASD zum Drücken von BP_Cube auf einen Schalter, um es einzuschalten.

Debug

Wenn Sie den Würfel auf den Schalter drücken, schaltet er sich ein, aber Sie bemerken möglicherweise ein Problem. Wenn Sie vom Schalter weggehen, wird der Schalter ausgeschaltet, auch wenn der Würfel ihn noch überlappt.

Sehen Sie sich die aktuelle Logik an, um den Fehler zu finden:

Wenn Trigger die Erkennung einer Kollision stoppt, setzen Sie das Material des Schalters auf OffMaterial.

Um dieses Problem zu lösen, weisen Sie den Trigger an, vor dem Fortfahren zu prüfen, ob es überlappende Actors gibt:

Wenn Trigger die Erkennung einer Kollision stoppt, und wenn es keine Actors gibt, die sie überlappen, dann setzen Sie das Material des Schalters auf OffMaterial.

Um diese Anpassung an Ihren Blueprints vorzunehmen, führe die folgenden Schritte aus:

1. Im Blueprint-Editor für BP_Switch, klicke mit der rechten Maustaste und erstelle einen Verzweigung-Knoten.

2. Ziehe den Zustand-Pin, suche und erstelle einen Ist leer (Array)-Knoten.

   

3. Aus dem Ziel-Array-Pin des Ist leer-Knotens, suche und erstelle Überlappende Actors erhalten (Trigger).

4.  Stelle den Klassenfilter auf Actor ein.

   

5. Verbinde diese Logik mit den vorhandenen Knoten, indem du sie aus dem False-Pin des ersten Verzweigung-Knotens ziehst und verbinde ihn mit dem Exec-Pin des zweiten Verzweigung-Knotens.

6. Verbinde den True-Pin auf dem zweiten Verzweigung-Knoten mit dem Exec-Pin des Material festlegen-Knotens.

7. Speichern und Kompilieren.

Ihr Event-Diagramm sollte jetzt so aussehen:

Um die Kollisionseinstellungen des Trigger zu ändern, gehe folgendermaßen vor:

1. Im Tab Komponenten wähle Trigger aus.

2. Im Details-Panel unter dem Kollisionsvorgaben-Header, stelle das Dropdown-Menü auf Benutzerdefiniert.

3. In der Kollision aktiviert-Dropdown-Liste, wählst du Kollision aktiviert (Abfrage und Physik) aus.

4. In der Objekttyp-Dropdown-Liste, wähle WorldDynamik.

   

5. Neben WorldDynamic, wähle Ignorieren.

   

6. Speichern und Kompilieren.

Wechseln Sie in den PIE-Modus, um Ihre Lösung zu testen. Der Schalter sollte beleuchtet bleiben, solange ihn ein Actor überlappt, unabhängig davon, ob einer weggeht.

Erstelle Sie zusätzliche Funktionen

Bisher haben Sie einen Schalter erstellt, der ein- und ausgeschaltet werden kann. Dies eignet sich hervorragend zur Visualisierung der korrekten Funktion des Schalters, könnte aber noch nützlicher sein. Als Nächstes verwendest du den Schalter, um andere Objekte innerhalb des Levels zu aktivieren. 

Zuerst erstellst du eine Blueprint-Interface mit zwei Funktionen; jede stellt den Ein- und Aus-Zustand des Schalters dar. Diese Funktionen werden wie zwischen Objekten signalisierte Events verwendet.

1. Im Inhaltsbrowser, navigiere zu AdventureGame > Designer > Blueprints > Kern, klicke mit der rechten Maustaste und hebe Blueprint hervor. Wähle dann Blueprint-Interface.

   

2. Benenne das Interface BPI_Interaktion. Doppelklicke, um das Blueprint-Interface-Fenster zu öffnen.

   

3. Im Tab Mein Blueprint sollte bereits eine neue Funktion vorhanden sein. Benenne es fnBPISwitchOn.

   

4. Klicke auf Hinzufügen und dann Funktion, um eine zweite Funktion zu erstellen. Benenne es fnBPISwitchOff.

5. Ihr Interface ist fertig.  Speichere, Kompiliere und schließe es.

Als nächstes erstellst du ein Array, das alle Objekte enthält, die der Schalter aktivieren soll. In diesem Lernprogramm verwendest du ein Array, um zu verwalten, welche Objekte deinen Schalter aktiviert, anstatt für jedes neue Objekt eine einzigartige Logik zu erstellen.

1. Im Tab Mein Blueprint von BP_Switch, unter VARIABLEN klicke auf die Schaltfläche +, um eine neue Variable zu erstellen.

2. Benenne es InteractObjectList und stelle den Pin-Typ auf Actor (Objektreferenz).

3. Im Details-Panel, neben Variablentyp, legen Sie den Containertyp auf Array.

   

4. Um es zu einem UI-Parameter zu machen, aktiviere Instanz editierbar und füge es hinzu zur Setup-Kategorie.

5. Speichern und Kompilieren.

Mithilfe der Logik weisen Sie den Switch an, jedes Objekt im Array (das derzeit leer ist) zu durchlaufen und dies mit dem BPI_Interaktion-Interface, das Sie zuvor erstellt haben. Dazu verwendest du einen Für jede Schleife.

Führe dazu die folgenden Schritte aus:

1. Im Event-Diagramm, ziehe aus dem Exec-Pin desMaterial festlegen-Knotens (des Bei Komponentenbeginn Überlappung-Knoten) und suche nachFür jede Schleife.

   

2. Um anzugeben, für welche Objekte das Ereignis ausgeführt werden soll, ziehe den Array-Pin auf Für jede Schleife und suche nachInteractObjectList abrufen.

   

3. Ziehe abschließend den Schleifenkörper-Pin auf Für jede Schleife und suche nach fnBPISwitchOn. Dies ist das Event, das Sie aufrufen.

   

4. Verbinde den Array-Element-Pin auf dem Für jede Schleife zum Ziel-Pin auf demfnBPISwitchOn-Knoten.

   

5. Dasselbe muss für Bei Überlappung der Komponentenenden (Trigger) getan werden. Um den Vorgang zu beschleunigen, wähle den Knoten „Für jede Schleife und Objektliste interagieren“ aus und kopiere ihn mit Rechtsklick > Kopieren oder Strg + C. Drücken Sie Strg + P, um es in das Diagramm einzufügen.

   

6. Verbinde den Exec-Pin des Material festlegen-Knotens mit dem Exec-Pin von Für jede Schleife.

7. Aus dem Schleifenkörper-Pin von Für jede Schleife, ziehe und suchen nach fnBPISwitchOff. Verbinde den Array-Element-Pin an den Ziel-Pin.

8. Ihr Schalter ist vorerst fertig. Speichere, Kompiliere und schließe es.

Ihr Event-Diagramm sollte jetzt so aussehen:

Sie haben jetzt die Grundlagenarbeit dafür erledigt, für jede Instanz Ihres Schalters eine eindeutige Liste von Objekten in Ihrem Level zu aktivieren. Im nächsten Tutorial erstellst du das dritte Gameplay-Objekt dieser Herausforderung – eine bewegliche Plattform.

Als Nächstes

• 

  Rätsel: Bewegliche Plattformen

  Erstelle im zweiten Teil des Plattform-Rätsels die beweglichen Plattformen mit Blueprints und lerne, wie sie dein Script debuggen.