Piattaforme a scomparsa sincronizzata

Le piattaforme a scomparsa rappresentano un elemento fondamentale per determinate modalità di gioco come i percorsi a ostacoli. In questo tipo di giochi, i giocatori devono sincronizzare i loro salti su una serie di piattaforme, altrimenti cadranno e dovranno ricominciare.

Seguendo questo tutorial, imparerai a creare una serie di piattaforme che appaiono e scompaiono una dopo l'altra utilizzando un dispositivo creato con Verse in Unreal Editor per Fortnite (UEFN).

Funzionalità del linguaggio Verse utilizzate

• array: il tipo di array ti permette di memorizzare i riferimenti alla piattaforma per un rapido accesso ed evitare di duplicare il codice.

• loop: il ciclo di apparizione e scomparsa della piattaforma deve cominciare all'inizio del gioco ed essere continuo. L'esempio mostra come creare questo comportamento con l'espressione loop di Verse.

• block: l'espressione block ti permette di raggruppare diverse espressioni in modo che possano essere eseguite in sequenza.

• for: con l'espressione for puoi iterare su ogni piattaforma del tuo array.

• sync: con l'espressione sync e la concorrenza strutturata, ti permettono di eseguire diverse espressioni asincrone contemporaneamente.

API Verse utilizzate

• Sleep(): utilizzando l'API Sleep(), puoi scegliere per quanto tempo le piattaforme rimangono invisibili o visibili.

• Proprietà modificabili: diverse proprietà del dispositivo Verse esposte a UEFN per personalizzarle nell'editor: tre ritardi per il comportamento della piattaforma e quattro riferimenti alla piattaforma.

Istruzioni

Segui questi passaggi per impostare una serie di piattaforme che scompaiono e appaiono periodicamente. Lo script completo è incluso come riferimento alla fine di questa guida.

Configurazione del livello

Questo tutorial utilizza come punto di partenza il progetto iniziale di Verse. Per iniziare, inizializza un nuovo progetto dall'esempio della funzione Dispositivo Verse.

Questo esempio utilizza i seguenti oggetti scenografici e dispositivi.

• 1 Dispositivo Pedana di generazione giocatore: questo dispositivo definisce la posizione di generazione del giocatore all'inizio del gioco.

• 6 oggetti Creativa: gli oggetti Creativa hanno diversi comportamenti che si possono richiamare con Verse, come Hide() e Show() per attivare la visibilità e la collisione della piattaforma. Questo tutorial utilizza la Piattaforma aerea A come piattaforma interattiva per il giocatore, ma puoi modificarla in base alle esigenze della tua esperienza.

Segui questi passaggi per impostare il tuo livello:

1. Aggiungi una Piattaforma aerea A alla scena. Posizionala sopra il pavimento in modo che il giocatore cada se non salta in tempo dalla piattaforma che scompare. Nell'Outliner, denomina la piattaforma SynchronizedPlatform1.

   

2. Duplica la piattaforma più volte per creare una linea. Quindi posiziona il dispositivo Pedana di generazione giocatore sulla piattaforma da cui vuoi che il tuo giocatore inizi. La configurazione completa deve essere simile a:

   

Creazione del dispositivo

Questo esempio utilizza un dispositivo Verse per definire il comportamento per attivare o disattivare la visibilità delle piattaforme. Segui questi passaggi per creare questo dispositivo utilizzando Verse.

1. Crea un nuovo dispositivo Verse denominato platform_series. Per informazioni sulla creazione di un nuovo dispositivo in Verse, vedi Creare un dispositivo personalizzato utilizzando Verse.

   

2. Trascina il dispositivo platform_series da Browser dei contenuti nel livello.

Modifica delle proprietà del dispositivo in UEFN

Questa sezione mostra come esporre le proprietà del dispositivo a UEFN per personalizzarle nell'editor:

• * Tre costanti float per memorizzare per quanto tempo le piattaforme devono essere invisibili/visibili, denominate HeadStart, AppearDelay e DisappearDelay.

• Riferimenti ai dispositivi degli oggetti creativi che hai inserito nel livello.

Segui questi passaggi per esporre queste proprietà dal dispositivo platform_series creato nella sezione precedente.

1. Apri Verse Explorer e fai doppio clic su platform_series.verse per aprire il suo script in Visual Studio Code.

2. Nella definizione della classe platform_series, aggiungi i seguenti campi:

   • Un float modificabile denominato HeadStart. Rappresenta il tempo di attesa, in secondi, dopo la comparsa e la scomparsa delle piattaforme. Inizializza questo valore a 2.5 o due secondi e mezzo.

     Verse

       # How long to wait in seconds after platforms start appearing
       # before they start disappearing.
       @editable
       HeadStart:float = 2.5
     

     Copy full snippet(4 lines long)

   • Un float modificabile denominato AppearDelay. Rappresenta il tempo di attesa, in secondi, prima che appaia la piattaforma successiva. Inizializza questo valore a 1.0, ovvero un secondo.

     Verse

       # How long to wait in seconds before the next platform appears.
       @editable
       AppearDelay:float = 1.0
     

     Copy full snippet(3 lines long)

   • Un float modificabile denominato DisappearDelay. Rappresenta il tempo di attesa, in secondi, prima che scompaia la piattaforma successiva. Inizializza questo valore a 1.25,, ovvero un secondo e un quarto.

     Verse

       # How long to wait in seconds before the next platform disappears.
       @editable
       DisappearDelay:float = 1.25
     

     Copy full snippet(3 lines long)

   • Un creative_prop modificabile denominato DisappearingPlatform. Si tratta della piattaforma di livello che scomparirà e riapparirà. Poiché il tuo codice non ha ancora un riferimento a questo oggetto nel livello, lo istanzierai con un archetipo creative_prop{} vuoto. In seguito assegnerai questo riferimento alla piattaforma fluttuante.

     Verse

       # The in-level platform that disappears and reappears.
       @editable
       DisappearingPlatform:creative_prop = creative_prop{}
     

     Copy full snippet(3 lines long)

3. I tuoi campi della classe platform_series devono apparire così:

   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
   
   Expand code Copy full snippet(19 lines long)

   È utile utilizzare l'attributo @editable per esporre valori come AppearDelay all'editor dai tuoi script. Questo ti permette di personalizzare i loro valori in UEFN senza dover ricompilare ogni volta il codice Verse, in modo da poter iterare rapidamente e trovare i valori che si adattano alla tua esperienza di gioco.

4. Salva lo script in Visual Studio Code.

5. Nella barra degli strumenti UEFN, fai clic su Verse, quindi Crea codice Verse per aggiornare il dispositivo platform_series che è nel livello.

   

6. Nel pannello Outliner di UEFN, seleziona il dispositivo platform_series per aprire il relativo pannello Dettagli.

7. Nel pannello Dettagli sotto Serie di piattaforme, imposta DisappearingPlatform su SynchronizedPlatform1 (l'oggetto Creativa che hai aggiunto al livello) facendo clic sul selettore oggetti e selezionando la piattaforma nella viewport.

Nascondere e mostrare una piattaforma

Ora che hai impostato il livello e una prima piattaforma, puoi aggiungere la funzionalità per mostrarla e nasconderla. Segui questi passaggi per aggiungere questo comportamento al dispositivo platform_series:

1. La classe creative_prop ha due metodi per attivare/disattivare la sua visibilità: Hide() e Show(). Torna in Visual Studio Code, In OnBegin(), chiama Hide() e poi Show() su DisappearingPlatform.

   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()
   

   Copy full snippet(8 lines long)

   Se esegui questo codice, non vedrai la piattaforma scomparire e ricomparire perché le chiamate Hide() e Show()si verificano immediatamente una dopo l'altra.

2. Per far sì che la piattaforma rimanga in uno stato visibile/invisibile più a lungo, puoi aggiungere un ritardo quando si chiama Hide() o Show() utilizzando la funzione Sleep(). La funzione Sleep() sospende l'esecuzione di una routine e ti permette di specificare la quantità di tempo (in secondi) per sospendere l'esecuzione passando un argomento float alla funzione. Chiama Sleep() prima di ogni chiamata a Hide() e Show(), passando il DisappearDelay definito in precedenza.

   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.
   
   Expand code Copy full snippet(11 lines long)

   Se esegui questo codice, la Platform sarà invisibile per un secondo (la quantità definita da DisappearDelay) prima di diventare visibile per il resto del gioco.

   La funzione Sleep() può essere chiamata solo in un contesto asincrono. Il metodo OnBegin() è già un contesto asincrono, poiché ha lo specificatore suspends, quindi non è necessario fare altro. Per ulteriori informazioni sullo specificatore suspends, vedi Specificatori e attributi.

Nascondere e mostrare più piattaforme

Anche se potresti ripetere il codice del passo precedente per ogni piattaforma del livello che vuoi rimuovere, la creazione di un array per memorizzare tutti i riferimenti ai dispositivi è più efficiente. In questo modo potrai iterare su ogni piattaforma dell'array, eseguendo il codice su ognuna di esse senza dover duplicare più volte il dispositivo Verse. Segui questi passaggi per nascondere e mostrare più piattaforme:

1. Nella definizione della classe platform_series, modifica il campo DisappearingPlatform in un array di creative_prop denominato DisappearingPlatforms. Utilizzerai questa array per iterare sulle piattaforme in ordine. Inizializza la variabile con il valore predefinito array{}, ovvero un array vuoto.

   Verse

        # The in-level platforms that disappear and reappear in sequence.
        @editable
        DisappearingPlatforms:[]creative_prop = array{}
   

   Copy full snippet(3 lines long)

2. Puoi usare l'espressione for per iterare su ogni elemento dell'array. L'espressione for utilizza il pattern X -> Y per fornire una coppia indice-valore. L'indice è collegato al lato sinistro (X) e il valore è collegato al lato destro (Y). In questo caso, X è il numero/indice della piattaforma e Y è il riferimento di ogni piattaforma recuperata dall'array. Per prima cosa, crea un'espressione for per iterare su ogni elemento e determinare l'indice di ciascun numero in una variabile PlatformNumber.

   ~~~(verse) # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione OnBegin<override>()<suspends>:void= for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: ~~~

3. Stampa il numero della piattaforma e chiama Hide() per nascondere la piattaforma. Poi Sleep() per un numero di secondi DisappearDelay.

   Verse

        # For each platform in DisappearingPlatforms, make it invisible and sleep.
        for:
            PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
        do:
            # Hide the platform
            DisappearingPlatform.Hide()
            Print("Platform {PlatformNumber} is now hidden")
            Sleep(DisappearDelay)
   

   Copy full snippet(8 lines long)

4. Per mostrare le piattaforme contrapposte, utilizzerai una seconda espressione for dopo la prima. Itera su ogni piattaforma in DisappearingPlatforms nello stesso modo, ma questa volta chiama Show() per mostrare la piattaforma e Sleep() per un numero di secondi AppearDelay.

   ~~~(verse) # Per ogni piattaforma in DisappearingPlatforms, rendila visibile e sospendi. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Mostra la piattaforma. DisappearingPlatform.Show() Print("La piattaforma {PlatformNumber} è ora visibile") Sleep(AppearDelay) ~~~

5. Quando scrivi del codice, è una buona idea inserire il codice che potresti voler riutilizzare in funzioni separate. In questo modo puoi richiamare il codice da contesti diversi ed evitare di riscrivere sempre lo stesso codice. A seconda della tua esperienza, potresti voler nascondere e mostrare le piattaforme in situazioni diverse, quindi dovrai creare delle funzioni per gestire ognuna di queste situazioni. Aggiungi due nuove funzioni denominate HideAllPlatforms() e ShowAllPlatforms() alla definizione della classe platform_series. Sposta l'espressione for che gestisce le piattaforme in HideAllPlatforms() e l'espressione che mostra le piattaforme in ShowAllPlatforms(). Poiché stai utilizzando la funzione Sleep(), queste funzioni devono essere asincrone, quindi aggiungi il modificatore <suspends> a ciascuna di esse. Quindi, in OnBegin(), chiama HideAllPlatforms() e poi 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:
   
   Expand code Copy full snippet(24 lines long)

6. Allo stato attuale, questo codice verrà eseguito solo una volta. Per far scomparire e riapparire le piattaforme nel corso del gioco, puoi utilizzare l'espressione loop per ripetere questo comportamento. Per gestire questo problema, aggiungi un'espressione loop a OnBegin() che includa le chiamate a HideAllPlatforms() e ShowAllPlatforms()In questo esempio, vuoi attivare o disattivare la visibilità della piattaforma per tutto il tempo di esecuzione del gioco, quindi non è necessario aggiungere un'espressione break per uscire dal loop.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Hide all platforms.
                HideAllPlatforms()
   
                # Show all platforms.
                ShowAllPlatforms()

   Copy full snippet(8 lines long)

   Eseguendo questo codice, le piattaforme scompaiono tutte in sequenza per poi riapparire nello stesso ordine fino alla fine del gioco.

7. Salva il codice e compilalo. Nel pannello Outliner di UEFN, seleziona il dispositivo platform_series per aprire il relativo pannello Dettagli.

8. Nel pannello Dettagli, alla voce DisappearingPlatforms, aggiungi un elemento array per ogni piattaforma del livello. Aggiungi nuovi elementi all'array con il pulsante "Aggiungi elemento", poi fai clic sul selettore oggetti e seleziona l'oggetto Creativa nella viewport. Assicurati che l'ordine di questo array corrisponda all'ordine su cui vuoi iterare:

   

Eseguendo questo codice, le piattaforme scompaiono tutte in sequenza per poi riapparire nello stesso ordine fino alla fine del gioco.

Sincronizzazione della scomparsa e riapparizione delle piattaforme

Per mettere sotto pressione il giocatore mentre salta sulle caselle, puoi fare in modo che le piattaforme inizino a scomparire mentre quelle più avanti nella sequenza continuano a comparire. In questo modo, il giocatore dovrà correre attraverso la serie o cadrà. Per creare questo comportamento, le due routine (ShowAllPlatforms() e HideAllPlatforms()) devono essere eseguite contemporaneamente e la seconda deve essere sfalsata rispetto alla prima in modo che il giocatore abbia un vantaggio per saltare sulla piattaforma successiva prima che scompaia.

Segui questi passaggi per nascondere e visualizzare tutte le piattaforme contemporaneamente.

1. Per far sì che HideAllPlatforms() e ShowAllPlatforms() vengano eseguite contemporaneamente, puoi utilizzare l'espressione sync. L'espressione sync esegue simultaneamente due (o più) espressioni asincrone nel suo blocco di codice e attende che tutte le sue espressioni finiscano prima di continuare. In OnBegin(), all'interno dell'espressione loop, aggiungi un'espressione sync su HideAllPlatforms() e ShowAllPlatforms()

   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()

   Copy full snippet(10 lines long)

2. Se esegui questo codice così com'è, una piattaforma viene nascosta e mostrata allo stesso tempo. Questo non è il risultato desiderato, quindi dovrai ritardare un po' la scomparsa della piattaforma. Per dare al giocatore un vantaggio, dovrai usare Sleep(), passando il valore HeadStart. Poiché l'espressione sync esegue contemporaneamente tutte le espressioni del suo blocco di codice, devi usare l'espressione block per annidare le espressioni Sleep() e HideAllPlatforms(). Aggiungi l'espressione block che copre Sleep() e HideAllPlatforms(). Ora la sincronizzazione eseguirà due espressioni. Il primo chiama ShowAllPlatforms(), il secondo chiama Sleep() e successivamente 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.
   
   Expand code Copy full snippet(11 lines long)

3. Salva lo script e fai clic su Verse, quindi su Compila il codice Verse per compilare il codice.

4. Fai clic su Avvia sessione nella barra degli strumenti UEFN per eseguire il playtest del livello.

   

Durante il playtest del livello, le piattaforme iniziano a scomparire in una sequenza, mentre le piattaforme successive della sequenza riappaiono; questo pattern si ripete per tutto il gioco.

Script completo

Il codice seguente è lo script completo per far scomparire e comparire una serie di piattaforme in una sequenza.

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

In autonomia

Completando questo tutorial, hai imparato a creare un dispositivo utilizzando Verse che attiva o disattiva la visibilità di una serie di piattaforme per tutta la durata del gioco.

Utilizzando ciò che hai imparato, prova quanto segue:

• Modificare l'ordine di apparizione e scomparsa delle piattaforme;

• Applicare gli stessi concetti per chiamare periodicamente funzioni su altri tipi di dispositivi, come il dispositivo Traslatore oggetti scenografici.