Dauerhafte Spielerstatistiken

Viele Erlebnisse verwenden Spieler-Statistiken, um die Daten der Spieler über die Zeit zu verfolgen. Statistiken wie Highscore, gewonnene Spiele, Gesamtspielzeit und gesammelte Gegenstände geben den Spielern ein Gefühl des Fortschritts und sind eine gute Möglichkeit, Spieler zur Rückkehr zu deinem Erlebnis zu bewegen.

Verse-Persistenz ist ein mächtiges Werkzeug, das dir erlaubt, dauerhafte Daten zu deinen Verse-Scripts hinzuzufügen. Dauerhafte Daten werden pro Spieler und Insel gespeichert und bleiben zwischen den Gameplay-Sitzungen unverändert. Dauerhafte Daten erlauben die Verfolgung des Spielerfortschritts zwischen den Sitzungen und eröffnen eine Vielzahl einzigartiger und interessanter Spielerfahrungen, die es in UEFN bisher nicht gab.

Dieses Tutorial zeigt dir, wie du eine benutzerdefinierte Tabelle mit Spieler-Statistiken mit Verse erstellst und sie so einrichtest, dass sie dauerhaft über mehrere Spiele deines Erlebnisses hinweg beibehalten wird. Nachdem du dieses Tutorial abgeschlossen hast, schau dir Erzeuge deine eigene In-Game-Rangliste in Verse an, um zu erfahren, wie du mit dauerhaften in-game Ranglisten erstellen kannst!

Verwendete Sprachfunktionen in Verse

• Klasse: In diesem Beispiel wird eine Verse-Klasse erstellt, die eine einzelne Statistik verwaltet, sowie eine dauerhafte Klasse, die eine Gruppe von Statistiken für einen Einzelspieler verfolgt.

• Constructor: Ein Constructor ist eine spezielle Funktion, die eine Instanz der Klasse erstellt, mit der er assoziiert ist.

• Weak_map: Eine weak_map ist eine einfache Map, über die nicht iteriert werden kann. Dauerhafte Verse-Daten müssen in einer weak_map gespeichert werden.

Level einrichten

Dieses Beispiel verwendet die folgenden Props und Geräte.

• 2 x Schaltflächengeräte: Wenn der Spieler mit dem Gerät interagiert, fügen sie einen Punkt zu ihrem aktuellen Score hinzu. Du verwendest ein weiteres Schaltflächengerät, um das Ende eines Spiels zu simulieren, indem du die Gewinne oder Verluste des Spielers abhängig von seinem aktuellen Score addierst.

• 1 x Reklametafel-Gerät: Es ist oft wichtig, dem Spieler dauerhafte Daten anzuzeigen. Manchmal geschieht dies zu Testzwecken und ein anderes Mal, um das Engagement des Spielers zu steigern oder den Fortschritt zu zeigen. Die Anforderungen, wann und welche Daten angezeigt werden sollen, variieren von Erlebnis zu Erlebnis. In diesem Beispiel zeigst du die Statistikdaten für Score, Highscore, Siege und Niederlagen auf einem Reklametafel-Gerät.

Verfolgung von dauerhaften Spieler-Statistiken

Zuerst musst du definieren, welche Statistiken du pro Spieler verfolgen willst. Zum Beispiel möchtest du vielleicht den Gesamtpunktestand eines Spielers, seinen aktuellen Rang oder seine beste Zeit in einer Runde verfolgen. In diesem Beispiel wirst du die Verfolgung von Punkten, Siegen und Niederlagen in einer Tabelle mit den Werten für jeden Spieler vornehmen. Du machst das in einer neuen Klasse, player_stats_table, die deine wichtigste dauerhafte Klasse sein wird.

Folge diesen Schritten, um deine Klasse player_stats_table zu erstellen:

1. Erstelle mit Verse-Explorer eine neue Verse-Datei mit dem Namen player_stats_table.verse.

2. Erstelle in deiner neuen Verse-Datei eine neue Klasse mit dem Namen player_stats_table. Füge deiner Klasse sowohl die Modifikatoren <persistable> und <final> hinzu. Der Modifikator <persistable> ermöglicht dass die Daten in der Klasse dauerhaft gespeichert werden können und erfordert den Modifikator <final>, da dauerhaft gespeicherte Daten nicht überschrieben oder in Subklassen übernommen werden können.

   Verse

        using { /Fortnite.com/Devices }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/Diagnostics }
   
        # Tracks different persistable stats for each player.
        player_stats_table := class<final><persistable>:

   Copy full snippet(6 lines long)

3. Füge deiner player_stats_table drei int-Werte namens Score, Wins und Losses hinzu. Diese verfolgen die Punkte, Siege und Verluste während der Lebenszeit jedes Spielers. Füge außerdem ein int mit dem Namen Version hinzu, um die aktuelle Version deiner player_stats_table zu verfolgen.

   Verse

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

4. Um eine Instanz der player_stats_table class zu erstellen, verwendest du eine <constructor>-Funktion. Dieser Constructor ist erforderlich, da Verse-Persistenz keine Klassen zulässt, die variable Felder enthalten. Mit einem Constructor kannst du die Werte deiner dauerhaften Klasse aktualisieren, indem du eine Kopie einer vorhandenen dauerhaften Statistik erstellst, die variabel ist, die Kopie aktualisierst und dann die ursprüngliche Instanz der Klasse durch die geänderten Werte ersetzt. Füge deiner Datei eine neue Constructor-Funktion MakePlayerStatsTable() hinzu. Dieser Constructor nimmt eine ursprüngliche (vorherige) Instanz der Klasse player_stats_table und erstellt anhand der ursprünglichen Werte eine neue Instanz.

   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
            Score := OldTable.Score
            Wins := OldTable.Wins
            Losses := OldTable.Losses

   Copy full snippet(6 lines long)

5. Um alle deine player_stats_tables zu verfolgen, verwendest du eine dauerhafte weak_map von player zu player_stats_table Instanzen. Füge diese Weak Map zu deiner Datei hinzu.

   Verse

        # Maps players to a table of their player stats.
        var PlayerStatsMap:weak_map(player, player_stats_table) = map{}
   

   Copy full snippet(2 lines long)

6. Deine komplette Klasse player_stats_table sollte jetzt wie folgt aussehen:

   Verse

        using { /Fortnite.com/Devices }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/Diagnostics }
        # Tracks different persistable stats for each player.
        player_stats_table := class<final><persistable>:
   
            # The version of the current stats table.
            Version<public>:int = 0
   
            # The score of a player.
   
   Expand code Copy full snippet(27 lines long)

Verwalten von Spieler-Statistiken für alle Spieler

Mit deiner Klasse player_stats_table kannst du die Statistiken einzelner Spieler verfolgen, aber du hast noch keine Möglichkeit, diese zu verwalten. Du musst die Statistiktabellen für jeden Spieler aktualisieren, wenn er Punkte erhält, und je nach Gestaltung deines Erlebnisses kann es viele Spieler auf einmal geben.

Dazu verwendest du eine andere Klasse, welche die Statistiken für alle Spieler verwaltet und Änderungen der Statistiken aufzeichnet, wenn ein Spieler einen Sieg, eine Niederlage oder Punkte erzielt. Folge den folgenden Schritten, um deine Manager-Klasse einzurichten.

1. Erstelle mit Verse-Explorer eine neue Verse-Datei mit dem Namen player_stats_manager. Erstelle in dieser Datei eine neue Klasse player_stats_manager.

   Verse

        using { /Fortnite.com/Devices }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/Diagnostics }
   		
        # Manages and updates player_stat_tables for each player.
        player_stats_manager := class():
   

   Copy full snippet(6 lines long)

2. Dein player_stats_manager muss mehrere Dinge tun. Es muss eine player_stats_table für einen Spieler einrichten, die Score, Wins und Losses pro Spieler aktualisieren und die player_stats_table für einen Spieler zurückgeben. Du behandelst jede dieser Aufgaben in separaten Funktionen. Füge eine neue Funktion InitializePlayer() zu deiner Klassendefinition von player_stats_manager hinzu. Diese Funktion initialisiert die Statistiken für den angegebenen Spieler.

   Verse

        # Initialize stats for the given player.
        InitializePlayer(Player:player):void=
   

   Copy full snippet(2 lines long)

3. Prüfe in InitializePlayer(), ob der angegebene Spieler bereits in der PlayerStatsMap existiert. Wenn nicht, setze den Wert dieses Spielers in der Map auf einen neuen player_stats_table. Deine fertige Funktion InitializePlayer() sollte wie folgt aussehen:

   Verse

        # Initialize stats for the given player.
        InitializePlayer(Player:player):void=
            if:
                not PlayerStatsMap[Player]
                set PlayerStatsMap[Player] = player_stats_table{}
            else:
                Print("Unable to initialize player stats")
   

   Copy full snippet(7 lines long)

4. Füge eine neue Funktion InitializeAllPlayers() zu deiner Klassendefinition von player_stats_manager hinzu. Diese Funktion nimmt ein Array von Spielern entgegen und ruft InitializePlayer() für alle auf. Deine fertige Funktion InitializeAllPlayers() sollte wie folgt aussehen:

   Verse

        # Initialize stats for all current players.
        InitializeAllPlayers(Players:[]player):void =
            for (Player : Players):
                InitializePlayer(Player)
   

   Copy full snippet(4 lines long)

5. Um die Statistiken für einen bestimmten Spieler zurückzugeben, benötigst du eine Funktion, die die player_stats_table dieses Spielers zurückgibt. Füge eine neue Funktion GetPlayerStats() zur Klassendefinition von player_stats_manager hinzu, die einen Agenten entgegennimmt. Füge den Modifikator <decides><transacts> hinzu, damit diese Funktion fehlschlagen und zurückgesetzt werden kann, wenn die Statistik-Tabelle eines Spielers nicht vorhanden ist. Erstelle in GetPlayerStats() eine neue player_stats_table Variable PlayerStats.

   Verse

        # Return the player_stats_table for the provided Agent.
        GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
            var PlayerStats:player_stats_table = player_stats_table{}

   Copy full snippet(3 lines long)

6. In einem if-Ausdruck wandel den an diese Funktion übergebenen Agent in einen Player um und rufe dann die player_stats_table für diesen Spieler aus der PlayerStatsMap ab. Lege dann PlayerStats auf diese Tabelle fest, indem du MakePlayerStatsTable() aufrufst. Gib schließlich PlayerStats zurück. Deine fertige Funktion GetPlayerStats() sollte wie folgt aussehen:

   Verse

        # Return the player_stats_table for the provided Agent.
        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

   Copy full snippet(8 lines long)

7. Um die Statistiken „Score“, „Siege“ und „Niederlagen“ zu aktualisieren, erstelle für jede Statistik eine eigene Funktion. Füge eine neue Funktion mit dem Namen AddScore() zu deiner player_stats_manager Datei hinzu. Diese Funktion übernimmt den Agent, dem ein Score verliehen werden soll, und die int Anzahl der Punkte, die ihm verliehen werden sollen.

   Verse

        # Adds to the given Agent's score and updates both their stats table
        # in PlayerStatsManager and the billboard in the level.
        AddScore<public>(Agent:agent, NewScore:int):void=

   Copy full snippet(3 lines long)

8. Die Daten werden aktualisiert, indem zunächst überprüft wird, ob der Player gültige Daten in der dauerhaften weak_map hat, und diese Daten dann durch eine aktualisierte Kopie der Klasse ersetzt werden. Um dies für den Score zu handhaben, rufe den Score des Spielers aus der PlayerStatsTable ab, setze dann die Tabelle in der PlayerStatsMap auf das Ergebnis der Erstellung einer neuen player_stats_table mit MakePlayerStatsTable(), wobei der aktuelle Score plus der neue Score übergeben wird. Wenn du mit einer Klasse arbeitest, die mehrere Felder enthält, erlaubt dir der Konstruktor der Klasse, einfach ein einzelnes Feld zu aktualisieren, ohne jedes Mal alle Felder explizit zu kopieren, wenn du eine Aktualisierung vornehmen willst. Deine Funktion AddScore() sollte wie folgt aussehen:

   Verse

        # Adds to the given Agent's score and updates both their stats table
        # in PlayerStatsManager and the billboard in the level.
        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
   
   Expand code Copy full snippet(12 lines long)

9. Wiederhole diesen Prozess für Siege und Niederlagen und füge NewWins bzw. NewLosses den Siegen oder Niederlagen des Spielers hinzu, wenn MakePlayerStatsTable() aufgerufen wird.

   Verse

        # Adds to the given Agent's wins and updates both their stats table
        # in PlayerStatsManager and the billboard in the level.
        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
   
   Expand code Copy full snippet(25 lines long)

10. Deine fertige Datei player_stats_manager sollte wie folgt aussehen.

    Verse

         using { /Fortnite.com/Devices }
         using { /Verse.org/Simulation }
         using { /UnrealEngine.com/Temporary/Diagnostics }
    
         # Manages and updates player_stat_tables for each player.
         player_stats_manager := class():
    
             # Return the player_stats_table for the provided Agent.
             GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
                 var PlayerStats:player_stats_table = player_stats_table{}
    
    Expand code Copy full snippet(67 lines long)

Testen der Persistenz mit Geräten

Jetzt, wo du deine Persistenz-Klassen eingerichtet hast, ist es an der Zeit, sie in deinem Level zu testen.

1. Erstelle ein neues Verse-Gerät mit dem Namen player_stats_example. Die einzelnen Schritte findest du unter Erstelle dein eigenes Gerät mit Verse.

2. Füge oben in der Klassendefinition von player_stats_example die folgenden Felder hinzu:

   1. Ein bearbeitbarer button_device mit dem Namen ScorePointsButton. Diese Schaltfläche fügt der Punktzahl des Spielers etwas hinzu, wenn sie aktiviert wird.

      Verse

       # Adds to the activating player's score.
       @editable
       ScorePointsButton:button_device = button_device{}
      

      Copy full snippet(3 lines long)

   2. Ein bearbeitbarer billboard_device namens StatsBillboard. Hier werden der Score, der Highscore, die Siege und die Niederlagen des Spielers angezeigt.

      Verse

       # Displays the player's Score, High Score, Wins, and Losses
       @editable
       StatsBillboard:billboard_device = billboard_device{}
      

      Copy full snippet(3 lines long)

   3. Ein bearbeitbarer button_device mit dem Namen CheckWinButton. Diese Schaltfläche setzt den Score jedes Spielers zurück und verleiht ihm einen Sieg oder eine Niederlage, abhängig vom Score seines Spielers.

      Verse

       # Resets the player's score and award them a win or a loss
       # depending if their current score is greater than WinScore.
       @editable
       CheckWinButton:button_device = button_device{}
      

      Copy full snippet(4 lines long)

   4. Ein bearbeitbarer int mit dem Namen WinScore. Dies ist der Score, die Spieler erreichen müssen, um nach der Aktivierung des CheckWinButton als Sieger ausgezeichnet zu werden.

      Verse

       # The score players need to reach to be awarded a win after
       # the CheckWinButton is activated.
       @editable
       WinScore:int = 10
      

      Copy full snippet(4 lines long)

   5. Ein bearbeitbarer int mit dem Namen AwardScore. Dies ist die Punktzahl, die Spieler erhalten, wenn sie mit der Schaltfläche interagieren.

      Verse

       # The amount of score to award per button press.
       @editable
       AwardScore:int = 1
      

      Copy full snippet(3 lines long)

   6. Ein player_stats_manager namens PlayerStatsManager. Hiermit werden die Statistiken für alle Spieler verwaltet und aktualisiert.

      Verse

       # Manages and updates stats for each player.
       PlayerStatsManager:player_stats_manager = player_stats_manager{}
      

      Copy full snippet(2 lines long)

   7. Eine Nachricht mit dem Namen StatsMessage, die für einen Agent vier Ganzzahlen übernimmt: Score, MaxScore, Wins und Losses. Du verwendest diese Nachricht, um die Statistiken eines Spielers auf der Reklametafel anzuzeigen.

      Verse

       # Displays a player's stats on a billboard.
       StatsMessage<localizes>(Player:agent, Score:int, Wins:int, Losses:int):message = "{Player}, Stats:\n  Score: {Score}\n Wins: {Wins}\n  Losses: {Losses}"

      Copy full snippet(2 lines long)

3. Kompiliere deinen Code und ziehe dein mit Verse erstelltes Gerät auf deine Insel. Die einzelnen Schritte findest du unter Hinzufügen deines Verse-Geräts zu deinem Level.

4. Weise im Details-Panel deines Geräts dem Schaltflächengerät in deinem Level ScorePointsButton und dem Reklametafel-Gerät StatsBillboard zu.

   

5. Um die Statistiken eines bestimmten Spielers auf dem „StatsBillboard“ anzuzeigen, füge eine neue Funktion UpdateStatsBillboard() zu deiner Klassendefinition player_stats_example hinzu. Diese Funktion nimmt den Agent entgegen, dessen Statistiken angezeigt werden sollen.

   Verse

        # Retrieves the stats of the given player and displays their stats
        # on the StatsBillboard.
        UpdateStatsBillboard(Agent:agent):void=
   

   Copy full snippet(3 lines long)

6. In UpdateStatsBillboard() rufst du die aktuellen Statistiken des angegebenen Agents ab, indem du die Funktion GetPlayerStats[] des Statistik-Managers aufrufst. Rufe dann SetText() auf dem „StatsBillboard“ auf und übergib dabei eine neue StatsMessage(). Um diese StatsMessage() zu konstruieren, rufe den Score, Siege und Niederlagen des Agents ab, indem Sie auf die aktuellen Statistiken des Agents zugreifen. Deine fertige Funktion `UpdateStatsBillboard()` sollte wie folgt aussehen:

   Verse

        # Retrieves the stats of the given player and displays their stats
        # on the StatsBillboard.
        UpdateStatsBillboard(Agent:agent):void=
            if:
                # Get the current stats of the given agent.
                CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
            then:
                StatsBillboard.SetText(
                    StatsMessage(
                        Player := Agent,
   
   Expand code Copy full snippet(15 lines long)

7. Füge eine neue Funktion AddScore() zu deiner Klassendefinition von player_stats_example hinzu. Diese Funktion nimmt einen Agent entgegen und fügt dessen Score hinzu, wenn er mit dem ScorePointsButton interagiert.

   Verse

        # Adds to the given player's score and updates both their stats table
        # in PlayerStatsManager and the billboard in the level.
        AddScore(Agent:agent):void=
   

   Copy full snippet(3 lines long)

8. In AddScore() rufst du die aktuellen Statistiken des angegebenen Agents sowie seinen aktuellen Score ab. Rufe dann AddScore() aus PlayerStatsManager auf und übergib dem Agent und den AwardScore, um ihm einen neuen Score zu verleihen. Rufe schließlich UpdateStatsBillboard() auf und übergib den angegebenen Agent. Deine fertige Funktion AddScore() sollte wie folgt aussehen:

   Verse

        # Adds to the given player's score and updates both their stats table
        # in PlayerStatsManager and the billboard in the level.
        AddScore(Agent:agent):void=
            if:
                CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
                CurrentScore := CurrentPlayerStats.Score
            then:
                Print("Current Score is: {CurrentScore}")
                PlayerStatsManager.AddScore(Agent, AwardScore)
                UpdateStatsBillboard(Agent)
   

   Copy full snippet(10 lines long)

9. Um einem Spieler einen Sieg oder eine Niederlage zuzuweisen, wenn die Schaltfläche „CheckWin“ betätigt wird, füge der Klassendefinition „player_stats_manager“ eine neue Funktion CheckWin() hinzu.

   Verse

        # Awards a player a win or a loss when they interact
        # with the CheckWinButton.
        CheckWin(Agent:agent):void=
   

   Copy full snippet(3 lines long)

10. Definiere zuerst eine Variable CurrentScore, um den aktuellen Score des Agents zu verfolgen. Rufe dann wie bei der Funktion AddScore() seinen aktuellen Score aus der Spieler-Statistiken-Tabelle ab.

    Verse

         # Awards a player a win or a loss when they interact
         # with the CheckWinButton.
         CheckWin(Agent:agent):void=
             var CurrentScore:int = 0
             if:
                 PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
                 set CurrentScore = PlayerStats.Score
    

    Copy full snippet(7 lines long)

11. Wenn der aktuelle Score des Agents größer ist als der WinScore, musst du einen Sieg im PlayerStatsManager eintragen. Andernfalls verbuchen Sie einen Verlust. Setze schließlich den Score des Agent zurück, indem du AddScore() mit einem negativen CurrentScore aufrufst und dann die Statistiken des Agent auf der Statistik-Reklametafel anzeigst. Deine fertige Funktion CheckWin() sollte wie folgt aussehen:

    Verse

         # Awards a player a win or a loss when they interact
         # with the CheckWinButton.
         CheckWin(Agent:agent):void=
             var CurrentScore:int = 0
             if:
                 PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
                 set CurrentScore = PlayerStats.Score
             then:
                 Print("Current Score is: {CurrentScore}") 
             if:
    
    Expand code Copy full snippet(21 lines long)

12. In OnBegin() abonniere ScorePointsButton.InteractedWithEvent für AddScore(), und CheckWinButton.InteractedWithEvent für CheckWin(). Rufe dann mit GetPlayers() das Array aller Spieler im Spiel ab und infialisiere sie alle mit der Funktion InitializeAllPlayers() des Statistik-Managers.

    Verse

         # Runs when the device is started in a running game
         OnBegin<override>()<suspends>:void=
             # Register Button Events
             ScorePointsButton.InteractedWithEvent.Subscribe(AddScore)
             CheckWinButton.InteractedWithEvent.Subscribe(CheckWin)
             Players := GetPlayspace().GetPlayers()
    
             # Initialize player stats
             PlayerStatsManager.InitializeAllPlayers(Players)

    Copy full snippet(9 lines long)

13. Speicher deinen Code und kompiliere ihn.

Testen der Persistenz in deinem Level

Du kannst deine dauerhaften Daten in einer Bearbeitungssitzung testen, aber diese Daten werden zurückgesetzt, wenn du die Sitzung beendest und neu startest. Damit deine Daten über mehrere Sitzungen hinweg erhalten bleiben, musst du eine Spieltest-Sitzung starten und bestimmte Einstellungen in deinen Insel-Einstellungen ändern. Informationen zum Einrichten Deiner Insel zum Testen dauerhafter Daten sowohl in Bearbeitungs- als auch in Spieltestsitzungen findest Du unter Testen mit dauerhaften Daten auf der Seite zu dauerhaften Daten.

Nachdem du deine Sitzung eingerichtet hast, sollte beim Spieltest deines Levels die Interaktion mit der ScorePoints-Schaltfläche den Score des Spielers erhöhen und diese Aktualisierung auf der Reklametafel anzeigen. Die Interaktion mit der CheckWin-Schaltfläche sollte die Siege oder Niederlagen des Spielers erhöhen, je nachdem, wie viele Punkte der Spieler hat. Wenn du in die Lobby zurückkehrst und deine Insel wieder betrittst, sollte die Statistik des Spielers dauerhaft bestehen bleiben und die Gesamtzahl der Siege/Niederlagen sowie der Highscore auf der Reklametafel angezeigt werden, sobald es aktualisiert wird.

Du bist am Zug

Nachdem du diese Anleitung abgeschlossen hast, hast du gelernt, wie du Verse verwendest, um dauerhafte Daten zu erstellen, die für jeden Spieler verfolgt werden und die über Gameplay-Sitzungen hinweg bestehen bleiben. Schau dir jetzt an, wie du die Persistenz nutzen kannst, um dein eigenes Erlebnis zu verbessern.

• Kannst du ein Datei-System zum Speichern erstellen, das sich den letzten Checkpoint merkt, den ein Spieler erreicht hat?

• Wie wäre es mit einem System, das sich merkt, mit welchen Charakteren du gesprochen hast und wie deine aktuelle Beziehung zu ihnen ist?

• Wie wäre es mit einem System, das den Spielern nur eine begrenzte Zeit über mehrere Wettkampfabschnitten hinweg zur Verfügung stellt, um Ziele zu erreichen, und ihren Fortschritt zurücksetzt, wenn sie scheitern?

Vollständiger Code

Dies ist der vollständige Code, der in diesem Tutorial-Teil erstellt wurde:

player_stats_table.verse

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

# Tracks different persistable stats for each player.
player_stats_table := class<final><persistable>:
    # The version of the current stats table.
    Version<public>:int = 0

    # The score of a player.

player_stats_manager.verse

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

# Manages and updates player_stat_tables for each player.
player_stats_manager := class():

    # Return the player_stats_table for the provided Agent.
    GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
        var PlayerStats:player_stats_table = player_stats_table{}

player_stats_example.verse

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

# A Verse-authored creative device that can be placed in a level
player_stats_example := class(creative_device):

    # Adds to the activating player's score.
    @editable