Persystencja danych statystyk graczy

Wiele gier korzysta ze statystyk graczy, aby śledzić dane dotyczące ich doświadczeń w miarę upływu czasu. Takie statystyki jak najwyższy wynik, całkowita liczba zwycięstw, całkowity czas gry i zebrane przedmioty dają graczom poczucie dokonania postępu w grze i są świetnym sposobem na zachęcenie ich do ponownego zagrania.

Verse Persistence (Persystencja Verse) to potężne narzędzie umożliwiające dodawanie trwałych danych do skryptów Verse. Dane możliwe do utrwalenia są zapisywane osobno dla każdego gracza i każdej wyspy i pozostają takie same pomiędzy sesjami gry. Dane możliwe do utrwalenia pozwolą ci śledzić postępy gracza pomiędzy sesjami gry i otworzą przed tobą szereg wyjątkowych i interesujących możliwości rozgrywki, które dotąd nie były dostępne w UEFN.

Z tego samouczka dowiesz się, jak śledzić niestandardowe statystyki graczy w Verse i jak je skonfigurować w taki sposób, aby były możliwe do utrwalenia podczas wielu rund rozgrywki w twojej przygodzie. Po ukończeniu tego samouczka przeczytaj artykuł Tworzenie własnej tablicy rankingowej gry w Verse, aby dowiedzieć się, jak wykorzystać persystencję do tworzenia tablic rankingowych w grze!

Używane funkcje języka Verse

• Klasa: W tym przykładzie tworzona jest klasa Verse, która zarządza pojedynczą statystyką, a także klasa persystentna, która śledzi grupę statystyk pojedynczego gracza.

• Konstruktor: Konstruktor to specjalna funkcja, która tworzy instancję klasy, z którą jest związana.

• Weak_map: weak_map to prosta mapa, w przypadku której nie można wykonywać iteracji. Możliwe do persystencji dane Verse muszą być przechowywane w weak_map.

Ustawianie poziomu

W tym przykładzie wykorzystano następujące rekwizyty i urządzenia:

• 2 x urządzenie przycisku: Kiedy gracz wejdzie w interakcję z urządzeniem, doda punkt do swojego aktualnego wyniku. Za pomocą kolejnego urządzenia z przyciskami będziesz symulować zakończenie gry, dodając zwycięstwa lub porażki gracza w zależności od jego aktualnego wyniku.

• 1 x urządzenie billboardu: Często istotne jest, aby dane możliwe do persystencji były wyświetlane graczowi. Czasami wykonuje się to w celach testowych, a innym razem, aby zwiększyć zaangażowanie graczy lub pokazać im poczynione postępy. Chociaż wymagania dotyczące tego, kiedy i jakie dane wyświetlać, będą się różnić w zależności od przygody (gry), w tym przykładzie wyświetlone będą dane statystyczne dotyczące wyniku, najwyższego wyniku, liczby wygranych i przegranych na urządzeniu billboardu.

Śledzenie persystentnych statystyk gracza

Po pierwsze, istotne jest, aby określić, jakie statystyki chcesz śledzić dla każdego gracza. Na przykład, możesz chcieć śledzić wynik wszech czasów gracza, jego aktualną rangę lub najlepszy czas okrążenia. W tym przykładzie będziesz śledzić wyniki, zwycięstwa i porażki w tabeli wartości statystyk dla każdego gracza. Zrobisz to za pomocą nowej klasy player_stats_table, która będzie twoją główną klasą możliwą do utrwalenia.

Wykonaj poniższe kroki, aby utworzyć swoją klasę player_stats_table.

1. Przy użyciu Eksploratora Verse utwórz nowy plik Verse o nazwie player_stats_table.verse.

2. W swoim nowym pliku Verse utwórz nową klasę o nazwie player_stats_table. Dodaj modyfikatory <persistable> i <final> do swojej klasy. Modyfikator <persistable> pozwala na persystencję danych w klasie i wymaga modyfikatora <final>, ponieważ nie można zastąpić ani „podklasować” danych możliwych do utrwalenia.

   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. Do tabeli player_stats_table dodaj trzy wartości int o nazwach Score, Wins i Losses. Śledzą one odpowiednio: najlepszy wynik życiowy, liczbę zwycięstw i liczbę porażek każdego gracza. Ponadto możesz dodać int o nazwie Version, aby śledzić aktualną wersję swojej player_stats_table.

   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. Aby utworzyć instancję klasy player_stats_table, należy użyć funkcji <constructor>. Ten konstruktor jest wymagany, ponieważ zasady persystencji Verse nie pozwalają na persystencję klas zawierających pola zmiennych. Użycie konstruktora umożliwi aktualizację persystentnych wartości klasy poprzez utworzenie kopii istniejącej persystentnej statystyki, która jest zmienną, zaktualizowanie kopii, a następnie zastąpienie oryginalnej instancji klasy zmienionymi wartościami. Dodaj nową funkcję konstruktora MakePlayerStatsTable() do pliku. Ten konstruktor przyjmie początkową (poprzednią) instancję klasy player_stats_table i utworzy nową na podstawie podanych wartości oryginalnych.

   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. Aby śledzić wszystkie swoje player_stats_tables, użyj trwałej weak_map instancji player do player_stats_table. Dodaj tę słabą mapę do swojego pliku.

   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. Ukończona klasa player_stats_table powinna wyglądać następująco:

   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)

Zarządzanie statystykami gracza dla wszystkich graczy

Twoja klasa player_stats_table umożliwia śledzenie statystyk pojedynczego gracza, ale nie masz jeszcze możliwości, aby nimi zarządzać. Musisz zaktualizować tabele statystyk dla każdego gracza za każdym razem, gdy zdobędzie on jakiś punkt. W zależności od konfiguracji twojej gry może to być wielu graczy na raz.

Aby to rozwiązać, użyjesz innej klasy do zarządzania statystykami wszystkich graczy i będziesz rejestrować zmiany statystyk za każdym razem, gdy gracz odniesie zwycięstwo, dozna porażki lub zdobędzie punkty. Wykonaj poniższe kroki, aby skonfigurować klasę menedżera.

1. Przy użyciu Eksploratora Verse utwórz nowy plik Verse o nazwie player_stats_manager. W tym pliku utwórz nową klasę 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. Twój player_stats_manager musi wykonywać kilka rzeczy. Musi utworzyć tabelę player_stats_table dla gracza, aktualizować Score, Wins i Losses dla każdego gracza i zwrócić tabelę player_stats_table dla gracza. Każda z powyższych będzie obsługiwana w osobnych funkcjach. Dodaj nową funkcję InitializePlayer() do definicji klasy player_stats_manager. Funkcja ta zainicjuje statystyki dla danego gracza.

   Verse

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

   Copy full snippet(2 lines long)

3. W InitializePlayer() sprawdź, czy dany gracz już istnieje w PlayerStatsMap. Jeśli nie, ustaw wartość tego gracza na mapie na nową player_stats_table. Gotowa funkcja InitializePlayer() powinna wyglądać następująco:

   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. Dodaj nową funkcję InitializeAllPlayers() do definicji klasy player_stats_manager. Funkcja ta przyjmuje tablicę graczy i wywołuje InitializePlayer() dla każdego z nich. Gotowa funkcja InitializeAllPlayers() powinna wyglądać następująco:

   Verse

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

   Copy full snippet(4 lines long)

5. Aby zwrócić statystyki konkretnego gracza, potrzebna jest funkcja, która zwraca player_stats_table tego gracza. Dodaj nową funkcję GetPlayerStats() do definicji klasy player_stats_manager, która przyjmuje agenta. Dodaj modyfikator <decides><transacts>, aby umożliwić tej funkcji niepowodzenie i cofnięcie w przypadku, gdy tabela statystyk gracza nie istnieje. W GetPlayerStats() utwórz nowe PlayerStats zmiennej player_stats_table.

   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. W wyrażeniu if rzutuj agenta przekazanego do tej funkcji do gracza, a następnie pobierz player_stats_table dla tego gracza z PlayerStatsMap. Następnie ustaw PlayerStats na tę tabelę, wywołując funkcję MakePlayerStatsTable(). Na końcu zwróć PlayerStats. Gotowa funkcja GetPlayerStats() powinna wyglądać następująco:

   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. Aby zaktualizować statystyki wyników, zwycięstw i porażek, należy utworzyć funkcje dla każdej z nich. Dodaj nową funkcję AddScore() do pliku player_stats_manager. Funkcja ta pobiera agenta w celu przyznania wyniku, po czym przyznaje mu liczbę punktów wyrażoną wartością int.

   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. Dane są aktualizowane poprzez weryfikację, czy gracz ma prawidłowe dane w możliwym do utrwalenia obiekcie weak_map, a następnie poprzez zastąpienie tych danych zaktualizowaną kopią klasy. Aby obsłużyć to dla wyniku, pobierz wynik gracza z PlayerStatsTable, a następnie ustaw tabelę w PlayerStatsMap na wynik skonstruowania nowej player_stats_table za pomocą MakePlayerStatsTable(), przekazując aktualny wynik wraz z nowym wynikiem. Kiedy pracujesz z klasą, która zawiera kilka pól, konstruktor klasy pozwala na łatwą aktualizację pojedynczego pola bez jawnego kopiowania wszystkich pól za każdym razem, gdy chcesz dokonać aktualizacji. Otrzymana funkcja AddScore() powinna wyglądać następująco:

   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. Powtórz ten proces dla wygranych i przegranych, dodając NewWins i NewLosses do wygranych lub przegranych gracza odpowiednio podczas wywoływania MakePlayerStatsTable().

   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. Gotowy plik player_stats_manager powinien wyglądać jak poniżej.

    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)

Testowanie persystencji z urządzeniami

Po skonfigurowaniu klas możliwych do persystencji, czas przetestować je na swoim poziomie.

1. Utwórz nowe urządzenie Verse o nazwie player_stats_example. Aby uzyskać informacje na ten temat, patrz: Tworzenie własnego urządzenia przy użyciu Verse.

2. Na początku definicji klasy player_stats_example dodaj następujące pola:

   1. Edytowalny button_device o nazwie ScorePointsButton. Ten przycisk dodaje do wyniku gracza za każdym razem, gdy zostanie aktywowany.

      Verse

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

      Copy full snippet(3 lines long)

   2. Edytowalne billboard_device o nazwie StatsBillboard. Wyświetli się wynik gracza, jego najlepszy wynik, liczba zwycięstw i porażek.

      Verse

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

      Copy full snippet(3 lines long)

   3. Edytowalne button_device o nazwie CheckWinButton. Ten przycisk resetuje wynik każdego gracza i przyznaje mu zwycięstwo lub porażkę w zależności od uzyskanego wyniku.

      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. Edytowalna wartość int o nazwie WinScore. Jest to wynik, jaki gracze muszą osiągnąć, aby uzyskać zwycięstwo po aktywacji przycisku CheckWinButton.

      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. Edytowalna wartość int o nazwie AwardScore. Jest to wynik przyznawany graczom za interakcję z przyciskiem.

      Verse

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

      Copy full snippet(3 lines long)

   6. player_stats_manager o nazwie PlayerStatsManager. Ta funkcja umożliwia zarządzanie statystykami wszystkich graczy i ich aktualizowanie.

      Verse

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

      Copy full snippet(2 lines long)

   7. Wiadomość o nazwie StatsMessage przyjmująca od agenta cztery liczby całkowite: Score, MaxScore, Wins i Losses. Za pomocą tego komunikatu możesz wyświetlić statystyki gracza na billboardzie.

      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. Skompiluj swój kod, a następnie przeciągnij urządzenie utworzone w Verse na wyspę. Aby uzyskać informacje na ten temat, patrz: Dodawanie urządzenia Verse do poziomu.

4. W panelu szczegółów swojego urządzenia przypisz urządzenie przycisku na swoim poziomie do ScorePointsButton, a urządzenie billboardu do StatsBillboard.

   

5. Aby wyświetlić statystyki danego gracza na StatsBillboard, dodaj nową funkcję UpdateStatsBillboard() do definicji klasy player_stats_example. Funkcja ta pobiera agenta, którego statystyki będą wyświetlane.

   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. W UpdateStatsBillboard() pobierz aktualne statystyki danego agenta, wywołując funkcję GetPlayerStats[] menedżera statystyk. Następnie wywołaj SetText() na StatsBillboard, przekazując nowy StatsMessage(). Aby utworzyć ten komunikat StatsMessage(), należy uzyskać wynik, zwycięstwa i porażki agenta, uzyskując do nich dostęp z poziomu bieżących statystyk agenta. Gotowa funkcja UpdateStatsBillboard() powinna wyglądać następująco:

   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. Dodaj nową funkcję AddScore() do definicji klasy player_stats_example. Ta funkcja przyjmuje agenta i dodaje do jego wyniku, gdy tylko aktywowany zostanie przycisk ScorePointsButton.

   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. W AddScore() pobierz aktualne statystyki danego agenta, a także jego aktualny wynik. Następnie wywołaj AddScore() z PlayerStatsManager, przekazując agenta oraz AwardScore, aby przyznać mu nowy wynik. Na koniec wywołaj UpdateStatsBillboard(), przekazując podanego agenta. Otrzymana funkcja AddScore() powinna wyglądać następująco:

   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. Aby przyznawać graczowi zwycięstwo lub porażkę po aktywowaniu przycisku CheckWin, należy dodać nową funkcję CheckWin() do definicji klasy player_stats_manager.

   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. W pierwszej kolejności zdefiniuj zmienną CurrentScore, aby śledziła aktualny wynik agenta. Następnie, podobnie jak w przypadku funkcji AddScore(), pobierz aktualny wynik z tabeli statystyk gracza.

    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. Jeśli aktualny wynik agenta jest wyższy niż WinScore, konieczne jest zapisanie zwycięstwa w PlayerStatsManager. W przeciwnym wypadku zapisywana jest porażka. Na koniec zresetuj wynik agenta, wywołując AddScore() z ujemnym CurrentScore, a następnie wyświetl statystyki agenta na billboardzie statystyk. Otrzymana funkcja CheckWin() powinna wyglądać następująco:

    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. W OnBegin() zasubskrybuj ScorePointsButton.InteractedWithEvent do AddScore() i CheckWinButton.InteractedWithEvent do CheckWin(). Następnie pobierz tablice wszystkich graczy w grze, wywołując GetPlayers() i zainicjuj je wszystkie za pomocą funkcji InitializeAllPlayers() menedżera statystyk.

    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. Zapisz kod i skompiluj go.

Testowanie persystencji na twoim poziomie

Możesz przetestować trwałe dane w sesji edycji, ale dane te zostaną zresetowane po wyjściu i ponownym uruchomieniu sesji. Aby dane były zachowywane w różnych sesjach, musisz uruchomić sesję testową i zmienić określone ustawienia w Ustawieniach wyspy. Informacje na temat konfigurowania wyspy w celu testowania danych możliwych do utrwalenia zarówno w sesjach edycji, jak i testów gry można znaleźć w artykule Testowanie z persystencją danych na stronie poświęconej danym możliwym do utrwalenia.

Po skonfigurowaniu sesji, gdy testujesz swój poziom, aktywowanie przycisku ScorePoints powinno podwyższyć wynik gracza i wyświetlić zaktualizowany wynik na billboardzie. Aktywowanie przycisku CheckWin powinno zwiększyć liczbę zwycięstw lub porażek gracza, w zależności od jego wyniku. Po powrocie do lobby i ponownym wejściu na wyspę statystyki gracza powinny zostać zachowane, a jego łączna liczba zwycięstw/porażek i najwyższy wynik powinny być wyświetlane na billboardzie po każdej aktualizacji.

Praca własna

Po ukończeniu tego przewodnika dowiedziałeś się, jak używać Verse do tworzenia danych możliwych do utrwalenia śledzonych dla każdego gracza, które będą zachowywane podczas kolejnych sesji gry. Teraz sprawdź, jak możesz dostosować persystencję, aby podnieść poziom swojego doświadczenia

• Czy możesz stworzyć system plików zapisu, w którym będzie zapisywany ostatni punkt kontrolny, do którego dotarł gracz?

• Co powiesz na system, który będzie zapamiętywać, z którymi postaciami gracz rozmawiał i jakie są jego obecne stosunki z nimi?

• Co powiesz na system, który daje graczom tylko ograniczoną ilość czasu w trakcie sesji gry na osiągnięcie celów i resetuje postępy, jeśli nie uda im się tego wykonać?

Gotowy kod

Oto kompletny kod utworzony w tej sekcji samouczka.

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