Zsynchronizowane znikające platformy w języku Verse w Unreal Editor dla Fortnite | Unreal Editor dla Fortnite Dokumentacja

Seria znikających platform to podstawowy element gier platformowych, takich jak tory z przeszkodami. Gracze muszą dokładnie wyczuć czas skakania po serii platform. Jeśli nie trafią, spadają i muszą zacząć od nowa.

Z tego samouczka dowiesz się, jak używać Verse w Unreal Editor dla Fortnite (UEFN), aby przy użyciu jednego urządzenia utworzyć serię platform, które kolejno pojawiają się i znikają.

Używane funkcje języka Verse

array: Przy użyciu typu array (tablica) możesz przechowywać razem odwołania do platform, aby przyspieszyć do nich dostęp i unikać duplikacji kodu.
loop (pętla): Cykl pojawiania się i znikania platform powinien zaczynać się na początku gry i trwać nieprzerwanie. W tym przykładzie pokazujemy, jak uzyskać to zachowanie za pomocą wyrażenia loop w Verse.
block: Przy użyciu wyrażenia block (blok) możesz przy użyciu możesz grupować razem wiele wyrażeń, dzięki czemu są one wykonywane po kolei.
for: Wyrażenie for umożliwia iterację każdej platformy w twojej tablicy.
sync: przy użyciu wyrażenia sync i współbieżności ustrukturyzowanej, możesz uruchamiać wiele wyrażeń asynchronicznych jednocześnie.

Używane interfejsy API Verse

Sleep(): Przy użyciu API Sleep() możesz wybrać, jak długo platformy będą w stanie niewidocznym i widocznym.
Właściwości edytowalne: Dla UEFN jest uwidocznionych siedem właściwości urządzenia tworzonego w Verse, dzięki czemu możesz je spersonalizować w Edytorze – trzy opóźnienia dla zachowania platform i cztery odwołania urządzenia do platform.

Instrukcje

Postępuj zgodnie z poniższą instrukcją, aby się nauczyć, jak skonfigurować serię platform, które okresowo pojawiają się i znikają. Do celów odniesienia, na końcu tego przewodnika znajduje się kompletny skrypt.

Ustawianie poziomu

W tym samouczku jako punkt wyjścia wykorzystano Szablon początkowy Verse. Na początek zainicjalizuj nowy projekt z przykładu funkcji Urządzenie Verse.

W tym przykładzie wykorzystano następujące rekwizyty i urządzenia:

1 x Urządzenie Panelu startowego gracza: To urządzenie określa, w którym miejscu na początku gry spawnuje się gracz.
6 x Rekwizyt trybu kreatywnego: Rekwizyty trybu kreatywnego mają kilka zachowań, które można wywoływać za pomocą Verse, na przykład Hide() i Show(), aby przełączać widoczność platformy i kolizję. W tym samouczku wykorzystano Platformę unoszącą się A jako platformę interaktywną dla gracza, ale możesz ją dowolnie zmieniać, dostosowując ją do swoich potrzeb.

Postępuj zgodnie z poniższą instrukcją, aby skonfigurować swój poziom:

1. Dodaj jedną Powietrzną platformę unoszącą się A do swojej sceny. Umieść to nad podłogą, aby gracz spadł, jeśli w porę nie zeskoczy ze znikającej platformy. W Outlinerze nazwij platformę SynchronizedPlatform1.
Zduplikuj platformę kilkukrotnie celem stworzenia linii. Następnie umieść urządzenie Panel Startowy Gracza na platformie, na której chcesz, aby Twój gracz rozpoczął grę. Gotowa konfiguracja powinna wyglądać następująco:

Tworzenie urządzenia

W tym przykładzie używamy urządzenia utworzonego w Verse, aby zdefiniować zachowanie przełączania widoczności platform. Postępuj zgodnie z poniższą instrukcją, aby utworzyć urządzenie w Verse.

Utwórz nowe urządzenie Verse o nazwie platform_series. Aby dowiedzieć się, jak utworzyć nowe urządzenie w Verse, patrz: Tworzenie własnego urządzenia przy użyciu Verse.
Przeciągnij urządzenie platform_series z Przeglądarki zawartości do poziomu.

Edycja właściwości urządzenia w UEFN

W tej sekcji pokazujemy, jak uwidocznić właściwości urządzenia dla UEFN, aby można je było dostosować w edytorze:

Trzy stałe typu float przechowujące czas, przez jaki platformy powinny być niewidoczne/widoczne, o nazwach HeadStart, AppearDelay i DisappearDelay.
Odwołania do urządzeń do obiektów trybu kreatywnego umieszczonych na poziomie.

Postępuj zgodnie z poniższymi instrukcjami, aby uwidocznić te właściwości z urządzenia platform_series utworzonego w poprzedniej sekcji.

Otwórz Eksplorator Verse i kliknij dwukrotnie platform_series.verse, aby otworzyć skrypt w Visual Studio Code.
Do definicji klasy platform_series dodaj następujące pola:
- Edytowalna wartość float o nazwie HeadStart. Odzwierciedla to, jak długo w sekundach czekać po tym, gdy platformy zaczynają się pojawiać i zanim zaczynają znikać. Zainicjuj tę wartość na 2.5 czyli dwie i pół sekundy.
  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
- Edytowalna wartość float o nazwieAppearDelay. Odzwierciedla to czas oczekiwania w sekundach, zanim pojawi się kolejna platforma. Zainicjuj tę wartość na 1.0, czyli jedną sekundę.
  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
- Edytowalna wartość float o nazwie DisappearDelay. Odzwierciedla to czas oczekiwania w sekundach, zanim zniknie kolejna platforma. Zainicjuj tę wartość na 1.25, czyli jedną i ćwierć sekundy.
  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
- Edytowalny creative_prop o nazwie DisappearingPlatform. Jest to platforma na poziomie, która będzie znikała i się pojawiała. Ponieważ twój kod nie zawiera jeszcze odwołania do tego obiektu na tym poziomie, utworzysz jego instancję przy użyciu pustego archetypu creative_prop{}. Później przypiszesz to odwołanie do swojej wiszącej platformy.
  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{}
Pola klasy platform_series powinny wyglądać następująco:
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
```
Pomocne jest użycie atrybutu @editable, aby udostępnić edytorowi wartości z twoich skryptów, takie jak AppearDelay. Pozwala ci to dostosować ich wartości w UEFN bez konieczności ponownego tworzenia kodu Verse za każdym razem, dzięki czemu możesz szybko wprowadzać zmiany i znajdować wartości odpowiadające twojej przygodzie.
Zapisz skrypt w Visual Studio Code.
Na pasku narzędzi UEFN kliknij Verse, następnie Skompiluj kod Verse, aby uaktualnić urządzenie platform_series umieszczone na poziomie.
W panelu Outlinera w UEFN wybierz urządzenie platform_series, aby otworzyć jego panel Szczegóły .
W Panelu szczegółów w obszarze Seria platform ustaw DisappearingPlatform to SynchronizedPlatform1 (rekwizyt trybu kreatywnego dodany do poziomu), klikając wybieracz obiektów i wybierając platformę w oknie wizualizacji.

Ukrywanie i wyświetlanie platformy

Po skonfigurowaniu poziomu i pierwszej platformy czas dodać funkcjonalność wyświetlania i ukrywania platformy. Postępuj zgodnie z instrukcją, aby dodać to zachowanie do urządzenia platform_series:

Klasa creative_prop zawiera dwie metody do przełączania jej widoczności: Hide() i Show(). Ponownie w Visual Studio Code w OnBegin() wywołaj Hide(), a następnie Show() na swojej DisappearingPlatform.
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;:void=
		
         # Hide the platform.
         DisappearingPlatform.Hide()
		
         # Show the platform.
         DisappearingPlatform.Show()
```
# Runs when the device is started in a running game OnBegin&lt;override&gt;()&lt;suspends&gt;:void= # Hide the platform. DisappearingPlatform.Hide() # Show the platform. DisappearingPlatform.Show()
Po wykonaniu tego kodu nie zobaczysz, jak platforma znika i pojawia się ponownie, ponieważ wywołania Hide() i Show() następują bezpośrednio po sobie.
Aby platforma pozostawała w stanie widocznym/niewidocznym przez dłuższy czas, możesz dodać opóźnienie przy wywołaniu Hide() or Show() przy użyciu Sleep(). Funkcja Sleep() zawiesza wykonanie procedury. Przekazując funkcji argument float, określasz ilość czasu (w sekundach), przez który wykonanie funkcji ma być zawieszone. Wywołaj Sleep() przed każdym wywołaniem Hide() i Show(), przekazując DisappearDelay, co zostało zdefiniowane wcześniej.
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;:void=
		
         # Hide the platform.
         DisappearingPlatform.Hide()
		
         # Wait for DisappearDelay seconds.
         Sleep(DisappearDelay)
		
         # Show the platform.
```
Jeśli uruchomisz ten kod, Platform będzie niewidoczna przez jedną sekundę (czas zdefiniowany przez DisappearDelay), zanim stanie się widoczna przez resztę gry.
Funkcję Sleep() można wywołać wyłącznie w kontekście asynchronicznym. Metoda OnBegin() jest już kontekstem asynchronicznym, ponieważ posiada specyfikator suspends, dlatego nie są konieczne żadne dalsze czynności. Aby dowiedzieć się więcej na temat specyfikatora suspends, patrz: Specyfikatory i atrybuty.

Ukrywanie i wyświetlanie wielu platform

Chociaż możesz powtórzyć kod z poprzedniego kroku dla każdej znikającej platformy umieszczonej na poziomie, utworzenie tablicy do przechowywania wszystkich odwołań do urządzeń jest bardziej wydajnym rozwiązaniem. Umożliwi to iterację każdej platformy w tablicy i wykonywanie kodu na każdej z nich bez konieczności wielokrotnego duplikowania urządzenia Verse. Aby ukryć i wyświetlić wiele platform, wykonaj następujące kroki:

W swojej definicji klasy platform_series zmień pole DisappearingPlatform na tablicę creative_prop o nazwie DisappearingPlatforms. Użyjesz tej tablicy, aby iterować kolejno przez platformy. Zainicjuj zmienną przy użyciu wartości domyślnej array{}, czyli pustej tablicy.
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{}
Możesz użyć wyrażenia for, aby iterować każdy element przez tablicę. Wyrażenie for używa wzorca X -> Y, aby tworzyć pary indeks-wartość. Indeks (lub klucz) jest powiązany z lewą częścią (X), a wartość jest powiązana z prawą częścią (Y). W tym przypadku X to numer platformy / indeks, a Y to odwołanie każdej platformy pobrane z tablicy. Najpierw utwórz wyrażenie for, aby iterować każdy element i pobrać indeks każdego numeru w zmiennej PlatformNumber.
~~~(verse) # Działa po uruchomieniu urządzenia w aktywnej grze OnBegin<override>()<suspends>:void= for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: ~~~
Wydrukuj numer platformy i wywołaj Hide(), aby ukryć platformę. Następnie Sleep() na DisappearDelay określoną liczbę sekund.
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)
Aby wyświetlić platformy w widoku względem siebie, użyj drugiego wyrażenia for po pierwszym. Iteruj przez każdą platformę w DisappearingPlatforms w ten sam sposób, z tą różnicą, że tym razem wywołaj Show(), aby wyświetlić platformę i Sleep() na określoną liczbę sekund AppearDelay.
~~~(verse) # Dla każdej platformy w DisappearingPlatforms ustaw ją jako widoczną i zastosuj uśpienie. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Wyświetlaj platformę. DisappearingPlatform.Show() Print("Platforma {PlatformNumber} jest teraz widoczna") Sleep(AppearDelay) ~~~
Pisząc kod, dobrym rozwiązaniem jest umieszczenie kodu, który może być ponownie wykorzystany, w oddzielnych funkcjach. Dzięki temu możesz wywoływać kod z różnych kontekstów i nie musisz stale przepisywać tego samego kodu. W zależności od twojego poziomu doświadczenia, możesz chcieć ukrywać i pokazywać platformy w różnych sytuacjach, więc musisz stworzyć funkcje do obsługi każdej z tych sytuacji. Dodaj dwie nowe funkcje o nazwach HideAllPlatforms() i ShowAllPlatforms() do definicji klasy platform_series. Przenieś wyrażenie for obsługujące ukrywanie platform do HideAllPlatforms(), a wyrażenie obsługujące wyświetlanie platform do ShowAllPlatforms(). Ponieważ używasz funkcji Sleep(), funkcje te muszą być asynchroniczne, dlatego dodaj modyfikator <suspends> do każdej z nich. Następnie w OnBegin() wywołaj HideAllPlatforms(), a następnie ShowAllPlatforms().
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;:void=
         HideAllPlatforms()
         ShowAllPlatforms()
		
     HideAllPlatforms()&lt;suspends&gt;:void=
         # For each platform in DisappearingPlatforms, make it invisible and sleep.
         for:
             PlatformNumber -&gt; DisappearingPlatform:DisappearingPlatforms
         do:
```
W obecnej formie kod ten zostanie uruchomiony tylko raz. Aby platformy przez całą grę znikały i się pojawiały, do powtarzania tego zachowania możesz użyć wyrażenia loop. Aby to wykonać, dodaj wyrażenie loop do OnBegin(), które zawiera wywołania HideAllPlatforms() i ShowAllPlatforms()W tym przykładzie chcesz przełączać widoczność platform przez cały czas trwania gry, dlatego nie musisz dodawać wyrażenia break, aby opuścić loop.
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;:void=
         loop:
             # Hide all platforms.
             HideAllPlatforms()
		
             # Show all platforms.
             ShowAllPlatforms()
```
# Runs when the device is started in a running game OnBegin&lt;override&gt;()&lt;suspends&gt;:void= loop: # Hide all platforms. HideAllPlatforms() # Show all platforms. ShowAllPlatforms()
Po wykonaniu tego kodu wszystkie platformy będą najpierw kolejno znikały, a następnie pojawiały się w tej samej kolejności i będą to powtarzały aż do końca gry.
Zapisz kod i go skompiluj. W panelu Outlinera w UEFN wybierz urządzenie platform_series, aby otworzyć jego panel Szczegóły .
W panelu Szczegóły, w obszarze DisappearingPlatforms, dodaj element tablicy dla każdej platformy na poziomie. Dodaj nowe elementy do tablicy przy użyciu przycisku "Dodaj element", następnie kliknij wybieracz obiektów i w oknie wizualizacji wybierz rekwizyt trybu kreatywnego. Upewnij się, że kolejność tej tablicy jest zgodna z kolejnością, według której chcesz wykonywać iterację:

Teraz po wykonaniu tego kodu platformy będą najpierw kolejno znikały, a następnie pojawiały się w tej samej kolejności i będą to powtarzały aż do końca gry.

Synchronizacja znikania i pojawiania się platform

Aby podkręcić tempo, gdy gracz przeskakuje przez pola, możesz zrobić tak, aby platformy zaczynały znikać, gdy dalsze w kolejności platformy dopiero się pojawiają. W ten sposób gracz będzie się musiał śpieszyć, skacząc przez serie, bo inaczej spadnie. Aby uzyskać to zachowanie, obie procedury (ShowAllPlatforms() i HideAllPlatforms()) muszą być wykonywane w tym samym czasie, druga z opóźnieniem po pierwszej, aby gracz musiał się pośpieszyć, by doskoczyć do kolejnej platformy, zanim zniknie.

Wykonaj te instrukcje, aby wszystkie platformy znikały i się pokazywały w tym samym czasie.

Aby HideAllPlatforms() i ShowAllPlatforms() pracowały współbieżnie, możesz używać wyrażenia sync. Wyrażenie sync wykonuje dwa lub większą liczbę wyrażeń asynchronicznych wewnątrz bloku kodu w tym samym czasie, a zanim przejdzie dalej, czeka, aż wykonanie wszystkich wyrażeń się zakończy. W OnBegin(), wewnątrz wyrażenia loop dodaj wyrażenie sync na HideAllPlatforms() i ShowAllPlatforms()
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;: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&lt;override&gt;()&lt;suspends&gt;:void= loop: # Run both expressions concurrently using sync. sync: # Hide all platforms. HideAllPlatforms() # Show all platforms. ShowAllPlatforms()
Po uruchomieniu tego kodu w aktualnym stanie, ukrywanie i pokazywanie platformy będzie miało miejsce jednocześnie. Nie jest to oczekiwany wynik, więc będziesz trzeba nieco opóźnić zniknięcie platformy. Aby dać graczowi przewagę na starcie, użyj funkcji Sleep() i przekaż jej wartość HeadStart. Wyrażenie sync wykonuje jednocześnie wszystkie wyrażenia w swoim bloku kodu, dlatego musisz użyć wyrażenia block, aby zagnieździć Sleep() i HideAllPlatforms(). Dodaj wyrażenie block, które obejmuje Sleep() i HideAllPlatforms(). Teraz synchronizacja uruchomi dwa wyrażenia. Pierwsze wywołuje ShowAllPlatforms(), drugie wywołuje Sleep(), a następnie wywołuje HideAllPlatforms().
Verse
```
     # Runs when the device is started in a running game
     OnBegin&lt;override&gt;()&lt;suspends&gt;:void=
         loop:
             # Run both expressions concurrently using sync.
             sync:
                 block:
                     Sleep(HeadStart)
                     # Hide all platforms.
                     HideAllPlatforms()
                 # Show all platforms.
```
Zapisz skrypt i kliknij Verse, następnie Skompiluj kod Verse, aby skompilować kod.
Na pasku narzędzi UEFN kliknij Uruchom sesję, aby przetestować poziom w grze.

Teraz, gdy wykonasz test gry poziomu, platformy będą zaczynały znikać jedna po drugiej, natomiast platformy późniejsze w kolejności będą się pojawiały jedna po drugiej przez cały czas trwania gry.

Kompletny skrypt

Poniższy kod to kompletny skrypt do utworzenia serii platform, które po kolei pojawiają się i znikają.

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

Praca własna

Po ukończeniu samouczka umiesz utworzyć w Verse urządzenie, które przełącza widoczność serii platform przez cały czas trwania gry.

Wykorzystując zdobytą wiedzę, spróbuj wykonać następujące czynności:

Zmień kolejność pojawiania się i znikania platform.
* Zastosuj te same koncepcje, aby okresowo wywoływać funkcje innych typów urządzeń, takich jak urządzenie przenośnika rekwizytów.