1. Epic GamesDeveloper
  3. Statistiche giocatore persistenti

Statistiche giocatore persistenti

Scopri come creare statistiche persistenti dei giocatori che vengono salvate tra le sessioni di gioco.

Statistiche giocatore persistenti

Molte esperienze utilizzano le statistiche dei giocatori per tenere traccia dei dati relativi alla loro esperienza nel tempo. Statistiche come il punteggio massimo, il totale delle partite vinte, il tempo di gioco totale e gli oggetti raccolti danno ai giocatori un senso di progressione e sono tutti ottimi modi per incoraggiare i giocatori a continuare a giocare.

La persistenza in Verse è un potente strumento che consente di aggiungere dati persistenti agli script Verse. I dati persistenti vengono salvati per giocatore e per isola e rimangono invariati tra le sessioni di gioco. I dati persistenti permettono di tenere traccia dei progressi dei giocatori tra una sessione di gioco e l'altra e apriranno una serie di esperienze di gioco uniche e interessanti precedentemente non disponibili in UEFN.

Questo tutorial mostra come creare una tabella personalizzata di statistiche dei giocatori con Verse e come impostarla in modo che sia persistente tra le varie partite del gioco. Al termine di questo tutorial, dai un'occhiata a Crea la tua classifica di gioco in Verse per imparare come utilizzare la persistenza nelle classifiche di gioco integrate!

Funzionalità del linguaggio Verse utilizzate

  • Classe: Questo esempio crea una classe Verse che gestisce una singola statistica e una classe persistente che tiene traccia di un gruppo di statistiche per un singolo giocatore.

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

  • weak_map: weak_map è una mappa semplice su cui non si può iterare. È necessario che i dati persistenti Verse siano memorizzati in una weak_map.

Configurazione di un livello

Questo esempio utilizza i seguenti oggetti scenografici e dispositivi.

  • 2 dispositivi Pulsante: Quando il giocatore interagisce con il dispositivo, aggiunge un punto al suo punteggio corrente. Userai un altro dispositivo pulsante per simulare la fine di una partita, aggiungendo alle vittorie o alle sconfitte del giocatore un punto a seconda del suo punteggio attuale.

  • 1 x dispositivo Billboard: Spesso è importante visualizzare dati persistenti al giocatore. A volte questo viene fatto a scopo di test, altre volte per aumentare il coinvolgimento del giocatore o mostrare i progressi. Anche se i requisiti su quando mostrare i dati e quali dati mostrare variano da esperienza a esperienza, in questo esempio verranno mostrati i dati statistici per il punteggio, il punteggio massimo, le vittorie e le sconfitte su un dispositivo billboard.

Impostazione del livello

Tracciamento delle statistiche persistenti del giocatore

Innanzitutto, è importante definire quali statistiche vuoi monitorare per ogni giocatore. Per esempio, potresti voler tenere traccia del punteggio assoluto di un giocatore, della sua posizione attuale o del suo miglior tempo sul giro. In questo esempio, terrai traccia di punteggio, vittorie e sconfitte in una tabella di valori statistici per ogni giocatore. Lo farai in una nuova classe, player_stats_table, che sarà la tua classe persistente principale.

Segui questa procedura per creare la classe player_stats_table:

  1. Crea un nuovo file Verse con Verse Explorer chiamato player_stats_table.

  2. Nel nuovo file Verse crea una nuova classe chiamata player_stats_table. Aggiungi alla classe i modificatori <persistable> e <final>. Il modificatore <persistable> permette ai dati della classe di essere persistenti e richiede il modificatore <final>, perché i dati persistenti non possono essere sovrascritti o sottoclassificati.

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

 # Tiene traccia di diverse statistiche persistenti per ogni giocatore.
 player_stats_table := class<final><persistable>:

  3. Alla tabella player_stats_table, aggiungi tre valori int chiamati Score, Wins e Losses. Questi valori tengono conto, rispettivamente, del punteggio, delle vittorie e delle sconfitte di ogni giocatore. Inoltre, aggiungi un int chiamato Version per tracciare la versione attuale della tabella player_stats_table.

     # Tiene traccia di diverse statistiche persistenti per ogni giocatore.
 player_stats_table := class<final><persistable>:
     # Versione della tabella delle statistiche attuale.
     Version<public>:int = 0
        
     # Il punteggio di un giocatore.
     Score<public>:int = 0

     # Il numero di vittorie di un giocatore.
     Wins<public>:int = 0

     # Il numero di sconfitte di un giocatore.
     Losses<public>:int = 0

  4. Per creare un'istanza della classe player_stats_table, userai una funzione <constructor>. Questo costruttore è necessario perché la persistenza in Verse non consente alle classi contenenti campi variabili di essere persistenti. L'uso di un costruttore consente di aggiornare i valori della classe persistente creando una copia di una statistica esistente persistente che è variabile, aggiornando la copia e sostituendo poi l'istanza originale della classe con i valori modificati. Aggiungi un nuovo costruttore MakePlayerStatsTable() al tuo file. Questo costruttore prenderà un'istanza originale (precedente) della classe player_stats_table e ne creerà una nuova dai valori originali.

     # Crea una nuova player_stats_table con gli stessi valori della player_stats_table.
 MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
     Version := OldTable.Version
     Score := OldTable.Score
     Wins := OldTable.Wins
     Losses := OldTable.Losses

  5. Per tenere traccia di tutte le player_stats_tables, userai una weak_map persistente di player a istanze player_stats_table. Aggiungi questa mappa debole al tuo file.

     # Mappa i giocatori in una tabella con le loro statistiche.
 var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

  6. La tua classe completa player_stats_table deve ora essere simile a:

     using { /Fortnite.com/Devices }
 using { /Verse.org/Simulation }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 # Tiene traccia di diverse statistiche persistenti per ogni giocatore.
 player_stats_table := class<final><persistable>:

     # Versione della tabella delle statistiche attuale.
     Version<public>:int = 0

     # Il punteggio di un giocatore.
     Score<public>:int = 0

     # Il numero di vittorie di un giocatore.
     Wins<public>:int = 0

     # Il numero di sconfitte di un giocatore.
     Losses<public>:int = 0

 # Crea una nuova player_stats_table con gli stessi valori della player_stats_table.
 MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
     Version := OldTable.Version
     Score := OldTable.Score
     Wins := OldTable.Wins
     Losses := OldTable.Losses

 # Mappa i giocatori in una tabella con le loro statistiche.
 var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

Gestione delle statistiche del giocatore per tutti i giocatori

La tua classe player_stats_table ti permette di tenere traccia delle statistiche di un singolo giocatore, ma non hai ancora un modo per gestirle. Devi aggiornare le tabelle delle statistiche di ogni giocatore ogni volta che guadagna punti e, a seconda del design della tua esperienza, potrebbero esserci più giocatori contemporaneamente.

Per risolvere questo problema, si utilizzerà un'altra classe per gestire le statistiche di tutti i giocatori e registrare le modifiche alle statistiche ogni volta che un giocatore ottiene una vittoria, una sconfitta o un punteggio. Segui i passaggi seguenti per impostare la classe gestione.

  1. Crea un nuovo file Verse usando Verse Explorer chiamato player_stats_manager. In questo file, crea una nuova classe player_stats_manager.

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

 # Gestisce e aggiorna player_stat_tables per ogni giocatore.
 player_stats_manager := class():

  2. Il player_stats_manager deve fare diverse cose. Deve impostare una player_stats_table per un giocatore, aggiornare Score, Wins e Losses per ogni giocatore e restituire player_stats_table per un giocatore. Ciascuna di queste funzioni sarà gestita in modo separato. Aggiungi una nuova funzione InitializePlayer() alla definizione della classe player_stats_manager. Questa funzione inizializzerà le statistiche del giocatore dato.

     # Inizializza le statistiche per il giocatore indicato.
 InitializePlayer(Player:player):void=

  3. In InitializePlayer(), controlla se il giocatore dato esiste già nella PlayerStatsMap. In caso contrario, imposta il valore di quel giocatore nella mappa in una nuova player_stats_table. La funzione InitializePlayer() completata deve essere simile alla seguente:

     # Inizializza le statistiche per il giocatore indicato.
 InitializePlayer(Player:player):void=
     if:
         not PlayerStatsMap[Player]
         set PlayerStatsMap[Player] = player_stats_table{}
     else:
         Print("Impossibile inizializzare le statistiche del giocatore")

  4. Aggiungi una nuova funzione InitializeAllPlayers() alla definizione della classe player_stats_manager. Questa funzione prende un array di giocatori e chiama InitializePlayer() su tutti loro. La funzione InitializeAllPlayers() completata deve essere simile alla seguente:

     # Inizializza le statistiche per tutti i giocatori attuali.
 InitializeAllPlayers(Players:[]player):void =
     for (Player : Players):
         InitializePlayer(Player)

  5. Per restituire le statistiche di un particolare giocatore, è necessaria una funzione che restituisca player_stats_table di quel giocatore. Aggiungi una nuova funzione GetPlayerStats() alla definizione della classe player_stats_manager che accetta un agente. Aggiungi il modificatore <decides><transacts> per consentire a questa funzione di fallire e tornare indietro nel caso in cui la tabella delle statistiche del giocatore non esista. In GetPlayerStats(), crea una nuova variabile player_stats_table PlayerStats.

     # Restituisci il player_stats_table per l'agente fornito.
 GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
     var PlayerStats:player_stats_table = player_stats_table{}

  6. In un'espressione if, esegui il cast dell'Agent passato a questa funzione a un Player, quindi recupera la player_stats_table per quel giocatore dalla PlayerStatsMap. Poi imposta PlayerStats su quella tabella chiamando MakePlayerStatsTable(). Infine, restituisci PlayerStats. La funzione GetPlayerStats() completata deve essere simile a:

     # Restituisci il player_stats_table per l'agente fornito.
 GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
     var PlayerStats:player_stats_table = player_stats_table{}
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         set PlayerStats = MakePlayerStatsTable(PlayerStatsTable)
     PlayerStats

  7. Per aggiornare ciascuna delle statistiche relative a punteggi, vittorie e sconfitte, creerai funzioni per ogni statistica. Aggiungi una nuova funzione chiamata AddScore() al tuo file player_stats_manager. Questa funzione prevede che l'agente assegni il punteggio e il numero int di punti per assegnarli.

     # Aggiunge al punteggio dell'agente e aggiorna entrambe le tabelle delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddScore<public>(Agent:agent, NewScore:int):void=

  8. I dati vengono aggiornati prima convalidando che il giocatore abbia dati validi nella weak_map persistente e poi sostituendo quei dati con una copia aggiornata della classe. Per gestire il punteggio, recupera il punteggio del giocatore dalla PlayerStatsTable, poi imposta la tabella nella PlayerStatsMap al risultato di costruire una nuova player_stats_table utilizzando MakePlayerStatsTable(), passando il punteggio attuale più il nuovo punteggio. Quando lavori con una classe che contiene più campi, la classe del costruttore ti permette di aggiornare facilmente un singolo campo senza copiare esplicitamente tutti i campi ogni volta che vuoi eseguire un aggiornamento. La tua funzione AddScore() deve essere simile a:

     # Aggiunge al punteggio dell'agente e aggiorna entrambe le tabelle delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddScore<public>(Agent:agent, NewScore:int):void=
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         CurrentScore := PlayerStatsTable.Score
         set PlayerStatsMap[Player] = player_stats_table:
             MakePlayerStatsTable<constructor>(PlayerStatsTable)
             Score := CurrentScore + NewScore
     else:
         Print("Impossibile registrare il punteggio del giocatore")

  9. Ripeti questo processo per le vittorie e le sconfitte, aggiungendo NewWins e NewLosses rispettivamente alle vittorie o alle sconfitte del giocatore quando chiami MakePlayerStatsTable().

     # Aggiunge alle vittorie dell'agente e aggiorna entrambe le tabelle delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddWin<public>(Agent:agent, NewWins:int):void=
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         CurrentWins := PlayerStatsTable.Wins
         set PlayerStatsMap[Player] = player_stats_table:
             MakePlayerStatsTable<constructor>(PlayerStatsTable)
             Wins := CurrentWins + NewWins
     else:
         Print("Impossibile registrare le vittorie del giocatore")
    
 # Aggiunge alle sconfitte dell'agente e aggiorna entrambe le tabelle delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddLoss<public>(Agent:agent, NewLosses:int):void=
     if:
         Player := player[Agent]
         PlayerStatsTable := PlayerStatsMap[Player]
         CurrentLosses := PlayerStatsTable.Losses
         set PlayerStatsMap[Player] = player_stats_table:
             MakePlayerStatsTable<constructor>(PlayerStatsTable)
             Losses := CurrentLosses + NewLosses
     else:
         Print("Impossibile registrare la sconfitta del giocatore")

  10. Il file finale player_stats_manager deve essere simile al seguente.

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

 # Gestisce e aggiorna player_stat_tables per ogni giocatore.
 player_stats_manager := class():

     # Restituisci il player_stats_table per l'agente fornito.
     GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
         var PlayerStats:player_stats_table = player_stats_table{}
         if:
             Player := player[Agent]
             PlayerStatsTable := PlayerStatsMap[Player]
             set PlayerStats = MakePlayerStatsTable(PlayerStatsTable)
         PlayerStats

     # Inizializza le statistiche per tutti i giocatori attuali.
     InitializeAllPlayers(Players:[]player):void =
         for (Player : Players):
             InitializePlayer(Player)

     # Inizializza le statistiche per il giocatore indicato.
     InitializePlayer(Player:player):void=
         if:
             not PlayerStatsMap[Player]
             set PlayerStatsMap[Player] = player_stats_table{}
         else:
             Print("Impossibile inizializzare le statistiche del giocatore")

     # Aggiunge al punteggio dell'agente e aggiorna entrambe le tabelle delle statistiche
     # in PlayerStatsManager e il billboard nel livello.
     AddScore<public>(Agent:agent, NewScore:int):void=
         if:
             Player := player[Agent]
             PlayerStatsTable := PlayerStatsMap[Player]
             CurrentScore := PlayerStatsTable.Score
             set PlayerStatsMap[Player] = player_stats_table:
                 MakePlayerStatsTable<constructor>(PlayerStatsTable)
                 Score := CurrentScore + NewScore
         else:
             Print("Impossibile registrare il punteggio del giocatore")

     # Aggiunge alle vittorie dell'agente e aggiorna entrambe le tabelle delle statistiche
     # in PlayerStatsManager e il billboard nel livello.
     AddWin<public>(Agent:agent, NewWins:int):void=
         if:
             Player := player[Agent]
             PlayerStatsTable := PlayerStatsMap[Player]
             CurrentWins := PlayerStatsTable.Wins
             set PlayerStatsMap[Player] = player_stats_table:
                 MakePlayerStatsTable<constructor>(PlayerStatsTable)
                 Wins := CurrentWins + NewWins
         else:
             Print("Impossibile registrare le vittorie del giocatore")
        
     # Aggiunge alle sconfitte dell'agente e aggiorna entrambe le tabelle delle statistiche
     # in PlayerStatsManager e il billboard nel livello.
     AddLoss<public>(Agent:agent, NewLosses:int):void=
         if:
             Player := player[Agent]
             PlayerStatsTable := PlayerStatsMap[Player]
             CurrentLosses := PlayerStatsTable.Losses
             set PlayerStatsMap[Player] = player_stats_table:
                 MakePlayerStatsTable<constructor>(PlayerStatsTable)
                 Losses := CurrentLosses + NewLosses
         else:
             Print("Impossibile registrare la sconfitta del giocatore")

Testare la persistenza con i dispositivi

Ora che sono state impostate le classi di persistenza, è il momento di testarle nel livello.

  1. Crea un nuovo dispositivo Verse chiamato player_stats_example. Per informazioni sui passaggi, vedi Creare il tuo dispositivo utilizzando Verse.

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

    1. Un button_device modificabile chiamato ScorePointsButton. Questo pulsante aggiunge punti al punteggio del giocatore ogni volta che viene attivato.

       # Aggiunge al punteggio del giocatore attivante.
 @editable
 ScorePointsButton:button_device = button_device{}

    2. Un billboard_device modificabile chiamato StatsBillboard. Questo visualizzerà il punteggio, il punteggio massimo, le vittorie e le sconfitte del giocatore.

       # Visualizza il punteggio, il punteggio massimo, le vittorie e le sconfitte del giocatore.
 @editable
 StatsBillboard:billboard_device = billboard_device{}

    3. Un button_device modificabile chiamato CheckWinButton. Questo pulsante azzera il punteggio di ogni giocatore e gli assegna una vittoria o una sconfitta a seconda del suo punteggio.

       # Azzera il punteggio del giocatore e gli assegna una vittoria o una sconfitta
 # a seconda che il punteggio attuale sia maggiore di WinScore.
 @editable
 CheckWinButton:button_device = button_device{}

    4. Un int modificabile chiamato WinScore. È il punteggio che i giocatori devono raggiungere per ottenere una vittoria dopo l'attivazione di CheckWinButton.

       # Il punteggio che i giocatori devono raggiungere per ottenere una vittoria dopo che
 # il pulsante CheckWinButton è attivato.
 @editable
 WinScore:int = 10

    5. Un int modificabile denominato AwardScore. Questi sono i punti che vengono assegnati ai giocatori quando interagiscono con il pulsante.

       # Il valore del punteggio da assegnare per ogni pressione di un pulsante.
 @editable
 AwardScore:int = 1

    6. Un player_stats_manager chiamato PlayerStatsManager. Questo gestirà e aggiornerà le statistiche di tutti i giocatori.

       # Gestisce e aggiorna le statistiche di ogni giocatore.
 PlayerStatsManager:player_stats_manager = player_stats_manager{}

    7. Un messaggio chiamato StatsMessage che prende un agente e quattro numeri interi: Score, MaxScore, Wins e Losses. Questo messaggio viene utilizzato per visualizzare le statistiche di un giocatore sul billboard.

       # Mostra le statistiche di un giocatore su un billboard.
 StatsMessage<localizes>(Player:agent, Score:int, Wins:int, Losses:int):message = "{Player}, Statistiche:\n Punteggio: {Score}\n Vittorie: {Wins}\n Sconfitte: {Losses}"

  3. Compila il codice e trascina il dispositivo creato con Verse sulla tua isola. Per i passaggi, vedi Aggiunta del dispositivo Verse al tuo livello.

  4. Nel pannello Dettagli del dispositivo, assegna il dispositivo Pulsante del livello a ScorePointsButton e assegna il dispositivo Billboard a StatsBillboard.

    Assegnazione del dispositivo

  5. Per visualizzare le statistiche di un determinato giocatore su StatsBillboard, aggiungi una nuova funzione UpdateStatsBillboard() alla definizione della classe player_stats_example. Questa funzione prende l'agente di cui visualizzare le statistiche.

     # Recupera le statistiche del giocatore dato e le mostra
 # sul StatsBillboard.
 UpdateStatsBillboard(Agent:agent):void=

  6. In UpdateStatsBillboard(), ottieni le statistiche attuali dell'agente chiamando la funzione GetPlayerStats[] del gestore delle statistiche. Poi chiama SetText() su StatsBillboard passando un nuovo StatsMessage(). Per costruire questo StatsMessage(), ottieni il punteggio, le vittorie e le sconfitte dell'agente accedendovi dalle statistiche attuali dell'agente. La funzione UpdateStatsBillboard() completata deve essere simile a:

     # Recupera le statistiche del giocatore dato e le mostra
 # sul StatsBillboard.
 UpdateStatsBillboard(Agent:agent):void=
     if:
         # Ottenere le statistiche correnti dell'agente dato.
         CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
     then:
         StatsBillboard.SetText(
             StatsMessage(
                 Player := Agent,
                 Score:=CurrentPlayerStats.Score.CurrentValue,
                 Wins:=CurrentPlayerStats.Wins.CurrentValue,
                 Losses:=CurrentPlayerStats.Losses.CurrentValue
             )
         )

  7. Aggiungi una nuova funzione AddScore() alla definizione della classe player_stats_example. Questa funzione prende un agente e aggiunge al suo punteggio ogni volta che interagisce con il pulsante ScorePointsButton.

     # Aggiunge al punteggio del giocatore dato e aggiorna sia la sua tabella delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddScore(Agent:agent):void=

  8. In AddScore(), ottieni le statistiche attuali dell'agente e il suo punteggio attuale. Quindi chiama AddScore() dal PlayerStatsManager, passando l'agente e l'AwardScore per assegnare loro un nuovo punteggio. Infine, chiama UpdateStatsBillboard(), passando l'agente. La funzione AddScore() completata deve essere simile a:

     # Aggiunge al punteggio del giocatore dato e aggiorna sia la sua tabella delle statistiche
 # in PlayerStatsManager e il billboard nel livello.
 AddScore(Agent:agent):void=
     if:
         CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         CurrentScore := CurrentPlayerStats.Score
     then:
         Print("Il punteggio attuale è: {CurrentScore}")
         PlayerStatsManager.AddScore(Agent, AwardScore)
         UpdateStatsBillboard(Agent)

  9. Per assegnare al giocatore una vittoria o una sconfitta quando si interagisce con il pulsante CheckWin, aggiungi una nuova funzione CheckWin() alla definizione della classe player_stats_manager.

     # Attribuisce a un giocatore una vittoria o una sconfitta quando interagisce
 # con il CheckWinButton.
 CheckWin(Agent:agent):void=

  10. Per prima cosa, definire una variabile CurrentScore per tenere traccia del punteggio attuale dell'agente. Quindi, come con la funzione AddScore(), recupera il suo punteggio attuale dalla tabella delle statistiche del giocatore.

     # Attribuisce a un giocatore una vittoria o una sconfitta quando interagisce
 # con il CheckWinButton.
 CheckWin(Agent:agent):void=
     var CurrentScore:int = 0
     if:
         PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         set CurrentScore = PlayerStats.Score

  11. Se il punteggio attuale dell'agente è maggiore di WinScore, è necessario registrare una vittoria nel PlayerStatsManager. Altrimenti, registra una sconfitta. Infine, azzera il punteggio dell'agente chiamando AddScore() con un CurrentScore negativo, quindi visualizza le statistiche dell'agente sul billboard delle statistiche. La funzione CheckWin() completata deve essere simile a:

     # Attribuisce a un giocatore una vittoria o una sconfitta quando interagisce
 # con il CheckWinButton.
 CheckWin(Agent:agent):void=
     var CurrentScore:int = 0
     if:
         PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         set CurrentScore = PlayerStats.Score
     then:
         Print("Il punteggio attuale è: {CurrentScore}") 
     if:
         CurrentScore > WinScore
     then:
         PlayerStatsManager.AddWin(Agent, 1)
         # Azzerare il punteggio del giocatore registrando la sua statistica di punteggio come 0.
         PlayerStatsManager.AddScore(Agent, -CurrentScore)
     else:
         PlayerStatsManager.AddLoss(Agent, 1)
         # Azzerare il punteggio del giocatore registrando la sua statistica di punteggio come 0.
         PlayerStatsManager.AddScore(Agent, -CurrentScore)
        
     UpdateStatsBillboard(Agent)

  12. In OnBegin(), sottoscrivi il pulsante ScorePointsButton.InteractedWithEvent a AddScore() e il CheckWinButton.InteractedWithEvent a CheckWin(). Ottieni quindi l'array di ogni giocatore del gioco chiamando GetPlayers() e inizializzali tutti usando la funzione InitializeAllPlayers() del gestore delle statistiche.

     # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
 OnBegin<override>()<suspends>:void=
     # Registrare gli eventi dei pulsanti
     ScorePointsButton.InteractedWithEvent.Subscribe(AddScore)
     CheckWinButton.InteractedWithEvent.Subscribe(CheckWin)
     Players := GetPlayspace().GetPlayers()

     # Inizializzare le statistiche del giocatore
     PlayerStatsManager.InitializeAllPlayers(Players)

  13. Salva il codice e compilalo.

Testare la persistenza nel livello

Puoi testare i tuoi dati persistenti in una sessione di modifica, ma questi dati verranno ripristinati quando esci e lanci di nuovo la sessione. Affinché i tuoi dati siano persistenti da una sessione all'altra, devi lanciare una sessione di playtest e modificare alcune impostazioni nelle tue Impostazioni dell'isola. Per informazioni sulla configurazione della tua isola per testare i dati persistenti sia nelle sessioni di modifica e di playtest, dai un'occhiata a Test con i dati persistenti nella pagina dei dati persistenti.

Dopo aver impostato la sessione, durante il playtest del livello, l'interazione con il pulsante ScorePoints deve aggiungere il punteggio del giocatore e visualizzare l'aggiornamento sul billboard. Interagendo con il pulsante CheckWin si aggiungono le vittorie o le sconfitte del giocatore, a seconda del suo punteggio. Una volta tornati nella lobby e rientrati nell'isola, le statistiche del giocatore devono persistere e il totale delle vittorie/perdite e il punteggio più alto devono essere visualizzati sul billboard ogni volta che viene aggiornato.

Statistiche persistenti

In autonomia

Al termine di questa guida, hai imparato a usare Verse per creare dati persistenti tracciati per giocatore, che persistono durante le sessioni di gioco. Ora vai a vedere come puoi adattare la persistenza per migliorare la tua esperienza.

  • Puoi creare un sistema di file di salvataggio che ricordi l'ultimo checkpoint raggiunto dal giocatore?
  • Che ne dici di un sistema che ricordi con quali personaggi hai parlato e la tua attuale relazione con loro?
  • Che ne dici di un sistema che dia ai giocatori solo una quantità limitata di tempo, nel corso delle sessioni, per raggiungere gli obiettivi, e che azzeri i loro progressi se falliscono?

Codice completo

Questo è il codice completo compilato in questa sezione del tutorial.

player_stats_table.verse

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

# Tiene traccia di diverse statistiche persistenti per ogni giocatore.
player_stats_table := class<final><persistable>:
    # Versione della tabella delle statistiche attuale.
    Version<public>:int = 0
    
    # Il punteggio di un giocatore.
    Score<public>:int = 0

    # Il numero di vittorie di un giocatore.
    Wins<public>:int = 0

    # Il numero di sconfitte di un giocatore.
    Losses<public>:int = 0

# Crea una nuova player_stats_table con gli stessi valori della player_stats_table.
MakePlayerStatsTable<constructor>(OldTable:player_stats_table)<transacts> := player_stats_table:
    Version := OldTable.Version
    Score := OldTable.Score
    Wins := OldTable.Wins
    Losses := OldTable.Losses
    
# Mappa i giocatori in una tabella con le loro statistiche.
var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

player_stats_manager.verse

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

# Gestisce e aggiorna player_stat_tables per ogni giocatore.
player_stats_manager := class():
    
    # Restituisci il player_stats_table per l'agente fornito.
    GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
        var PlayerStats:player_stats_table = player_stats_table{}
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            set PlayerStats = MakePlayerStatsTable(PlayerStatsTable)
        PlayerStats

    # Inizializza le statistiche per tutti i giocatori attuali.
    InitializeAllPlayers(Players:[]player):void =
        for (Player : Players):
            InitializePlayer(Player)
        
    # Inizializza le statistiche per il giocatore indicato.
    InitializePlayer(Player:player):void=
        if:
            not PlayerStatsMap[Player]
            set PlayerStatsMap[Player] = player_stats_table{}
        else:
            Print("Impossibile inizializzare le statistiche del giocatore")

    # Aggiunge al punteggio dell'agente e aggiorna entrambe le tabelle delle statistiche
    # in PlayerStatsManager e il billboard nel livello.
    AddScore<public>(Agent:agent, NewScore:int):void=
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            CurrentScore := PlayerStatsTable.Score
            set PlayerStatsMap[Player] = player_stats_table:
                MakePlayerStatsTable<constructor>(PlayerStatsTable)
                Score := CurrentScore + NewScore
        else:
            Print("Impossibile registrare il punteggio del giocatore")

    # Aggiunge alle vittorie dell'agente e aggiorna entrambe le tabelle delle statistiche
    # in PlayerStatsManager e il billboard nel livello.
    AddWin<public>(Agent:agent, NewWins:int):void=
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            CurrentWins := PlayerStatsTable.Wins
            set PlayerStatsMap[Player] = player_stats_table:
                MakePlayerStatsTable<constructor>(PlayerStatsTable)
                Wins := CurrentWins + NewWins
        else:
            Print("Impossibile registrare le vittorie del giocatore")
    
    # Aggiunge alle sconfitte dell'agente e aggiorna entrambe le tabelle delle statistiche
    # in PlayerStatsManager e il billboard nel livello.
    AddLoss<public>(Agent:agent, NewLosses:int):void=
        if:
            Player := player[Agent]
            PlayerStatsTable := PlayerStatsMap[Player]
            CurrentLosses := PlayerStatsTable.Losses
            set PlayerStatsMap[Player] = player_stats_table:
                MakePlayerStatsTable<constructor>(PlayerStatsTable)
                Losses := CurrentLosses + NewLosses
        else:
            Print("Impossibile registrare la sconfitta del giocatore")

player_stats_example.verse

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

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

    # Aggiunge al punteggio del giocatore attivante.
    @editable
    ScorePointsButton:button_device = button_device{}

    # Visualizza il punteggio, il punteggio massimo, le vittorie e le sconfitte del giocatore.
    @editable
    StatsBillboard:billboard_device = billboard_device{}

    # Azzera il punteggio del giocatore e gli assegna una vittoria o una sconfitta
    # a seconda che il punteggio attuale sia maggiore di WinScore.
    @editable
    CheckWinButton:button_device = button_device{}

    # Il punteggio che i giocatori devono raggiungere per ottenere una vittoria dopo che
    # il pulsante CheckWinButton è attivato.
    @editable
    WinScore:int = 10

    # Il valore del punteggio da assegnare per ogni pressione di un pulsante.
    @editable
    AwardScore:int = 1

    # Gestisce e aggiorna le statistiche di ogni giocatore.
    PlayerStatsManager:player_stats_manager = player_stats_manager{}

    # Mostra le statistiche di un giocatore su un billboard.
    StatsMessage<localizes>(Player:agent, Score:int, Wins:int, Losses:int):message = "{Player}, Statistiche:\n Punteggio: {Score}\n Vittorie: {Wins}\n Sconfitte: {Losses}"

    # Viene eseguito quando il dispositivo viene avviato in un gioco in esecuzione
    OnBegin<override>()<suspends>:void=
        # Registrare gli eventi dei pulsanti
        ScorePointsButton.InteractedWithEvent.Subscribe(AddScore)

        CheckWinButton.InteractedWithEvent.Subscribe(CheckWin)

        Players := GetPlayspace().GetPlayers()

        # Inizializzare le statistiche del giocatore
        PlayerStatsManager.InitializeAllPlayers(Players)

    # Aggiunge al punteggio del giocatore dato e aggiorna sia la sua tabella delle statistiche
    # in PlayerStatsManager e il billboard nel livello.
    AddScore(Agent:agent):void=
        if:
            CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
            CurrentScore := CurrentPlayerStats.Score
        then:
            Print("Il punteggio attuale è: {CurrentScore}")
            PlayerStatsManager.AddScore(Agent, AwardScore)
            UpdateStatsBillboard(Agent)
       
    # Recupera le statistiche del giocatore dato e le mostra
    # sul StatsBillboard.
    UpdateStatsBillboard(Agent:agent):void=
        if:
            # Ottenere le statistiche correnti dell'agente dato.
            CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
        then:
            StatsBillboard.SetText(
                StatsMessage(
                    Player := Agent,
                    Score:=CurrentPlayerStats.Score,
                    Wins:=CurrentPlayerStats.Wins,
                    Losses:=CurrentPlayerStats.Losses
                )
            )

    # Attribuisce a un giocatore una vittoria o una sconfitta quando interagisce
    # con il CheckWinButton.
    CheckWin(Agent:agent):void=
        var CurrentScore:int = 0
        if:
            PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
            set CurrentScore = PlayerStats.Score
        then:
            Print("Il punteggio attuale è: {CurrentScore}") 
        if:
            CurrentScore > WinScore
        then:
            PlayerStatsManager.AddWin(Agent, 1)
            # Azzerare il punteggio del giocatore registrando la sua statistica di punteggio come 0.
            PlayerStatsManager.AddScore(Agent, -CurrentScore)
        else:
            PlayerStatsManager.AddLoss(Agent, 1)
            # Azzerare il punteggio del giocatore registrando la sua statistica di punteggio come 0.
            PlayerStatsManager.AddScore(Agent, -CurrentScore)

        UpdateStatsBillboard(Agent)

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page