Verwendung von synchronisierten verschwindenden Plattformen mit Verse in Unreal Editor für Fortnite | Fortnite Dokumentation

Eine Reihe verschwindender Plattformen ist ein fester Bestandteil von Plattform-Spielmodi wie Hindernisparcours. Dabei wird verlangt, dass die Spieler ihre Sprünge über eine Serie an Plattformen zeitlich abstimmen, oder sie fallen runter und müssen von vorne beginnen.

In diesem Tutorial erfähst du, wie du eine Reihe von Plattformen erstellst, die nacheinander erscheinen und verschwinden, indem du ein Gerät mit Verse im Unreal Editor für Fortnite (UEFN) erstellst.

Verwendete Sprachfunktionen in Verse

array: Mit dem array type, Plattformreferenzen zusammen speichern, um einen schnellen Zugriff zu ermöglichen und Code-Duplizierung zu vermeiden.
loop: Der Zyklus des Auftauchens und Verschwindens von Plattformen sollte mit Beginn des Spiels beginnen und kontinuierlich ablaufen. Dieses Beispiel zeigt, wie du dieses Verhalten mit dem Verse- loop expression erstellen kannst.
block: Mit dem Ausdruck Block kannst du mehrere Ausdrücke gruppieren, so dass sie executed werden.
for: Mit dem Ausdruck for kannst du über jede Plattform in deinem Array iterieren.
sync: Mit dem Ausdruck sync und structured concurrency kannst du mehrere asynchrone Ausdrücke gleichzeitig ausführen.

Verwendete APIs in Verse

Sleep(): Mit der API Sleep() kannst du festlegen, wie lange die Plattformen in ihrem unsichtbaren und sichtbaren Zustand sein sollen.
Editable Properties: MehrereVerse-authored device Eigenschaften sind für UEFN offengelegt, so dass du sie im Editor anpassen kannst - drei Verzögerungen für das Verhalten der Plattformen und vier Geräteverweise auf die Plattformen.

Anweisungen

Befolge diese Schritte, um zu erfahren, wie du eine Reihe von Plattformen einrichtest, die in regelmäßigen Abständen verschwinden und wieder auftauchen. Das complete script ist am Ende dieses Leitfadens als Referenz enthalten.

Level einrichten

Dieses Tutorial nutzt die Verse-Startervorlage als Ausgangspunkt. Um zu beginnen, initialisiere ein neues Projekt aus dem Verse-Gerät Funktionsbeispiel.

Dieses Beispiel verwendet die folgenden Props und Geräte.

1 x Spieler-Spawnfläche-Gerät: Dieses Gerät legt fest, wo der Spieler zu Beginn des Spiels spawnt.
6 x Kreatives Prop: Kreative Props haben mehrere Verhaltensweisen, die du mit Verse aufrufen kannst, wie z.B. Hide() und Show(), um die Sichtbarkeit und Kollision der Plattform umzuschalten. Dieses Tutorial verwendet die Fliegende Schwebeplattform A als interaktive Plattform für den Spieler verwendet, aber du kannst diese gerne ändern, um sie deinem Erlebnis anzupassen.

Befolge diese Schritte, um dein Level einzurichten:

Füge deiner Szene eine Fliegende Schwebeplattform A hinzu. Platziere sie über der Plattform. Das ist der Ort, an dem der Spieler zu Beginn des Spiels spawnen wird. Gib der Plattform im Outliner den Namen SynchronizedPlatform1.
Dupliziere die Plattform mehrmals,, um eine Linie zu erstellen. Platziere dann das Player Spawn Pad auf der Plattform, von wo du möchtest, dass dein Spieler beginnt. Dein fertiges Setup sollte wie folgt aussehen:

Erstellen des Geräts

Dieses Beispiel verwendet ein Verse-authored device, um das Verhalten zum Umschalten der Sichtbarkeit der Plattformen zu definieren. Befolge diese Schritte, um dieses Gerät mit Verse zu erstellen.

Erstelle ein neues Verse-Gerät mit dem Namen platform_series. Wie du ein neues Gerät in Verse erstellen kannst, findest du unter Create Your Own Device Using Verse.
Ziehen das platform_series Gerät aus dem Inhaltsbrowser in den Level.

Bearbeiten der Geräteeigenschaften in UEFN

In diesem Abschnitt wird gezeigt, wie du Geräteeigenschaften für UEFN freigeben kannst, damit du sie im Editor anpassen kannst:

Drei Konstanten mit den Namen float, um zu speichern, wie lange die Plattformen unsichtbar/sichtbar sein sollen: HeadStart, AppearDelay und DisappearDelay.
Geräte verweisen auf die Kreativobjekte, die du im Level platziert hast.

Führedie folgenden Schritte aus, um diese Eigenschaften für das im vorherigen Abschnitt erstellte Gerät platform_series freizugeben.

Öffne den Verse Explorer und doppelklicke auf platform_series.verse, um das Script in Visual Studio Code zu öffnen.
Füge in der Klassendefinition platform_series die folgenden Felder hinzu:
- Ein bearbeitbarer float mit dem Namen HeadStart. Das gibt an, wie lange in Sekunden gewartet werden muss, nachdem Plattformen erscheinen und bevor Plattformen zu verschwinden beginnen. Initialisiere diesen Wert auf 2.5 oder zweieinhalb Sekunden.
  Verse
```
  # How long to wait in seconds after platforms start appearing
  # before they start disappearing.
  @editable
  HeadStart:float = 2.5
```
  # How long to wait in seconds after platforms start appearing # before they start disappearing. @editable HeadStart:float = 2.5
- Ein bearbeitbarer float mit dem Namen AppearDelay. Das gibt an, wie lange in Sekunden gewartet werden muss, bis die nächste Plattform verschwindet. Initialisiere diesen Wert auf 1,0 oder eine Sekunde.
  Verse
```
  # How long to wait in seconds before the next platform appears.
  @editable
  AppearDelay:float = 1.0
```
  # How long to wait in seconds before the next platform appears. @editable AppearDelay:float = 1.0
- Ein bearbeitbarer float mit dem Namen DisappearDelay. Das gibt an, wie lange in Sekunden gewartet werden muss, bis die nächste Plattform verschwindet. Initialisiere diesen Wert auf 1.25 oder eineinviertel Sekunden.
  Verse
```
  # How long to wait in seconds before the next platform disappears.
  @editable
  DisappearDelay:float = 1.25
```
  # How long to wait in seconds before the next platform disappears. @editable DisappearDelay:float = 1.25
- Ein bearbeitbares creative_prop mit dem Namen DisappearingPlatform. Das ist die im-Level-Plattform, die verschwindet und wieder erscheint. Da dein Code noch keine Referenz auf dieses Objekt im Level hat, wirst du es mit einem leeren archetype creative_prop{} instanziieren. Diese Referenz weist du später deiner schwebenden Plattform zu.
  Verse
```
  # The in-level platform that disappears and reappears.
  @editable
  DisappearingPlatform:creative_prop = creative_prop{}
```
  # The in-level platform that disappears and reappears. @editable DisappearingPlatform:creative_prop = creative_prop{}
Die Felder deiner Klasse platform_series sollten wie folgt aussehen:
Verse
```
     # A Verse-authored creative device that can be placed in a level
     platform_series := class(creative_device):
		
     # How long to wait in seconds after platforms start appearing
     # before they start disappearing.
     @editable
     HeadStart:float = 2.5
		
     # How long to wait in seconds before the next platform appears.
     @editable
```
Es ist hilfreich, das Attribut @editable zu verwenden, um Werte wie AppearDelay aus deinen Scripts dem Editor zugänglich zu machen. Auf diese Weise kannst du ihre Werte in UEFN anpassen, ohne den Verse-Code jedes Mal neu erstellen zu müssen. Somit kannst du schnell iterieren und Werte finden, die zu deinem Spielerlebnis passen.
Speichere das Script in Visual Studio Code.
Klicke in der UEFN-Werkzeugleiste auf Verse und dann auf Verse-Code erstellen um das Gerät platform_series zu aktualisieren, das sich im Level befindet.
Wähle im Panel Outliner in UEFN das Gerät platform_series aus, um dessen Panel Details zu öffnen.
Lege im Panel Details unter Plattformserie die DisappearingPlatform auf SynchronizedPlatform1 (das kreative Prop, die Du dem Level hinzugefügt hast) fest, indem du auf den Objektwähler klickst und die Plattform im Viewport auswählst.

Eine Plattform anzeigen und ausblenden

Nachdem du nun das Level und die erste Plattform eingerichtet hast, kannst du die Funktion zum Ein- und Ausblenden der Plattform hinzufügen. Folge diesen Schritten, um dieses Verhalten dem Gerät platform_series hinzuzufügen:

Die Klasse creative_prop hat zwei methods um ihre Sichtbarkeit umzuschalten: Hide() und Show(). Zurück im Visual Studio Code, in OnBegin() rufe Hide() und dann Show() in deiner DisappearingPlatform auf.
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
		
         # Hide the platform.
         DisappearingPlatform.Hide()
		
         # Show the platform.
         DisappearingPlatform.Show()
```
# Runs when the device is started in a running game OnBegin<override>()<suspends>:void= # Hide the platform. DisappearingPlatform.Hide() # Show the platform. DisappearingPlatform.Show()
Wenn du diesen Code ausführst, wirst du nicht sehen, wie die Plattform verschwindet und wieder auftaucht, weil die Aufrufe Hide() und Show() unmittelbar nacheinander erfolgen.
Damit die Plattform länger in einem sichtbaren/unsichtbaren Zustand bleibt, kannst du eine Verzögerung beim Aufrufen von Hide() oder Show() mit Sleep() hinzufügen. Die Funktion Sleep() unterbricht die Ausführung einer Routine, und du gibt die Zeitwert (in Sekunden) an, die die Ausführung unterbrochen werden soll, indem du ein float argument an die Funktion übergibst. Rufe Sleep() vor jedem Hide() und Show() Aufruf auf, und übergebe das zuvor definierte DisappearDelay.
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
		
         # Hide the platform.
         DisappearingPlatform.Hide()
		
         # Wait for DisappearDelay seconds.
         Sleep(DisappearDelay)
		
         # Show the platform.
```
Wenn du diesen Code ausführst, wird die Platform für eine Sekunde unsichtbar (der Wert, der durch DisappearDelay definiert ist), bevor sie für den Rest des Spiels sichtbar wird.
Die Funktion Sleep() kann nur in einem asynchronen Kontext aufgerufen werden. Die Methode OnBegin() ist bereits ein asynchroner Kontext, da sie den Bezeichner suspends hat, sodass du nichts weiter tun musst. Um mehr über den Bezeichner suspends zu erfahren, findest du unter Specifiers and Attributes.

Mehrere Plattformen ausblenden und einblenden

Während du den Code aus dem vorherigen Schritt für jede Plattform im Level wiederholen kannst, die du verschwinden lassen willst, ist die Erstellung eines Arrays, um alle Gerät-Referenzen zu speichern, wirksamer. Auf diese Weise kannst du alle Plattformen im Array durchlaufen und auf jeder Plattform Code ausführen, ohne das Verse-Gerät mehrfach duplizieren zu müssen. Befolge diese Anweisungen zum ausblenden und anzeigen mehrerer Plattformen:

Ändere in deiner Klassendefinition platform_series das Feld DisappearingPlatform in ein Array von creative_prop mit dem Namen DisappearingPlatforms. Verwende diesen Array, um die Plattformen der Reihenfolge nach durchzugehen. Initialisiere die Variable mit dem Standardwert array{}, ein leeres Array.
Verse
```
     # The in-level platforms that disappear and reappear in sequence.
     @editable
     DisappearingPlatforms:[]creative_prop = array{}
```
# The in-level platforms that disappear and reappear in sequence. @editable DisappearingPlatforms:[]creative_prop = array{}
Du kannst den Ausdruck for verwenden, um über jedes Element im Array zu iterieren. Der Ausdruck for verwendet das Muster X -> Y um dir eine Index-Wert-Paarung zu geben. Der Index ist an den linken Teil (X) und der Wert an den rechten Teil (Y) gebunden. In diesem Fall ist X die Nummer/der Index der Plattform und Y ist jede aus dem Array abgerufene Plattformreferenz. Erstelle zuerst einen Ausdruck for um über jedes Element zu iterieren, und hole den Index jeder Nummer in einer Variablen PlatformNumber.
~~~(Verse) # Wird ausgeführt, wenn das Gerät in einem laufenden Spiel gestartet wird OnBegin<override>()<suspends>:void= for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: ~~~
Drucke die Nummer der Plattform aus und rufe Hide() auf, um die Plattform auszublenden. Dann Sleep() für eine DisappearDelay Anzahl in Sekunden.
Verse
```
     # For each platform in DisappearingPlatforms, make it invisible and sleep.
     for:
         PlatformNumber -&gt; DisappearingPlatform:DisappearingPlatforms
     do:
         # Hide the platform
         DisappearingPlatform.Hide()
         Print("Platform {PlatformNumber} is now hidden")
         Sleep(DisappearDelay)
```
# For each platform in DisappearingPlatforms, make it invisible and sleep. for: PlatformNumber -&gt; DisappearingPlatform:DisappearingPlatforms do: # Hide the platform DisappearingPlatform.Hide() Print("Platform {PlatformNumber} is now hidden") Sleep(DisappearDelay)
Um die Plattformen darzustellen, wird nach dem ersten Ausdruck ein zweiter for verwendet. Iteriere über jede Plattform in DisappearingPlatforms auf die gleiche Weise, außer dass du diesmal Show() aufrufst, um die Plattform anzuzeigen, und Sleep() für einen AppearDelay Wert in Sekunden.
~~~(Verse) # Mach jede Plattform in DisappearingPlatforms sichtbar und in den Schlaf. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Zeig die Plattform. DisappearingPlatform.Show() Print("Platform {PlatformNumber} ist jezt sichtbar") Sleep(AppearDelay) ~~~
Beim Schreiben von Code ist es sinnvoll, Code, den du möglicherweise wiederverwenden möchtest, in separate Funktionen zu packen. So kannst du den Code aus verschiedenen Kontexten aufrufen und musst nicht immer wieder denselben Code neu schreiben. Abhängig von deiner Erfahrung möchtst du die Plattformen möglicherweise in unterschiedlichen Situationen ausblenden und anzeigen, wehalb du Funktionen erstellst, um diese jeweils zu bewältigen. Füge deiner Klassendefinition zwei neue Funktionen platform_series mit den Namen HideAllPlatforms() und ShowAllPlatforms() hinzu. Verschiebe den Ausdruck for, der das Ausblenden der Plattformen behandelt, in HideAllPlatforms() und den Ausdruck, der das Einblenden der Plattformen behandelt, in ShowAllPlatforms(). Da du die Funktion Sleep() verwendest, müssen diese Funktionen asynchron sein, also füge zu jeder den Modifikator <suspends> hinzu. Rufe dann in OnBegin() HideAllPlatforms() auf, dann ShowAllPlatforms().
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
         HideAllPlatforms()
         ShowAllPlatforms()

     HideAllPlatforms()<suspends>:void=
         # For each platform in DisappearingPlatforms, make it invisible and sleep.
         for:
             PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
         do:
```
So wie es scheint, wird dieser Code nur einmal ausgeführt. Um die Plattformen verschwinden und wieder auftauchen zu lassen, solange das Spiel läuft, kannst du den Ausdruck loop verwenden, um dieses Verhalten zu wiederholen. Um dies zu verarbeiten, füge einen Ausdruck loop zu OnBegin() hinzu, der die Aufrufe von HideAllPlatforms() und ShowAllPlatforms() umfasst. In diesem Beispiel möchtest du die Sichtbarkeit der Plattformen umschalten, solange das Spiel läuft, daher ist es nicht erforderlich einen break Ausdruck hinzuzufügen, um loop zu beenden.
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
         loop:
             # Hide all platforms.
             HideAllPlatforms()

             # Show all platforms.
             ShowAllPlatforms()
```
# Runs when the device is started in a running game OnBegin<override>()<suspends>:void= loop: # Hide all platforms. HideAllPlatforms() # Show all platforms. ShowAllPlatforms()
Wenn du diesen Code ausführst, verschwinden die Plattformen zuerst nacheinander und tauchen dann alle in der gleichen Reihenfolge wieder auf, was sich wiederholt, bis das Spiel zu Ende ist.
Speichere deinen Code und kompiliere ihn. Wähle im Panel Outliner in UEFN das Gerät platform_series aus, um dessen Panel Details zu öffnen.
Füge im Panel Details unter DisappearingPlatforms für jede Plattform im Level ein Array-Element hinzu. Füge dem Array mit der Schaltfläche „Element hinzufügen“ neue Elemente hinzu, klicke dann auf den Objektwähler und wähle die kreativen Prop im Viewport aus. Vergewissere dich, dass die Reihenfolge dieses Arrays mit der Reihenfolge übereinstimmt, die du iterieren möchtest:

Wenn du jetzt diesen Code ausführst, verschwinden die Plattformen zuerst nacheinander und tauchen dann in der gleichen Reihenfolge wieder auf, was sich wiederholt, bis das Spiel zu Ende ist.

Verschwinden und Wiederauftauchen der Plattformen synchronisieren

Um die Spannung zu erhöhen, wenn der Spieler über die Kacheln springt, kannst du die Plattformen verschwinden lassen, während Plattformen später in der Sequenz nach wie vor auftauchen. Auf diese Weise muss der Spieler über die Serie hetzen oder runterfallen. Um dieses Verhalten zu erstellen, müssen beide Routinen (ShowAllPlatforms() und HideAllPlatforms()) gleichzeitig ausgeführt werden, wobei die zweite hinter der ersten zurückbleibt damit der Spieler einen Vorsprung hat, um zur nächsten Plattform zu springen, bevor sie verschwindet.

Befolge diese Schritte, um dafür zu sorgen, dass die Plattformen alle gleichzeitig ein- und ausgeblendet werden.

Um HideAllPlatforms() und ShowAllPlatforms() gleichzeitig laufen zu lassen, kannst du den Ausdruck sync verwenden. Der Ausdruck sync führt die zwei oder mehrere asynchrone Ausdrücke in seinem Codeblock gleichzeitig aus und wartet, bis alle Ausdrücke beendet sind, bevor er fortfährt. Füge in OnBegin() innerhalb des Ausdrucks loop einen sync Ausdruck auf HideAllPlatforms() und ShowAllPlatforms() hinzu
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
         loop:
             # Run both expressions concurrently using sync.
             sync:
                 # Hide all platforms.
                 HideAllPlatforms()

                 # Show all platforms.
                 ShowAllPlatforms()
```
# Runs when the device is started in a running game OnBegin<override>()<suspends>:void= loop: # Run both expressions concurrently using sync. sync: # Hide all platforms. HideAllPlatforms() # Show all platforms. ShowAllPlatforms()
Wenn du diesen Code ausführst, wie er ist, erfolgt das Ausblenden und Anzeigen einer Plattform gleichzeitig. Dies ist nicht das gewünschte Ergebnis, daher musst du das Verschwinden der Plattform etwas verzögern. Um dem Spieler einen Vorsprung zu verschaffen, solltest du Sleep() verwenden und den Wert HeadStart übergeben. Da der Ausdruck sync alle Ausdrücke in seinem Codeblock gleichzeitig ausführt, musst du den Ausdruck block verwenden, um Sleep() und HideAllPlatforms() zu verschachteln. Füge den Ausdruck block der Sleep() und HideAllPlatforms() abdeckt. Die Synchronisierung führt nun zwei Ausdrücke aus. Der erste ruft ShowAllPlatforms() auf, und der zweite Sleep() und danach HideAllPlatforms().
Verse
```
     # Runs when the device is started in a running game
     OnBegin<override>()<suspends>:void=
         loop:
             # Run both expressions concurrently using sync.
             sync:
                 block:
                     Sleep(HeadStart)
                     # Hide all platforms.
                     HideAllPlatforms()
                 # Show all platforms.
```
Speicher das Script und klicke auf Verse und dann auf Verse-Codeerstellen um den Code zu kompilieren.
Klicke auf Sitzung starten in der UEFN-Symbolleiste, um den Level einen Spieltest durchzuführen.

Wenn du das Level jetzt testest, verschwinden die Plattformen in der Sequenz, während die Plattformen später in der Sequenz wieder auftauchen, und dieses Muster wiederholt sich so lange, wie das Spiel läuft.

Vollständiges Script

Der folgende Code ist das vollständige Script, um eine Reihe von Plattformen zu erstellen, die nacheinander auftauchen und verschwinden.

Verse

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# See https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse for how to create a verse device.

# A Verse-authored creative device that can be placed in a level
platform_series := class(creative_device):

    # How long to wait in seconds after platforms start appearing

Du bist am Zug

Wenn du dieses Tutorial abgeschlossen hast, hast du gelernt, wie du mit Verse ein Gerät erstellst, das die Sichtbarkeit einer Plattformserie umschaltet, solange das Spiel läuft.

Versuche mit dem, was du gelernt hast, Folgendes:

Ändere die Reihenfolge, in der die Plattformen erscheinen und verschwinden.
Wende die gleichen Konzepte an, um regelmäßig Funktionen auf anderen Gerätetypen aufzurufen, z. B. dem Objektbeweger-Gerät.