Gestione di gioco riutilizzabile

Questo tutorial utilizza Verse per rendere possibili alcune funzioni. Utilizzando Verse in questo tutorial, potrai:

• Attivare e riprodurre animazioni a intermittenza per creare una meccanica di gameplay.

• Aggiornare le informazioni sul punteggio del giocatore per tutti i giocatori in un minigioco.

• Creare ritardi nella generazione dei giocatori e tempi di generazione intermittente degli oggetti.

Puoi riutilizzare questo codice per eseguire le seguenti operazioni:

• Commutare i dispositivi abilitati e disabilitati mentre il gioco passa dall'HUB al gameplay e di nuovo all'HUB.

• Controllare i punteggi dei giocatori per trovare il punteggio vincente e visualizzarlo nell'HUB.

• Terminare il gioco e teletrasportare i giocatori all'HUB alla fine del minigioco.

Configurazione del dispositivo Verse e degli oggetti modificabili

Segui questi passaggi per configurare il tuo dispositivo Verse e gli oggetti modificabili:

1. Crea un nuovo dispositivo Verse denominato tiltnboom e aggiungilo al livello. Per informazioni sulla procedura, dai un'occhiata a Creare un dispositivo personalizzato utilizzando Verse.

2. Aggiungi i seguenti moduli all'inizio del file:

   Verse

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

   Copy full snippet(6 lines long)

3. Aggiungi i seguenti campi alla definizione di classe tiltnboom:

   1. Due dispositivi attivatori modificabili: ActivateGameTrigger e EndGameTrigger. ActivateGameTrigger viene utilizzato per attivare questo gioco. Il trigger può essere attivato da qualsiasi cosa, ad esempio un teletrasporto verso il gioco o dopo una cinematica introduttiva.

      EndGameTrigger permette di terminare il minigioco e rimuovere tutte le telecamere e i dispositivi di controllo dai giocatori al termine della partita.

   Verse

        @editable
        ActivateGameTrigger:trigger_device = trigger_device{}
   
        @editable
        EndGameTrigger:trigger_device = trigger_device{}
   

   Copy full snippet(5 lines long)

   1. Dispositivo Timer modificabile denominato GameTimer. Permette di terminare il gioco dopo un determinato periodo di tempo.

   2. Un array di dispositivi Sequenza cinematica denominato CannonballSequences, con ogni dispositivo dell'array che riproduce una diversa posizione di atterraggio della palla di cannone.

   3. Array di Volumi di danni denominato DamageVolumes che si attiva e disattiva in base allo stato di gioco.

   4. Array di Generatori oggetti denominato ItemSpawner che genera un numero casuale di oggetti durante la partita.

   5. Dispositivo Area di acquisizione denominato CaptureArea. Assegna ai giocatori dei punti per la presenza sulla zattera e si attiva o disattiva in base allo stato di gioco.

   6. Dispositivo Gestione punteggio denominato ScoreManager che reimposta il punteggio dei giocatori all'inizio della partita e determina il giocatore vincitore al termine.

   7. Teletrasporto chiamato HUBTeleporter che riporta tutti all'HUB al termine della partita.

   8. Dispositivo Riferimento giocatore denominato PlayerReference che visualizza il giocatore vincitore nell'HUB tra una partita e l'altra.

      Verse

                                   @editable
                                   GameTimer:timer_device = timer_device{}
      								        
                                   @editable
                                   CannonballSequences:[]cinematic_sequence_device = array{}
      								        
                                   @editable
                                   DamageVolumes:[]damage_volume_device = array{}
      								
                                   @editable
      
      Expand code Copy full snippet(23 lines long)

4. Due array modificabili di Pedane di generazione giocatore denominati PlayerSpawners e HUBSpawners. Questi array disattivano la generazione al termine del minigioco e riportano i giocatori all'HUB.

   Verse

            @editable
            PlayerSpawners:[]player_spawner_device = array{}
   		
            @editable
            HUBSpawners:[]player_spawner_device = array{}
   

   Copy full snippet(5 lines long)

5. Due float modificabili denominati MinimumItemSpawnTime e MaximumItemSpawnTime. Indicano il tempo di attesa minimo e massimo tra le generazioni di oggetti sulla zattera.

   Verse

            @editable
            MinimumItemSpawnTime:float = 5.0
   		
            @editable
            MaximumItemSpawnTime:float = 10.0
   

   Copy full snippet(5 lines long)

6. Un float modificabile denominato DelayAfterGame. Indica il ritardo per il teletrasporto dei giocatori nell'HUB una volta terminata la partita.

   Verse

            @editable
            DelayAfterGame:float = 5.0
   

   Copy full snippet(2 lines long)

7. Un float denominato DelayBetweenCannonballSequences. È il ritardo con cui vengono riprodotte le palle di cannone tra le sequenze per tutta la durata del minigioco.

   Verse

        DelayBetweenCannonballSequences:float = 8.0
   

   Copy full snippet(1 line long)

8. Una variabile logica denominata GameActive per determinare se il gioco è attivo o meno.

   Verse

            var GameActive:logic = false
   

   Copy full snippet(1 line long)

Avvio del gioco

All'avvio del minigioco vengono attivati diversi dispositivi e il punteggio del giocatore viene reimpostato su 0.

1. Sopra la definizione della classe tiltnboom, aggiungi un canale di registro per la stampa dei messaggi specifici del minigioco. Poi aggiunge un logger alla definizione della classe da utilizzare con il canale di registro.

   Verse

        tiltnboom_log_channel := class(log_channel){}
   		
        # A Verse-authored creative device that can be placed in a level
        tiltnboom := class(creative_device):
   		
            Logger:log = log{Channel := tiltnboom_log_channel}
   

   Copy full snippet(6 lines long)

2. Aggiunge un nuovo metodo OnTriggered alla definizione della classe titnboom che prende un InitiatingAgent e avvia il gioco. Aggiungi un'espressione if al metodo che restituisce se il gioco è già attivo in modo da non avviarlo se è già in esecuzione.

   Verse

            OnTriggered(InitiatingAgent:?agent):void=
                if (GameActive?):
                    return
   		
                spawn{StartGame()}
   

   Copy full snippet(5 lines long)

3. In OnBegin(), iscrive TriggeredEvent di ActivateGameTrigger alla funzione OnTriggered per avviare il gioco. I dispositivi da abilitare all'inizio del minigioco verranno iscritti a questo evento e vengono abilitati quando l'evento OnTrigger viene attivato.

   Verse

            OnBegin<override>()<suspends>:void=
   
                ActivateGameTrigger.TriggeredEvent.Subscribe(OnTriggered)

   Copy full snippet(3 lines long)

4. Aggiungi un nuovo metodo StartGame() che gestisce la logica di avvio del gioco. Aggiungi il modificatore <suspends> a questa funzione in modo che possa essere eseguita in modo asincrono.

   Per prima cosa, imposta GameActive su true per segnalare che la partita è attiva. Poi attiva CaptureArea e ogni DamageVolume nell'array DamageVolumes.

   Per ogni giocatore, se quel giocatore ha un punteggio superiore a 0, lo reimposta assegnandogli l'inverso del suo punteggio attuale per ottenere 0.

   Quindi, in un'espressione race, corre tra il timer che termina, la sequenza di palle di cannone in esecuzione e la generazione di oggetti casuali. La sequenza di palle di cannone e la generazione di oggetti casuali sono loop infiniti, ma vengono annullati appena il timer termina.

   Al termine del gioco, chiama la funzione OnGameFinished() per gestire la pulizia alla fine del gioco.

   Verse

        StartGame()<suspends>:void=
            Logger.Print("Starting game.")
            set GameActive = true
   
            CaptureArea.Enable()
   
            for (DamageVolume : DamageVolumes):
                DamageVolume.Enable()
   
            for:
   
   Expand code Copy full snippet(23 lines long)

Creazione di un loop per palle di cannone

Questa sezione tratta l'aggiunta di una funzione che riproduce le Sequenze cinematiche delle palle di cannone.

1. Aggiungi un nuovo metodo StartCannonSequence() alla definizione della classe tiltnboom che riproduce le sequenze livelli delle palle di cannone e utilizza un loop per riprodurre l'espressione delay e inserire un ritardo tra le palle di cannone. Aggiungi il modificatore <suspends> a questa funzione in modo che possa essere eseguita in modo asincrono.

   In un loop, scegli una sequenza casuale nell'array CannonballSequences indicizzandola con GetRandomInt(). Riproduci la sequenza, poi resta in sospensione per un determinato periodo di tempo DelayBetweenCannonballSequences prima di riprodurre un'altra sequenza.

   Verse

        StartCannonSequence()<suspends>:void=
            loop:
   
                RandomCannonballSequence:int = GetRandomInt(0, CannonballSequences.Length - 1)
   
                if (CannonballSequence := CannonballSequences[RandomCannonballSequence]):
                    Logger.Print("Set CannonballSequence to {RandomCannonballSequence}")
   
                    CannonballSequence.Play()
   
   
   Expand code Copy full snippet(11 lines long)

Creazione di loop di oggetti con generazione casuale

Questa sezione tratta la creazione di una funzione che genera in loop oggetti casuali in punti casuali della zattera che possono aumentare o diminuire le probabilità di vittoria di un giocatore nel minigioco.

1. Aggiungi un nuovo metodo denominato SpawnRandomItems alla definizione della classe tiltnboom. Questo metodo controlla gli oggetti che vengono generati sulla zattera.

2. Determina il numero di oggetti nell'array ItemSpawners, quindi esegui un loop nell'array. Utilizza un int casuale per ottenere un generatore di oggetti casuali dall'array, quindi attivalo. Resta in sospensione per un periodo di tempo casuale tra le generazioni degli oggetti.

3. Il loop decide in modo casuale quanti elementi riprodurre e seleziona casualmente un elemento da riprodurre per un numero di volte pari a NumberOfItemsToSpawn. Il parametro DelayBetweenItemSpawns genera un tempo indeterminato di attesa tra le generazioni.

   Verse

            SpawnRandomItems()<suspends>:void=
                ItemSpawnerCount:int = ItemSpawners.Length - 1
   
                loop:
   
                    NumberOfItemsToSpawn:int = GetRandomInt(0, ItemSpawnerCount)
   
                    # Spawn a randomly selected item, as many times as NumberOfItemsToSpawn.
                    for:
                        CurrentItemSpawnNumber := 0..NumberOfItemsToSpawn
   
   Expand code Copy full snippet(17 lines long)

Termine della partita

Al termine del minigioco dovrai inviare il punteggio del vincitore all'HUB, disattivare i dispositivi e teletrasportare i giocatori nell'HUB.

1. Aggiungi un nuovo metodo OnGameFinished alla definizione della classe tiltnboom. Quando il gioco è terminato, questa funzione imposta il gioco come inattivo e disabilita i relativi dispositivi.

   ~~~(verse) OnGameFinished()<suspends>:void= Logger.Print("Partita terminata.") set GameActive = false

   CaptureArea.Disable()

   for (PlayerSpawner : PlayerSpawners): PlayerSpawner.Disable()

   for (DamageVolume : DamageVolumes): DamageVolume.Disable() ~~~

2. Aggiungi variable int HighestScore per tenere traccia del giocatore con il punteggio più alto e un riferimento variabile opzionale a quel giocatore WinningPlayer.

   Verse

                var HighestScore:int = -1
                var WinningPlayer:?agent = false
   

   Copy full snippet(2 lines long)

3. In un'espressione for/do, ottieni tutti i giocatori nello spazio di gioco, quindi ottieni FortCharacter per ciascuno di essi. Congela il personaggio in posizione usando PutInStasis(), passando una nuova serie di stasis_args per permettere di girarsi e utilizzare emote in modo che i giocatori possano festeggiare la partita.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    FortCharacter.PutInStasis(stasis_args{AllowTurning := true, AllowEmotes := true})
   

   Copy full snippet(5 lines long)

4. In un'istruzione if, controlla il punteggio di ogni giocatore per trovare e memorizzare il punteggio vincente nel dispositivo Riferimento giocatore nell'HUB.

   Verse

                    if (ScoreManager.GetCurrentScore(Player) > HighestScore):
   		                
                        set HighestScore = ScoreManager.GetCurrentScore(Player)
                        set WinningPlayer = option{Player}
   

   Copy full snippet(4 lines long)

5. Infine, in un'altra istruzione if, chiama TeleportPlayersToHUB() per teletrasportare tutti di nuovo all'HUB quando viene trovato un punteggio vincente.

   Verse

                if(Winner := WinningPlayer?):
                    PlayerReference.Register(Winner)
   		
                TeleportPlayersToHUB()
   

   Copy full snippet(4 lines long)

Teletrasporto dei giocatori all'HUB

Quando i punteggi sono stati calcolati e viene dichiarato un vincitore, tutti i giocatori devono essere teletrasportati nell'HUB.

1. Aggiungi un nuovo metodo TeleportPlayersToHUB() alla definizione della classe tiltnboom. Questo metodo abilita tutti i Generatori giocatori nell'HUB, quindi attende qualche secondo prima di teletrasportarli tutti nell'HUB. Questo metodo deve anche attivare EndGameTrigger per rimuovere la telecamera e i dispositivi di controllo dai giocatori.

   Verse

            TeleportPlayersToHUB()<suspends>:void=
   
                for (HUBSpawner : HUBSpawners):
                    HUBSpawner.Enable()
   
                Sleep(DelayAfterGame)
   
                EndGameTrigger.Trigger()

   Copy full snippet(8 lines long)

2. In un'espressione for, teletrasporta ogni giocatore all'HUBTeleporter e li libera dalla stasi.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    HUBTeleporter.Teleport(Player)
   		
                    Sleep(1.0)
   		
                    FortCharacter.ReleaseFromStasis()
   

   Copy full snippet(9 lines long)

In autonomia

Modifica questo codice per creare diversi task da far eseguire al dispositivo Timer. Invece di determinare la durata di un minigioco, puoi utilizzare il dispositivo Timer per cronometrare una corsa.

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

    tiltnboom_log_channel := class(log_channel){}

    # A Verse-authored creative device that can be placed in a level