1. Epic GamesDeveloper
  3. Piattaforma a scomparsa al tocco

Piattaforma a scomparsa al tocco

Crea una piattaforma utilizzando Verse che scompare quando il giocatore la tocca e ricompare un numero casuale di secondi dopo.

Piattaforma a scomparsa al tocco

Le piattaforme che scompaiono quando ci si atterra sopra rappresentano un elemento cruciale per le modalità di gioco a piattaforma come i percorsi a ostacoli. Richiedono al giocatore di agire rapidamente e pianificare dove sta andando in modo da non cadere.

Seguendo questo tutorial, imparerai come costruire una piattaforma che scompare quando il giocatore la tocca e riappare un numero casuale di secondi dopo utilizzando Verse in Unreal Editor per Fortnite (UEFN). Questo esempio mostra come creare un'area in cui il giocatore deve saltare da una piattaforma all'altra per evitare di cadere. Lo script completo è incluso come riferimento alla fine di questa guida.

Piattaforma che scompare quando il giocatore la tocca e riappare un numero casuale di secondi dopo utilizzando Verse

Funzione del linguaggio Verse utilizzata

API Verse utilizzate

  • Sleep(): l'API Sleep() viene utilizzata per inserire i ritardi tra la piattaforma che scompare e ricompare di nuovo dopo un periodo di tempo casuale.

  • GetRandomFloat(): l'API GetRandomFloat() viene utilizzata per calcolare un periodo di tempo casuale prima che la piattaforma ricompaia.

  • Proprietà modificabili: quattro proprietà sono esposte a UEFN: tre float per controllare i ritardi di scomparsa e ricomparsa della piattaforma e il riferimento alla piattaforma stessa.

  • Eventi del dispositivo: userai il dispositivo attivatore TriggeredEvent per sapere quando un giocatore atterra sulla piattaforma.

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.

Inizializzare il modello iniziale

Questo esempio utilizza i seguenti oggetti scenografici e dispositivi.

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

  • 4 x oggetti scenografici creativi: gli oggetti scenografici creativi 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.

  • 4 x Dispositivo attivatore: Questi attivatori verranno utilizzati per sapere quando un giocatore atterra su ogni piattaforma.

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 RecyclePlatform.

    Seleziona recycle_platform nell'Outliner

  2. Aggiungi un dispositivo attivatore alla scena e impostalo come figlio della RecyclePlatform. Posizionalo sopra la piattaforma e ridimensionalo in modo che si adatti all'intera piattaforma. Nell'Outliner, imposta Visibile in gioco su Falso e Numero di attivazioni possibili su 1.

    Posiziona attivatore sulla piattaforma

  3. Posiziona il dispositivo Pedana di generazione giocatore sulla piattaforma. Questa è la posizione di generazione del giocatore all'inizio del gioco. Nell'Outliner, disattiva l'opzione Visibile in gioco in modo che i giocatori non possano rimanere sulla pedana di generazione giocatore dopo la generazione. La configurazione completa deve essere simile a:

    Posiziona il dispositivo Pedana di generazione giocatore sulla piattaforma

Creazione del dispositivo

Questo esempio utilizza un dispositivo Verse per definire il comportamento per far scomparire la piattaforma quando il giocatore atterra su di essa e farla riapparire un numero casuale di secondi più tardi. Segui questi passaggi per creare questo dispositivo utilizzando Verse.

  1. Crea un nuovo dispositivo Verse denominato disappear_on_touch_platform utilizzando Verse Explorer. Per informazioni su come creare un nuovo dispositivo in Verse, vedi Creare il tuo dispositivo utilizzando Verse.

    Crea un nuovo dispositivo Verse chiamato disappear_on_touch_platform

  2. Trascina il dispositivo disappear_on_touch_platform da Esplora contenuti nel livello.

Modifica delle proprietà del dispositivo in UEFN

Questa sezione mostra come esporre queste quattro proprietà del dispositivo a UEFN al fine di personalizzarle nell'editor:

  • Un riferimento al dispositivo dell'oggetto creativo inserito nel livello.

  • Una costante float, denominata DisappearDelay, per memorizzare quanto tempo aspettare dopo che il giocatore tocca la piattaforma prima di nasconderla.

  • Due costanti float, denominate DelayMin e DelayMax, per memorizzare la quantità minima e massima di tempo da attendere prima di far riapparire la piattaforma. Questi due valori definiscono l'intervallo consentito quando si ottiene un numero casuale.

Segui la procedura seguente per esporre queste proprietà dal dispositivo disappear_on_touch_platform creato nella sezione precedente.

  1. Apri Verse Explorer e fai doppio clic su disappear_on_touch_platform.verse per aprire lo script in Visual Studio Code.

  2. Alla definizione della classe disappear_on_touch_platform, aggiungi i seguenti campi:

    • Un float modificabile, chiamato DisappearDelay. È il tempo di attesa dopo che il giocatore tocca la piattaforma prima di nasconderla. Inizializza questo valore a 1.0, ovvero un secondo.

        # Quanto tempo aspettare dopo che il giocatore tocca la piattaforma prima di nasconderla.
  @editable
  DisappearDelay:float = 1.0

    • Un float modificabile chiamato DelayMin. È la quantità minima di tempo di attesa prima di far riapparire la piattaforma. Inizializza questo valore a 3.0, ovvero tre secondi.

        # È la quantità minima di tempo di attesa prima di far riapparire la piattaforma.
  @editable
  DelayMin:float = 3.0

    • Un float modificabile chiamato DelayMax. È la quantità massima di tempo di attesa prima di far riapparire la piattaforma. Inizializza questo valore a 4.0, ovvero quattro secondi.

        # È la quantità massima di tempo di attesa prima di far riapparire la piattaforma.
  @editable
  DelayMax:float = 4.0

    • Un creative_prop modificabile chiamato DisappearingPlatform. Si tratta della piattaforma di livello che scomparirà e riapparirà periodicamente. 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.

        # Riferimento alla piattaforma nel livello.
  @editable
  DisappearingPlatform:creative_prop = creative_prop{}

    • Un trigger_device modificabile chiamato PlatformTrigger. Avrai bisogno dell'evento TriggeredEvent di questo dispositivo per sapere quando un giocatore atterra sulla piattaforma.

        # La zona in cui il giocatore entra quando atterra sulla piattaforma.
  @editable
  PlatformTrigger:trigger_device = trigger_device{}

  3. I tuoi campi della classe disappear_on_touch_platform dovrebbero ora apparire così:

     # Dispositivo di Fortnite Creativo sviluppato con Verse che può essere inserito in un livello
 disappear_on_touch_platform := class(creative_device):

     # Quanto tempo aspettare dopo che il giocatore tocca la piattaforma prima di nasconderla.
     @editable
     DisappearDelay:float = 1.0

     # È la quantità minima di tempo di attesa prima di far riapparire la piattaforma.
     @editable
     DelayMin:float = 3.0

     # È la quantità massima di tempo di attesa prima di far riapparire la piattaforma.
     @editable
     DelayMax:float = 4.0

     # Riferimento alla piattaforma nel livello.
     @editable
     DisappearingPlatform:creative_prop = creative_prop{}

     # La zona in cui il giocatore entra quando atterra sulla piattaforma.
     @editable
     PlatformTrigger:trigger_device = trigger_device{}

    È utile usare l'attributo @editable per esporre valori come ToggleDelay 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 Compila il codice Verse per aggiornare il dispositivo disappear_on_touch_platform nel livello.

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

  7. Nel pannello Dettagli sotto Scomparsa al tocco della piattaforma, imposta Piattaforma su RecyclePlatform (l'oggetto creativo aggiunto al livello) facendo clic sul selettore di oggetti e selezionando il dispositivo della piattaforma nella viewport.

    Imposta la piattaforma su recycle_platform sul dispositivo Verse

  8. Ora che hai un oggetto di riferimento per il dispositivo Verse, seleziona entrambi i dispositivi e duplicali più volte nel livello per creare una serie di piattaforme tra cui il giocatore possa saltare. Ogni nuovo dispositivo Verse creato deve fare riferimento alla propria piattaforma.

    Duplica l'impostazione del dispositivo Verse e della piattaforma per aggiungere altro al livello

Nascondere e mostrare la piattaforma

Ora che hai impostato il livello e i dispositivi, puoi aggiungere la funzionalità per mostrare e nascondere la piattaforma quando un giocatore vi atterra sopra. Segui questi passaggi per aggiungere questo comportamento alla classe disappear_on_touch_platform:

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

     # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
 OnBegin<override>()<suspends>:void=

     # Rendere la piattaforma invisibile.
     DisappearingPlatform.Hide()

     # Rendere visibile la piattaforma.
     DisappearingPlatform.Show()

    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() (https://dev.epicgames.com/documentation/en-us/uefn/verse-api/versedotorg/simulation/sleep). La funzione Sleep() sospende l'esecuzione di una routine. Puoi 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.

     # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
 OnBegin<override>()<suspends>:void=

     # Attendere i secondi di DisappearDelay.
     Sleep(DisappearDelay)

     # Rendere la piattaforma invisibile.
     DisappearingPlatform.Hide()

     # Attendere i secondi di DisappearDelay.
     Sleep(DisappearDelay)

     # Rendere visibile la piattaforma.
     DisappearingPlatform.Show()

    Ora, se esegui questo codice, la piattaforma 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.

  3. Variare il tempo che la piattaforma impiega per riapparire può rendere il gioco più interessante. Invece di fornire lo stesso valore a Sleep() ogni volta, puoi ottenere un numero casuale di secondi con la funzione GetRandomFloat() e passare il suo valore a Sleep().

    • All'inizio del file, aggiungi using { /Verse.org/Random } per utilizzare la funzione GetRandomFloat().

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

  # Visita https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse per maggiori informazioni sulla creazione di un dispositivo Verse.

  # Dispositivo di Fortnite Creativo sviluppato con Verse che può essere inserito in un livello

  disappear_on_touch_platform := class(creative_device):

    • Utilizza la funzione GetRandomFloat() come argomento per Sleep() quando decidi quanto tempo aspettare prima di far riapparire la piattaforma e imposta l'intervallo di secondi consentito con DelayMin e DelayMax.

        # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
  OnBegin<override>()<suspends>:void=

  # Attendere i secondi di DisappearDelay.
  Sleep(DisappearDelay)

  # Rendere la piattaforma invisibile.
  DisappearingPlatform.Hide()

  # Attendere tra DelayMin e DelayMax secondi.
  Sleep(GetRandomFloat(DelayMin, DelayMax))

  # Rendere visibile la piattaforma.
  DisappearingPlatform.Show()

    Ora la piattaforma aspetterà per 1,0 secondo prima di scomparire e riapparirà tra 3,0 e 4,0 secondi dopo.

Rilevamento dell'atterraggio del giocatore sulla piattaforma

Per essere in grado di rilevare quando il giocatore atterra sulla piattaforma, puoi iscriverti all'evento TriggeredEvent che la classe trigger_device espone. L'attivatore invia il TriggeredEvent solo quando un giocatore ci passa sopra. Avendo impostato Numero di attivazioni possibili a uno, sarà necessario chiamare Reset() sull'attivatore per resettare il suo stato e permettergli di inviare nuovamente il TriggeredEvent.

Segui la procedura seguente per rilevare quando il giocatore tocca la piattaforma e utilizza il codice scritto nella sezione precedente per nascondere e visualizzare di nuovo la piattaforma in risposta.

  1. Il TriggeredEvent richiede una firma di funzione con un player opzionale come parametro e void come tipo di ritorno. L'agente è opzionale in questa funzione, poiché è possibile attivare i dispositivi attivatori anche tramite codice, quindi è necessario verificare se è stato un giocatore ad attivarlo. Aggiungi un nuovo metodo alla classe disappear_on_touch_platform chiamato OnPlayerTouch().

     OnPlayerTouch(ActivatingPlayer:?agent):void=

  2. In OnPlayerTouch(), in un'espressione if, cerca di ottenere il giocatore dall'opzione ActivatingPlayer. Se questa chiamata ha successo, sai che un giocatore ha attivato l'attivatore, anziché il codice.

     OnPlayerTouch(ActivatingPlayer:?agent):void=
     if:
         Player := ActivatingPlayer?
     then:
         Print("Un giocatore ha toccato una piattaforma!")

  3. In OnBegin(), iscriviti al PlatformTrigger.TriggeredEvent usando OnPlayerTouch come gestore dell'evento. Ora, ogni volta che un giocatore atterra su una piattaforma, il TriggeredEvent verrà attivato e verrà eseguito OnPlayerTouch().

     OnBegin<override>()<suspends>:void=

     # Iscriviti al TriggeredEvent di PlatformTrigger per sapere
     # quando un giocatore atterra sulla piattaforma.
     PlatformTrigger.TriggeredEvent.Subscribe(OnPlayerTouch)

  4. Quando la piattaforma è nascosta, i giocatori non sono in grado di attivare l'attivatore, poiché devono passare attraverso la piattaforma. Per gestire questo problema, in OnBegin(), aggiungi le chiamate a PlatformTrigger.Disable() e Enable() dopo rispettivamente Hide() e Show(). Ora l'attivatore non sarà interattivo quando la piattaforma è nascosta.

     OnBegin<override>()<suspends>:void=

     # Iscriviti al TriggeredEvent di PlatformTrigger per sapere
     # quando un giocatore atterra sulla piattaforma.
     PlatformTrigger.TriggeredEvent.Subscribe(OnPlayerTouch)

     # Attendere i secondi di DisappearDelay.
     Sleep(DisappearDelay)

     # Nascondere la piattaforma e disattivare l'attivatore.
     DisappearingPlatform.Hide()
     PlatformTrigger.Disable()

     # Attendere tra DelayMin e DelayMax secondi.
     Sleep(GetRandomFloat(DelayMin, DelayMax))

     # Mostrare la piattaforma e abilitare l'attivatore.
     DisappearingPlatform.Show()
     PlatformTrigger.Enable()

Sebbene sia necessario nascondere la piattaforma quando un giocatore vi atterra sopra, non puoi aggiungere il codice per nascondere e mostrare la piattaforma direttamente al metodo OnPlayerTouch(). Puoi chiamare la funzione Sleep() soltanto in un contesto asincrono e non puoi aggiungere lo specificatore suspends a OnPlayerTouch() perché TriggeredEvent non consente funzioni asincrone come gestore eventi. Si può invece usare spawn per chiamare una funzione asincrona da OnPlayerTouch(). Segui questi passaggi per aggiungere la tua funzione asincrona.

  1. Aggiungi un nuovo metodo RecyclePlatform() alla definizione della classe disappear_on_touch_platform. Aggiungi il modificatore <suspends> per consentire l'esecuzione asincrona del codice e spostare il codice per nascondere e mostrare la piattaforma e l'attivatore da OnBegin al blocco di codice RecyclePlatform().

     # Nascondere la piattaforma e resettare il PlatformTrigger. Quindi attendi un tempo casuale e riattiva la visualizzazione della piattaforma.
 RecyclePlatform()<suspends> : void =

     # Attendere i secondi di DisappearDelay.
     Sleep(DisappearDelay)

     # Nascondere la piattaforma e disattivare l'attivatore.
     DisappearingPlatform.Hide()
     PlatformTrigger.Disable()

     # Attendere tra DelayMin e DelayMax secondi.
     Sleep(GetRandomFloat(DelayMin, DelayMax))

     # Mostrare la piattaforma e abilitare l'attivatore.
     DisappearingPlatform.Show()
     PlatformTrigger.Enable()

  2. In OnPlayerTouch(), chiama spawn{} su RecyclePlatform() per eseguire il codice in modo asincrono. La funzione completa RecyclePlatform() deve essere simile a:

     # Viene eseguita quando un giocatore atterra sulla piattaforma. Richiama RecyclePlatform() per nascondere la piattaforma
 # e ripristina lo stato di attivazione.
 OnPlayerTouch(ActivatingPlayer:?agent):void=
     if:
         Player := ActivatingPlayer?
     then:
         Print("Un giocatore ha toccato una piattaforma!")
         spawn{RecyclePlatform()}

    Se esegui questo codice, la piattaforma scompare e poi ricompare quando il giocatore atterra per la prima volta sulla piattaforma.

    Asincrono suggerisce che il completamento di una parte di codice potrebbe richiedere del tempo. In questo caso, ad esempio, il riciclaggio della piattaforma richiede alcuni secondi a causa di tutte le chiamate Sleep(). Le funzioni asincrone consentono di eseguire operazioni senza bloccare l'esecuzione del codice che chiama la funzione asincrona. Per ulteriori informazioni sui contesti asincroni e sull'espressione spawn, vedi Concorrenza.

  3. Al momento, TriggeredEvent viene inviato soltanto la prima volta che il giocatore atterra sulla piattaforma. Per rendere l'evento nuovamente attivabile, puoi chiamare resetta l'attivatore. In RecyclePlatform(), chiama Reset() sul PlatformTrigger dopo aver chiamato Enable().

     # Nascondere la piattaforma e resettare il PlatformTrigger. Quindi attendi un tempo casuale e riattiva la visualizzazione della piattaforma.
 RecyclePlatform()<suspends> : void =

     # Attendere i secondi di DisappearDelay.
     Sleep(DisappearDelay)

     # Nascondere la piattaforma e disattivare l'attivatore.
     DisappearingPlatform.Hide()
     PlatformTrigger.Disable()

     # Attendere tra DelayMin e DelayMax secondi.
     Sleep(GetRandomFloat(DelayMin, DelayMax))

     # Mostrare la piattaforma e abilitare l'attivatore.
     DisappearingPlatform.Show()
     PlatformTrigger.Enable()

     # Azzerare il numero di volte in cui il PlatformTrigger può attivarsi.
     PlatformTrigger.Reset()

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

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

  6. Quando fai il playtest del tuo livello ora, ogni piattaforma deve scomparire quando atterri e riapparire un numero casuale di secondi dopo.

    Piattaforma che scompare quando il giocatore la tocca e riappare un numero casuale di secondi dopo utilizzando Verse

Script completo

Il codice seguente è lo script completo per far scomparire una piattaforma quando il giocatore atterra su di essa e farla riapparire dopo un numero casuale di secondi.

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

# Visita https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse per maggiori informazioni sulla creazione di un dispositivo Verse.
# Dispositivo di Fortnite Creativo sviluppato con Verse che può essere inserito in un livello
disappear_on_touch_platform := class(creative_device):

    # Quanto tempo aspettare dopo che il giocatore tocca la piattaforma prima di nasconderla.
    @editable
    DisappearDelay:float = 1.0

    # È la quantità minima di tempo di attesa prima di far riapparire la piattaforma.
    @editable
    DelayMin:float = 3.0

    # È la quantità massima di tempo di attesa prima di far riapparire la piattaforma.
    @editable
    DelayMax:float = 4.0

    # Riferimento alla piattaforma nel livello.
    @editable
    DisappearingPlatform:creative_prop = creative_prop{}

    # La zona in cui il giocatore entra quando atterra sulla piattaforma.
    @editable
    PlatformTrigger:trigger_device = trigger_device{}

    # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
    OnBegin<override>()<suspends>:void=

        # Iscriviti al TriggeredEvent di PlatformTrigger per sapere
        # quando un giocatore atterra sulla piattaforma.
        PlatformTrigger.TriggeredEvent.Subscribe(OnPlayerTouch)

    # Viene eseguita quando un giocatore atterra sulla piattaforma. Richiama RecyclePlatform() per nascondere la piattaforma
    # e ripristina lo stato di attivazione.
    OnPlayerTouch(ActivatingPlayer:?agent):void=
        if:
            Player := ActivatingPlayer?
        then:
            Print("Un giocatore ha toccato una piattaforma!")
            spawn{RecyclePlatform()}

    # Nascondere la piattaforma e resettare il PlatformTrigger. Quindi attendi un tempo casuale e riattiva la visualizzazione della piattaforma.
    RecyclePlatform()<suspends> : void =

        # Attendere i secondi di DisappearDelay.
        Sleep(DisappearDelay)

        # Nascondere la piattaforma e disattivare l'attivatore.
        DisappearingPlatform.Hide()
        PlatformTrigger.Disable()

        # Attendere tra DelayMin e DelayMax secondi.
        Sleep(GetRandomFloat(DelayMin, DelayMax))

        # Mostrare la piattaforma e abilitare l'attivatore.
        DisappearingPlatform.Show()
        PlatformTrigger.Enable()

        # Azzerare il numero di volte in cui il PlatformTrigger può attivarsi.
        PlatformTrigger.Reset()

In autonomia

Completando questo tutorial, hai imparato come creare un dispositivo utilizzando Verse che fa scomparire una piattaforma quando il giocatore atterra su di essa e la fa riapparire un numero casuale di secondi dopo.

Utilizzando ciò che hai imparato, prova quanto segue:

  • Gioca con le dimensioni e le posizioni delle piattaforme per creare una sfida interessante.

  • In questo esempio il giocatore non segna punti e non succede nulla quando cade. Riesci a pensare a come implementeresti un sistema di punteggio e una condizione di perdita?

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page