Crea la tua classifica di gioco in Verse

Questo tutorial si basa sui concetti di Statistiche giocatore persistenti. Dai subito un'occhiata!

Le classifiche sono un punto fermo dei giochi competitivi, consentendo ai giocatori di mostrare le proprie abilità e far conoscere il proprio nome. Aiutano i giocatori a sviluppare un senso di progressione e incoraggiano i giocatori a continuare a tornare in modo da potersi vedere salire in cima.

La Persistenza di Verse fornisce lo strumento che ti consente di creare le classifiche e aggiungere questo vantaggio competitivo alla tua esperienza. Hai già visto come tenere traccia dei dati persistenti tra le sessioni di gioco nel tutorial sulle statistiche persistenti dei giocatori e come modificare e aggiornare tali dati in base a eventi diversi. Ora applicherai queste conoscenze per imparare a creare classifiche locali complete, ordinare le statistiche dei giocatori e mettere tutto insieme in un gioco di corse!

Funzionalità del linguaggio Verse utilizzate

• Classe: questo esempio crea una classe Verse persistente che tiene traccia di un gruppo di statistiche per un giocatore.

• Costruttore: un costruttore è una funzione speciale che crea un'istanza della classe a cui è associato.

• weak_map: una weak_map è una mappa semplice che non può essere iterata. È necessario che i dati persistenti Verse siano memorizzati in una weak_map.

Configurazione del livello

Questo esempio utilizza i seguenti oggetti scenografici e dispositivi:

• 3 x Dispositivo Manifesto: mostrerà le statistiche sulla durata di vita per ogni giocatore e verrà ordinato in base ai punti vita per mostrare i migliori giocatori nella lobby.

• 3 x Dispositivo riferimento giocatore: in combinazione con le billboard, i riferimenti dei giocatori daranno un volto al nome dei tuoi migliori giocatori, in modo che gli altri giocatori sappiano a chi prestare attenzione durante la partita.

• 3 x Dispositivo Punto di controllo: corrisponde ai punti di controllo attraverso i quali i giocatori corrono per completare la gara.

• 1 x Dispositivo Gestione gara: tiene traccia di quando i giocatori iniziano e terminano la gara e assegna loro punti in base al piazzamento finale.

• 1 x Dispositivo Generatore di furgoni: genera il veicolo che utilizzerai durante la gara, che può essere cambiato in qualsiasi veicolo in base alla tua esperienza.

Segui questi passaggi per configurare il livello:

Billboard e riferimenti dei giocatori

Per visualizzare le statistiche dei giocatori, utilizzerai una combinazione di billboard e riferimenti dei giocatori. Ogni billboard mostrerà le statistiche sulla durata di un giocatore, mentre il riferimento del giocatore mostrerà una rappresentazione visiva di quel giocatore. Per aggiungere questi elementi, segui i passaggi:

1. Aggiungi tre dispositivi Riferimento giocatore al tuo livello e posizionali uno accanto all'altro.

2. Seleziona ogni riferimento giocatore nell'Outliner. Nel pannello Dettagli, in Opzioni utente, imposta Colore personalizzato sul colore con cui desideri rappresentare il primo, il secondo e il terzo giocatore definiti dalle migliori prestazioni nella lobby. In questo esempio vengono utilizzati oro, argento e bronzo come colori.

   

3. Aggiungi tre dispositivi Billboard al tuo livello e posiziona un livello davanti a ciascun riferimento giocatore. Li aggiornerai con le statistiche di ogni giocatore usando Verse all'inizio del gioco.

Punti di controllo, Furgone e Gestione gara

Dato che si tratta di una gara, avrai bisogno di qualcosa con cui gareggiare! Avrai anche bisogno di punti di controllo da attraversare e di una gestione gara per dirigere la gara durante il gioco. Per aggiungere questi elementi, segui i passaggi:

1. Aggiungi tre dispositivi Punto di controllo gara al tuo livello. Posizionali nell'ordine in cui vuoi che i giocatori corrano attraverso di loro. Per ogni punto di controllo, nell'Outliner, assicurati che il Numero del punto di controllo corrisponda all'ordine in cui i giocatori viaggiano attraverso i punti di controllo.

   

2. Aggiungi un dispositivo Gestione gara al tuo livello. Questo gestirà la corsa e indirizzerà i giocatori verso i punti di controllo. Ascolterai il RaceCompletedEvent() da questo dispositivo in un secondo momento, per sapere quando un giocatore termina la gara.

3. Aggiungi un dispositivo Generatore di furgoni al tuo livello. Il veicolo è facoltativo, ma questa guida utilizza un furgone per adattarsi al Modello Circuito e dare ai giocatori un mezzo con cui guidare.

Modifica della tabella delle statistiche

Questo esempio utilizza una versione modificata del file player_stats_table da Statistiche giocatore persistenti. Questo sarà simile al file di quell'esempio, con alcune differenze importanti che cambiano l'implementazione.

Segui i passaggi seguenti per creare la tabella delle statistiche dei giocatori:

1. Nella classe player_stats_table:

   1. Rimuovi la statistica Losses.

   2. Cambia la statistica Score in Points.

      Verse

       # Tracks different persistable stats for each player.
       player_stats_table<public>:= class<final><persistable>:
      
           # The version of the current stats table.
           Version<public>:int = 0
      
           # The Points of a player.
           Points<public>:int = 0
      
           # The number of Wins for a player.
      
      Expand code Copy full snippet(11 lines long)

2. Modifica la funzione di costruttore MakePlayerStatsTable() nel file per riflettere le statistiche aggiornate.

   Verse

        # Creates a new player_stats_table with the same values as the previous player_stats_table.
        MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
            Version := OldTable.Version
            Points := OldTable.Points
            Wins := OldTable.Wins

   Copy full snippet(5 lines long)

3. Aggiungi una nuova struttura player_and_stats al file player_stats_table.verse. La struttura contiene un riferimento a un player e alla sua classe player_stats_table per consentire di utilizzare entrambi i dati nelle funzioni senza doverli recuperare ripetutamente. La struttura completa player_and_stats deve assomigliare alla seguente:

   Verse

        # Structure for passing a player and their stats as arguments.
        player_and_stats<public> := struct:
            Player<public>:player
            StatsTable<public>:player_stats_table

   Copy full snippet(4 lines long)

Gestione delle statistiche

Come avviene in Statistiche giocatore persistenti, utilizzerai un file manager per gestire e registrare le modifiche alle statistiche dei giocatori.

Guarda i passaggi seguenti per creare il file player_stats_manager modificato.

1. Modifica la firma della funzione di InitializeAllPlayers() e InitializePlayer() in InitializeAllPlayerStats() e InitializePlayerStat(). Questi nomi riflettono meglio la relazione con la funzione GetPlayerStat(). La funzione aggiornata deve essere simile alla seguente:

   Verse

        # Initialize stats for all current players.
        InitializeAllPlayerStats<public>(Players:[]player):void =
            for (Player : Players):
                InitializePlayerStat(Player)
   
        # Initialize stats for the given player.
        InitializePlayerStat<public>(Player:player):void=
            if:
                not PlayerStatsMap[Player]
                set PlayerStatsMap[Player] = player_stats_table{}
   
   Expand code Copy full snippet(12 lines long)

2. Modifica la firma della funzione di AddScore() in AddPoints(). Quindi rimuovi la funzione AddLosses() perché player_stats_table non contiene più quel valore. Il file player_stats_manager completo deve essere simile al seguente:

   Verse

        # This file handles the code for initializing, updating, and returning player_stats_tables
        # for each player. It also defines an abstract stat_type class to use for updating stats, and the
        # StatType module to use when displaying stats.
   
        using { /Fortnite.com/Devices }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/Diagnostics }
   
        # Return the player_stats_table for the provided Agent.
        GetPlayerStats<public>(Agent:agent)<decides><transacts>:player_stats_table=
   
   Expand code Copy full snippet(55 lines long)

Costruire le classifiche dei giocatori

Per visualizzare i dati dei giocatori nelle tue classifiche, avrai bisogno di alcune cose. Hai bisogno di un modo per aggiornare il testo sui billboard e i giocatori sui dispositivi di riferimento del giocatore. Hai anche bisogno di un modo per ordinare questi dispositivi, poiché vuoi che i migliori giocatori siano i più importanti nella tua classifica. Poiché queste funzioni hanno un obiettivo simile di modificare i dispositivi nel livello, è consigliabile raggruppare le funzioni in un file comune.

Segui i passaggi seguenti per creare funzioni che aggiornano i tuoi dispositivi a livello interno:

1. Crea un nuovo file Verse denominato player_leaderboards.verse. Questo file memorizzerà le funzioni comuni per l'aggiornamento delle classifiche a livello interno.

2. Per il testo sul billboard, utilizzerai un messaggio a cui puoi passare argomenti. Crea un nuovo messaggio denominato StatsMessage che accetta CurrentPlayer, Points e Wins, tutti di tipo message, e che restituisce il testo combinato come message.

   Verse

        # The message to display on the stats billboard.
        StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
            "{CurrentPlayer}:\n{Points}\n{Wins}"
   

   Copy full snippet(3 lines long)

3. Aggiungi altre tre variabili message, una per ciascuno degli input a StatsMessage. Il messaggio PlayerText prende un Agent, il messaggio PointsText prende i punti di quell'agente, mentre il messaggio WinsText prende le vittorie di quell'agente. StatsMessage creerà un messaggio da tutti questi elementi per visualizzare in modo pulito i dati nel livello.

   Verse

        # The message to display on the stats billboard.
        StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
            "{CurrentPlayer}:\n{Points}\n{Wins}"
        PlayerText<localizes>(CurrentPlayer:agent):message = "Player {CurrentPlayer}"
        PointsText<localizes>(Points:int):message = "Total Points {Points}"
        WinsText<localizes>(Wins:int):message = "{Wins} Total Wins"

   Copy full snippet(6 lines long)

4. Per aggiornare una billboard, chiama la funzione UpdateStatsBillboard() dal tutorial sulle statistiche persistenti dei giocatori. Poiché questa funzione è definita in un file separato dal dispositivo Verse, devi inserire una StatsBillboard come argomento aggiuntivo per specificare quale billboard intendi aggiornare.

   Verse

        # Updates the given billboard device to display the stats of the given player.
        UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=

   Copy full snippet(2 lines long)

5. Innanzitutto, passa le statistiche del giocatore come argomento utilizzando GetPlayerStats[]. Non è necessario un riferimento a un player_stats_manager, poiché non è più una classe separata. Quindi costruisci un nuovo StatsMessage utilizzando il giocatore e i Points e Wins da CurrentPlayerStats. Infine, chiama SetText() su StatsBillboard per aggiornare il testo del billboard nel livello interno. La funzione UpdateStatsBillboard() completa deve essere simile a questa:

   Verse

        # Updates the given billboard device to display the stats of the given player.
        UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=
            if:
                CurrentPlayerStats := GetPlayerStats[Player]
            then:
                PlayerStatsText := StatsMessage(
                    PlayerText(Player),
                    PointsText(CurrentPlayerStats.Points),
                    WinsText(CurrentPlayerStats.Wins))
                StatsBillboard.SetText(PlayerStatsText)

   Copy full snippet(10 lines long)

Ordinamento e visualizzazione del miglior giocatore

Prima di continuare, è importante considerare come si desidera ordinare questi billboard. Vuoi che vinca il giocatore con il maggior numero di punti o il giocatore con il maggior numero di vittorie? E se volessi ordinare in base a statistiche diverse? Hai bisogno di un metodo per gestire tutto e un algoritmo di ordinamento può essere utile a questo scopo. Utilizzando un algoritmo di ordinamento e una funzione di confronto, puoi specificare i criteri in base ai quali vuoi eseguire l'ordinamento. Puoi quindi ordina i billboard e i riferimenti dei giocatori per mostrare i migliori giocatori della tua esperienza. Questo esempio utilizza l'algoritmo Ordinamento per fusione, ma puoi anche decidere di implementarne uno personalizzato.

Segui i passaggi seguenti per aggiungere il confronto e l'ordinamento ai tuoi billboard e completare l'aggiornamento dei dispositivi nel tuo livello.

1. Torna al file player_stats_table, definisci le funzioni di confronto per ognuna delle tue statistiche. Ciascuna di queste accetta una struttura Left e Right di player_and_stats e la confronta in base a una determinata statistica. Queste funzioni possiedono i modificatori <decides><transacts>; per questo motivo, se il confronto non riesce, nemmeno la funzione riuscirà. Ad esempio, facendoti sapere che Left è minore di Right. Aggiungi una nuova funzione denominata MorePointsComparison() al file player_stats_table.verse. Questa funzione controlla se Left.Points è maggiore di Right.Points e non riesce in caso contrario. Se l'esecuzione viene completata, restituisce `Left`.

   Verse

        # Returns Left if Left has greater Points than Right.
        MorePointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:Left=
            Left.StatsTable.Points > Right.StatsTable.Points
            Left

   Copy full snippet(4 lines long)

2. Copia questa funzione tre volte, una per un confronto a un numero minore di punti e due per il confronto delle vittorie. Le tue funzioni di confronto devono avere questo aspetto:

   Verse

        # Returns Left if Left has greater Points than Right.
        MorePointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
            Left.StatsTable.Points > Right.StatsTable.Points
            Left
   
        # Returns Left if Left has less Points than Right.
        LessPointsComparison<public>(Left:player_and_stats, Right:player_and_stats)<decides><transacts>:player_and_stats=
            Left.StatsTable.Points < Right.StatsTable.Points
            Left
   
   
   Expand code Copy full snippet(19 lines long)

3. Aggiungi l'algoritmo Ordinamento per fusione. Puoi posizionarlo in un file o modulo separato e provare l'algoritmo sul file di test fornito.

4. Vai di nuovo in player_leaderboards e aggiungi una nuova funzione UpdateStatsBillboards(). Questa funzione prende un array di agenti e un array di billboard, li ordina e chiama UpdateStatsBillboard() per aggiornare ogni billboard nel livello.

   Verse

        # Update the stats billboards by sorting them based on the amount of lifetime points
        # each player has.
        UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=

   Copy full snippet(3 lines long)

5. In UpdateStatsBillboards(), inizializza una nuova variabile di array di player_and_stats chiamata PlayerAndStatsArray. Imposta passaggio in modo uguale al risultato di un'espressione for. Nell'espressione for, per ogni agent, ottieni il player di questo agent e recupera la relativa player_stats_table utilizzando GetPlayerStats[]. Quindi restituisci una struttura player_and_stats costruita dal player e dalla tabella delle statistiche.

   Verse

        UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=
            var PlayerAndStatsArray:[]player_and_stats =
                for:
                    Agent:Players
                    Player := player[Agent]
                    PlayerStats := GetPlayerStats[Player]
                do:
                    player_and_stats:
                        Player := Player
                        StatsTable := PlayerStats

   Copy full snippet(10 lines long)

6. Per ordinare PlayerAndStatsArray, inizializza una nuova variabile SortedPlayersAndStats al risultato della chiamata MergeSort(), passando l'array e MorePointsComparison. Dopo aver ordinato in un'espressione for, itera tramite ogni elemento in SortedPlayerAndStats, memorizzando l'indice degli elementi in una variabile PlayerIndex. Utilizza PlayerIndex per l'indice nell'array StatsBillboards, poi chiama UpdateStatsBillboard passando il giocatore e la billboard per aggiornare. La funzione UpdateStatsBillboards() completa deve apparire nel modo seguente:

   Verse

        # Update the stats billboards by sorting them based on the amount of lifetime points
        # each player has.
        UpdateStatsBillboards<public>(Players:[]agent, StatsBillboards:[]billboard_device):void=
            var PlayerAndStatsArray:[]player_and_stats =
                for:
                    Agent:Players
                    Player := player[Agent]
                    PlayerStats := GetPlayerStats[Player]
                do:
                    player_and_stats:
   
   Expand code Copy full snippet(24 lines long)

7. Per aggiornare i riferimenti dei giocatori, utilizza una funzione molto simile chiamata UpdatePlayerReferences(). Questa funzione prende un array di player_reference_device non quello delle billboard e, invece di chiamare UpdateStatsBillboard() alla fine, chiama Register() sul dispositivo di riferimento per ogni giocatore. Copia il codice UpdateStatsBillboard() in una nuova funzione UpdatePlayerReferences() con le modifiche appena descritte. La funzione UpdatePlayerReferences() completa deve apparire nel modo seguente:

   Verse

        # Update the player references devices by sorting them based on the amount
        # of lifetime points each player has.
        UpdatePlayerReferences<public>(Players:[]player, PlayerReferences:[]player_reference_device):void=
            var PlayerAndStatsArray:[]player_and_stats =
                for:
                    Agent:Players
                    Player := player[Agent]
                    PlayerStats := GetPlayerStats[Player]
                do:
                    player_and_stats:
   
   Expand code Copy full snippet(25 lines long)

Classifiche dei giocatori nel tuo livello

Ora che tutto è configurato, è il momento di mettere in mostra i tuoi giocatori! Crea un dispositivo per assegnare i punti ai giocatori quando interagiscono con il pulsante e ordina i riferimenti dei giocatori e i billboard in modo che i migliori giocatori siano davanti e al centro. Segui questa procedura per creare un dispositivo Verse per provare le classifiche nel tuo livello:

1. Crea un nuovo dispositivo Verse chiamato player_leaderboards_example. Per informazioni sugli step, vedi Creare un dispositivo personalizzato utilizzando Verse.

2. All'inizio della definizione della classe player_leaderboards_example, aggiungi i seguenti campi:

   • Un array modificabile di dispositivi Riferimento giocatore chiamato PlayerReferences. Questi offrono rappresentazioni visive di ogni giocatore nella gara.

     Verse

       # Visual representations of each player.
       @editable
       PlayerReferences:[]player_reference_device = array{}
     

     Copy full snippet(3 lines long)

   • Un array modificabile di dispositivi Billboard chiamato Leaderboards. Questi visualizzano statistiche di ogni giocatore su un billboard nel livello.

     Verse

       # Billboards that display each player's stats.
       @editable
       Leaderboards:[]billboard_device = array{}
     

     Copy full snippet(3 lines long)

   • Un dispositivo Gestione gara modificabile denominato RaceManager. Iscriviti agli eventi dal sistema di Gestione gara per sapere quando un giocatore termina la gara.

     Verse

       # Tracks when players complete a race, with the players in the first spot being awarded a win.
       @editable
       RaceManager:race_manager_device = race_manager_device{}
     

     Copy full snippet(3 lines long)

   • Un intero modificabile denominato PlacementRequiredForWin. Questa è la posizione in cui si deve piazzare un giocatore per ottenere una vittoria.

     Verse

       # The placement of a player must be at or below to award a win.
       @editable
       PlacementRequiredForWin:int = 1
     

     Copy full snippet(3 lines long)

   • Un array modificabile di interi chiamato PointsPerPlace. Questi sono i numeri di punti che ogni giocatore ottiene in base alla posizione.

     Verse

       # The number of points a player in each place earns.
       # Adjust this to award your players the desired amount of score
       # based on their placement.
       @editable
       PointsPerPlace:[]int = array{5, 3, 1}
     

     Copy full snippet(5 lines long)

   • Una variabile intera denominata CurrentFinishOrder. Questa è la posizione del giocatore che ha completato più recentemente la gara.

     Verse

       # The spot of the player who just finished the race.
       # The first three players to finish the race will be awarded a win.
       var CurrentFinishOrder:int = 0
     

     Copy full snippet(3 lines long)

Assegnazione di statistiche in base al posizionamento

Quando un giocatore termina la gara, aggiorni le sue statistiche in base alla sua posizione. I giocatori che si piazzano in buone posizioni devono ricevere un maggiore numero di punti e a quelli nelle posizioni migliori deve essere assegnata una vittoria.

Per assegnare le statistiche ai giocatori quando terminano una gara, segui questa procedura:

1. Per gestire questo passaggio, aggiungi una nuova funzione RecordPlayerFinish() alla definizione della classe player_leaderboards_example. Questa funzione considera il giocatore a cui assegnare le statistiche come un parametro.

   Verse

        # When a player finishes the race, award them points based on their placement, and award them a win if
        # their placement was better than the PlacementRequiredForWin.
        RecordPlayerFinish(Player:agent):void=
   

   Copy full snippet(3 lines long)

2. In RecordPlayerFinish(), ottieni la posizione del giocatore tramite il valore corrente di CurrentFinishOrder in un nuovo int chiamato PlayerFinishOrder. Poi incrementa CurrentFinishOrder in modo che il giocatore successivo a terminare la gara non abbia la stessa posizione.

   Verse

        RecordPlayerFinish(Player:agent):void=
            PlayerFinishOrder:int = CurrentFinishOrder
            set CurrentFinishOrder += 1
   

   Copy full snippet(3 lines long)

3. È il momento di assegnare le statistiche. Per sapere quanti punti assegnare ai giocatori, in un'espressione if, indicizza nell'array PointsPerPlace utilizzando PlayerFinishOrder. Poi chiama AddPoints() per assegnare quel numero di punti al giocatore.

   Verse

        set CurrentFinishOrder += 1
            if:
                PointsToAward := PointsPerPlace[PlayerFinishOrder]
            then:
                AddPoints(Player, PointsToAward)
   

   Copy full snippet(5 lines long)

4. Se la posizione del giocatore è sufficiente per la vittoria, registra una vittoria nella sua tabella delle statistiche. In un'altra espressione if, controlla se PlayerFinishOrder è inferiore a PlacementRequiredToWin. In questo caso, chiama AddWin(), passa il giocatore e assegnagli una vittoria. La funzione RecordPlayerFinish() completa deve avere questo aspetto:

   Verse

        # When a player finishes the race, award them points based on their placement, and award them a win if
        # their placement was better than the PlacementRequiredForWin.
        RecordPlayerFinish(Player:agent):void=
            PlayerFinishOrder:int = CurrentFinishOrder
            set CurrentFinishOrder += 1
            if:
                PointsToAward := PointsPerPlace[PlayerFinishOrder]
            then:
                AddPoints(Player, PointsToAward)
   
   
   Expand code Copy full snippet(16 lines long)

In attesa che i giocatori terminino la gara

Ora che la registrazione delle statistiche è pronta, devi sapere quando un giocatore termina la gara per aggiornare le sue statistiche. Per farlo, ascolta RaceCompletedEvent() del gestore della gara. Questo evento si verifica ogni volta che un giocatore termina la gara, quindi devi ascoltare in modo continuo in una funzione asincrona.

1. Aggiungi una nuova funzione WaitForPlayerToFinishRace() alla definizione della classe player_leaderboards_example. Questa funzione prende un giocatore e attende che termini la gara.

   Verse

        # When a player finishes the race, record a finish in their stats table.
        WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
   

   Copy full snippet(2 lines long)

2. In WaitForPlayerToFinishRace(), in un'espressione race, avvia due loop. Il primo attende che il giocatore finisca la gara e il secondo gestisce ciò che succede se un giocatore lascia la sessione prima del termine. Se un giocatore esce, non vuoi che il loop continui per sempre, quindi hai bisogno di un modo per uscire da questa situazione.

   Verse

        # When a player finishes the race, record a finish in their stats table.
        WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
            race:
                # Waiting for this player to finish the race and then record the finish.
                loop:
                # Waiting for this player to leave the game.
                loop:
   

   Copy full snippet(7 lines long)

3. Nel primo loop, attendi RaceManager.RaceCompletedEvent e memorizza il risultato in una variabile chiamata FinishingPlayer. Dato che questo evento si verifica ogni volta che un giocatore termina la gara, devi verificare che il giocatore che hai memorizzato sia quello che stavi monitorando. Confronta FinishingPlayer e il giocatore monitorato da questo loop. Se sono uguali, passa il giocatore a RecordPlayerFinish() e interrompi il loop

   Verse

        # Waiting for this player to finish the race and then record the finish.
        loop:
            FinishingPlayer := RaceManager.RaceCompletedEvent.Await()
            if:
                FinishingPlayer = Player
            then:
                RecordPlayerFinish(Player)
                break
   

   Copy full snippet(8 lines long)

4. Nel secondo loop, attendi l'evento dello spazio di gioco PlayerRemovedEvent(). Come prima, ottieni il giocatore che è appena uscito e memorizzalo in una variabile LeavingPlayer. Se il giocatore che è appena uscito è il giocatore che questo loop sta aspettando, interrompi il loop. La funzione WaitForPlayerToFinishRace() completa deve avere questo aspetto:

   Verse

        # When a player finishes the race, record a finish in their stats table.
        WaitForPlayerToFinishRace(Player:agent)<suspends>:void=
            race:
                # Waiting for this player to finish the race and then record the finish.
                loop:
                    FinishingPlayer := RaceManager.RaceCompletedEvent.Await()
                    if:
                        FinishingPlayer = Player
                    then:
                        RecordPlayerFinish(Player)
   
   Expand code Copy full snippet(19 lines long)

Collegare tutti gli elementi

Quando le tue funzioni sono pronte, devi collegarle ai tuoi dispositivi e iniziare la gara!

Segui questa procedura per collegare la tua logica ai tuoi dispositivi:

1. In OnBegin(), ottieni tutti i giocatori nello spazio di gioco usando GetPlayers(). Passa questo array a InitializeAllPlayerStats() in modo da configurare player_stats_tables per ognuno di loro.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            # Get the players in the current race and create a player_stat_table
            # for each of them.
            Players := GetPlayspace().GetPlayers()
            InitializeAllPlayerStats(Players)

   Copy full snippet(6 lines long)

2. Chiama UpdateStatsBillboards(), passando gli array Players e Leaderboards per aggiornare le billboard nel livello con i dati correnti di ogni giocatore. Poi chiama UpdatePlayerReferences() per aggiornare i riferimenti nel livello in modo che corrispondano ai giocatori. Infine, in un'espressione for, genera una funzione WaitForPlayerToFinishRace() per ogni giocatore. La funzione OnBegin() completa deve apparire nel seguente modo:

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            # Get the players in the current race and create a player_stat_table
            # for each of them.
            Players := GetPlayspace().GetPlayers()
            InitializeAllPlayerStats(Players)
            UpdateStatsBillboards(Players, Leaderboards)
            UpdatePlayerReferences(Players, PlayerReferences)
   
            # Wait for all players to finish the race.
   
   Expand code Copy full snippet(15 lines long)

3. Salva il codice e compilalo.

Trascina il dispositivo player_leaderboards_example nel livello. Assegna i riferimenti dei giocatori all'array PlayerReferences, prendendo nota dell'ordine. Il dispositivo nel primo indice deve corrispondere al riferimento del primo giocatore, il secondo indice a quello del secondo giocatore e così via. Fai lo stesso per le classifiche, verificando che siano allineate ai dispositivi di riferimento dei giocatori. Ricorda di assegnare anche il dispositivo di Gestione gara!

Test delle classifiche persistenti

Puoi testare i tuoi dati persistenti in una sessione di modifica, ma questi dati verranno ripristinati quando esci e lanci di nuovo la sessione. Per fare in modo che i dati vengano mantenuti da una sessione all'altra, dovrai avviare una sessione di playtest e modificare alcune impostazioni nelle Impostazioni isola. Per sapere di più sulla configurazione della tua isola, e per testare i dati persistenti nelle sessioni di modifica e di playtest, dai un'occhiata a Test con dati persistenti ed esegui le modifiche necessarie nelle Impostazioni isola. Per sapere di più sulla configurazione della tua isola, e per testare i dati persistenti nelle sessioni di modifica e di playtest, dai un'occhiata a Test con i dati persistenti.

Dopo aver configurato la tua sessione, quando vuoi eseguire il playtest del tuo livello, ai giocatori che terminano la gara devono essere assegnati punti in base alla loro posizione. Deve essere assegnata una vittoria se la loro posizione è sufficientemente alta e queste statistiche devono essere persistenti da una sessione di gioco all'altra. I giocatori e le loro statistiche devono essere ordinati con il giocatore con più punti in prima posizione.

Ora tocca a te

Dopo aver completato questa guida, hai imparato come creare le classifiche che visualizzano le statistiche persistenti dei giocatori nel tuo livello. Hai imparato anche come ordinare e aggiornare queste classifiche, verificando che tutti possano vedere chi sono i migliori giocatori. Cerca di adattare questo tutorial alle tue esperienze e metti in mostra il meglio del meglio!

Codice completo

player_stats_table.verse

    # This file defines a player_stats_table, a collection of persistable player statistics.
    # It also contains functions to compare stats tables by each of the stats to order players
    # when sorting.

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

    # Structure for passing a player and their stats as arguments.
    player_and_stats<public> := struct:

player_leaderboards.verse

    # This file contains the code that updates the billboards, player references, and UI on the island
    # to display a player's stats from their player stats table. It also handles adding wins and points to a
    # player's stats table.

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation}

    # The message to display on the stats billboard.
    StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message=
        "{CurrentPlayer}:\n{Points}\n{Wins}"

player_stats_manager.verse

    # This file handles the code for initializing, updating, and returning player_stats_tables
    # for each player. It also defines an abstract stat_type class to use for updating stats, and the
    # StatType module to use when displaying stats.

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

    # Return the player_stats_table for the provided Agent.
    GetPlayerStats<public>(Agent:agent)<decides><transacts>:player_stats_table=

player_leaderboards_example.verse

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

    # 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
    player_leaderboards_example := class(creative_device):
        # Visual representations of each player.