1. Epic GamesDeveloper
  3. Persystencja danych statystyk graczy

Persystencja danych statystyk graczy

Dowiedz się, jak stworzyć persystentne statystyki gracza, które są zapisywane pomiędzy sesjami gry.

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.

Konfiguracja poziomu

Śledzenie trwałych 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. Utwórz nowy plik Verse o nazwie player_stats_table.verse przy użyciu Eksplorator 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.

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

 # Śledzi różne persystentne statystyki dla każdego gracza.
 player_stats_table := class<final><persistable>:

  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.

     # Śledzi różne persystentne statystyki dla każdego gracza.
 player_stats_table := class<final><persistable>:
     # Wersja tabeli aktualnych statystyk.
     Version<public>:int = 0
        
     # Wynik gracza.
     Score<public>:int = 0

     # Liczba wygranych gracza.
     Wins<public>:int = 0

     # Liczba porażek gracza.
     Losses<public>:int = 0

  4. Aby utworzyć instancję klasy player_stats_table class, 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 początkowych podanych wartości.

     # Tworzy nową player_stats_table z takimi samymi wartościami, jak poprzednia 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. 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.

     # Mapuje graczy do tabeli odpowiednich statystyk gracza.
 var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

  6. Ukończona klasa player_stats_table powinna wyglądać następująco:

     using { /Fortnite.com/Devices }
 using { /Verse.org/Simulation }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 # Śledzi różne persystentne statystyki dla każdego gracza.
 player_stats_table := class<final><persistable>:

     # Wersja tabeli aktualnych statystyk.
     Version<public>:int = 0

     # Wynik gracza.
     Score<public>:int = 0

     # Liczba wygranych gracza.
     Wins<public>:int = 0

     # Liczba porażek gracza.
     Losses<public>:int = 0

 # Tworzy nową player_stats_table z takimi samymi wartościami, jak poprzednia 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

 # Mapuje graczy do tabeli odpowiednich statystyk gracza.
 var PlayerStatsMap:weak_map(player, player_stats_table) = map{}

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. Utwórz nowe urządzenie Verse o nazwie player_stats_manager przy użyciu Eksploratora Verse. W tym pliku utwórz nową klasę player_stats_manager.

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

 # Zarządza i aktualizuje player_stat_tables dla każdego gracza.
 player_stats_manager := class():

  2. Twój player_stats_manager musi wykonywać kilka rzeczy. Musi utworzyć tabelę player_stats_table dla gracza, aktualizować Score, Zwycięstwa i Wins 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.

     # Zainicjuj statystyki dla danego gracza.
 InitializePlayer(Player:player):void=

  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:

     # Zainicjuj statystyki dla danego gracza.
 InitializePlayer(Player:player):void=
     if:
         not PlayerStatsMap[Player]
         set PlayerStatsMap[Player] = player_stats_table{}
     else:
         Print("Nie można zainicjować statystyk gracza")

  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:

     # Zainicjuj statystyki dla wszystkich bieżących graczy.
 InitializeAllPlayers(Players:[]player):void =
     for (Player : Players):
         InitializePlayer(Player)

  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 nową zmienną player_stats_table PlayerStats.

     # Zwrot player_stats_table dla podanego agenta.
 GetPlayerStats(Agent:agent)<decides><transacts>:player_stats_table=
     var PlayerStats:player_stats_table = player_stats_table{}

  6. W wyrażeniu if rzutuj Agent przekazanego do tej funkcji do Player, 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:

     # Zwrot player_stats_table dla podanego agenta.
 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. Aby zaktualizować statystyki wyników, zwycięstw i porażek, należy utworzyć funkcje dla każdej z nich. Dodaj nową funkcję o nazwie 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.

     # Dodaje do wyniku danego agenta i aktualizuje tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 AddScore<public>(Agent:agent, NewScore:int):void=

  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. Funkcja AddScore() powinna wyglądać następująco:

     # Dodaje do wyniku danego agenta i aktualizuje tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 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("Nie można zarejestrować wyniku gracza")

  9. Powtórz ten proces dla wygranych i przegranych, dodając NewWins i NewLossesdo wygranych lub przegranych gracza odpowiednio podczas wywoływania MakePlayerStatsTable().

     # Dodaje do zwycięstw danego agenta i aktualizuje tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 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("Nie można zarejestrować wygranych gracza")
    
 # Dodaje do strat danego agenta i aktualizuje tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 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("Nie można zarejestrować przegranej gracza")

  10. Gotowy plik player_stats_manager powinien wyglądać jak poniżej.

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

 # Zarządza i aktualizuje player_stat_tables dla każdego gracza.
 player_stats_manager := class():

     # Zwrot player_stats_table dla podanego agenta.
     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

     # Zainicjuj statystyki dla wszystkich bieżących graczy.
     InitializeAllPlayers(Players:[]player):void =
         for (Player : Players):
             InitializePlayer(Player)

     # Zainicjuj statystyki dla danego gracza.
     InitializePlayer(Player:player):void=
         if:
             not PlayerStatsMap[Player]
             set PlayerStatsMap[Player] = player_stats_table{}
         else:
             Print("Nie można zainicjować statystyk gracza")

     # Dodaje do wyniku danego agenta i aktualizuje tabele jego statystyk
     # w PlayerStatsManager i billboardzie w poziomie.
     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("Nie można zarejestrować wyniku gracza")

     # Dodaje do zwycięstw danego agenta i aktualizuje tabele jego statystyk
     # w PlayerStatsManager i billboardzie w poziomie.
     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("Nie można zarejestrować wygranych gracza")
        
     # Dodaje do strat danego agenta i aktualizuje tabele jego statystyk
     # w PlayerStatsManager i billboardzie w poziomie.
     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("Nie można zarejestrować przegranej gracza")

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. Procedurę zawiera sekcja 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.

       # Dodaje do wyniku gracza, który to aktywował.
 @editable
 ScorePointsButton:button_device = button_device{}

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

       # Wyświetla wynik gracza, najwyższy wynik, liczbę zwycięstw i porażek
 @editable
 StatsBillboard:billboard_device = billboard_device{}

    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.

       # Resetuje wynik gracza i przyznaje mu zwycięstwo lub porażkę
 # zależy to od tego, czy aktualny wynik jest wyższy niż WinScore.
 @editable
 CheckWinButton:button_device = button_device{}

    4. Edytowalna wartość int o nazwie WinScore. Jest to wynik, jaki gracze muszą osiągnąć, aby uzyskać zwycięstwo po aktywacji przycisku CheckWinButton.

       # Wynik, jaki gracze muszą osiągnąć, aby uzyskać zwycięstwo po 
 # aktywacji przycisku CheckWinButton.
 @editable
 WinScore:int = 10

    5. Edytowalna wartość int o nazwie AwardScore. Jest to wynik przyznawany graczom za interakcję z przyciskiem.

       # Ilość punktów przyznawanych za naciśnięcie przycisku.
 @editable
 AwardScore:int = 1

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

       # Zarządza i aktualizuje statystki dla każdego gracza.
 PlayerStatsManager:player_stats_manager = player_stats_manager{}

    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.

       # Wyświetla statystyki gracza na billboardzie.
 StatsMessage<localizes>(Player:agent, Score:int, Wins:int, Losses:int):message = "{Player}, Stats:\n  Score: {Score}\n Wins: {Wins}\n  Losses: {Losses}"

  3. Skompiluj swój kod, a następnie przeciągnij urządzenie utworzone w Verse na swoją wyspę. Patrz: Dodawanie urządzenia Verse do Twojego poziomu, aby zobaczyć dalsze kroki.

  4. Na panelu Szczegóły swojego urządzenia przypisz urządzenie Przycisku na swoim poziomie do ScorePointsButton, a urządzenie Billboardu do StatsBillboard.

    Przypisanie urządzenia

  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.

     # Pobiera statystyki danego gracza i wyświetla jego statystyki
 # na StatsBillboard.
 UpdateStatsBillboard(Agent:agent):void=

  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 agenta, zwycięstwa i porażki, uzyskując do nich dostęp z poziomu bieżących statystyk agenta. Gotowa funkcja UpdateStatsBillboard() powinna wyglądać następująco:

     # Pobiera statystyki danego gracza i wyświetla jego statystyki
 # na StatsBillboard.
 UpdateStatsBillboard(Agent:agent):void=
     if:
         # Pobierz aktualne statystyki danego agenta.
         CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
     then:
         StatsBillboard.SetText(
             StatsMessage(
                 Player := Agent,
                 Score:=CurrentPlayerStats.Score.CurrentValue,
                 Wins:=CurrentPlayerStats.Wins.CurrentValue,
                 Losses:=CurrentPlayerStats.Losses.CurrentValue
             )
         )

  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.

     # Dodaje do wyniku danego gracza i aktualizuje jego tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 AddScore(Agent:agent):void=

  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. Gotowa funkcja AddScore() powinna wyglądać następująco:

     # Dodaje do wyniku danego gracza i aktualizuje jego tabele jego statystyk
 # w PlayerStatsManager i billboardzie w poziomie.
 AddScore(Agent:agent):void=
     if:
         CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         CurrentScore := CurrentPlayerStats.Score
     then:
         Print("Aktualny wynik to: {CurrentScore}")
         PlayerStatsManager.AddScore(Agent, AwardScore)
         UpdateStatsBillboard(Agent)

  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.

     # Przyznaje graczowi zwycięstwo lub porażkę, gdy wchodzi w interakcję
 # z CheckWinButton.
 CheckWin(Agent:agent):void=

  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.

     # Przyznaje graczowi zwycięstwo lub porażkę, gdy wchodzi w interakcję
 # z CheckWinButton.
 CheckWin(Agent:agent):void=
     var CurrentScore:int = 0
     if:
         PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         set CurrentScore = PlayerStats.Score

  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. Gotowa funkcja CheckWin() powinna wyglądać następująco:

     # Przyznaje graczowi zwycięstwo lub porażkę, gdy wchodzi w interakcję
 # z CheckWinButton.
 CheckWin(Agent:agent):void=
     var CurrentScore:int = 0
     if:
         PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
         set CurrentScore = PlayerStats.Score
     then:
         Print("Aktualny wynik to: {CurrentScore}") 
     if:
         CurrentScore > WinScore
     then:
         PlayerStatsManager.AddWin(Agent, 1)
         # Reset wynik gracza, zapisując jego statystykę wyniku jako 0.
         PlayerStatsManager.AddScore(Agent, -CurrentScore)
     else:
         PlayerStatsManager.AddLoss(Agent, 1)
         # Reset wynik gracza, zapisując jego statystykę wyniku jako 0.
         PlayerStatsManager.AddScore(Agent, -CurrentScore)
        
     UpdateStatsBillboard(Agent)

  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.

     # Działa po uruchomieniu urządzenia w aktywnej grze
 OnBegin<override>()<suspends>:void=
     # Rejestracja zdarzenia przycisku
     ScorePointsButton.InteractedWithEvent.Subscribe(AddScore)
     CheckWinButton.InteractedWithEvent.Subscribe(CheckWin)
     Players := GetPlayspace().GetPlayers()

     # Zainicjuj statystyki gracza
     PlayerStatsManager.InitializeAllPlayers(Players)

  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 między sesjami były utrwalone, musisz uruchomić sesję testu gry i zmienić pewne ustawienia w swoich 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.

Statystyki persystentne

We własnym zakresie

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 rozmawiałeś i jakie są twoje 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ć?

Kompletny 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 }

# Śledzi różne persystentne statystyki dla każdego gracza.
player_stats_table := class<final><persistable>:
    # Wersja tabeli aktualnych statystyk.
    Version<public>:int = 0
    
    # Wynik gracza.
    Score<public>:int = 0

    # Liczba wygranych gracza.
    Wins<public>:int = 0

    # Liczba porażek gracza.
    Losses<public>:int = 0

# Tworzy nową player_stats_table z takimi samymi wartościami, jak poprzednia 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
    
# Mapuje graczy do tabeli odpowiednich statystyk gracza.
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 }

# Zarządza i aktualizuje player_stat_tables dla każdego gracza.
player_stats_manager := class():
    
    # Zwrot player_stats_table dla podanego agenta.
    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

    # Zainicjuj statystyki dla wszystkich bieżących graczy.
    InitializeAllPlayers(Players:[]player):void =
        for (Player : Players):
            InitializePlayer(Player)
        
    # Zainicjuj statystyki dla danego gracza.
    InitializePlayer(Player:player):void=
        if:
            not PlayerStatsMap[Player]
            set PlayerStatsMap[Player] = player_stats_table{}
        else:
            Print("Nie można zainicjować statystyk gracza")

    # Dodaje do wyniku danego agenta i aktualizuje tabele jego statystyk
    # w PlayerStatsManager i billboardzie w poziomie.
    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("Nie można zarejestrować wyniku gracza")

    # Dodaje do zwycięstw danego agenta i aktualizuje tabele jego statystyk
    # w PlayerStatsManager i billboardzie w poziomie.
    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("Nie można zarejestrować wygranych gracza")
    
    # Dodaje do strat danego agenta i aktualizuje tabele jego statystyk
    # w PlayerStatsManager i billboardzie w poziomie.
    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("Nie można zarejestrować przegranej gracza")

player_stats_example.verse

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

# Urządzenie trybu kreatywnego utworzone w Verse, które można umieścić w poziomie
player_stats_example := class(creative_device):

    # Dodaje do wyniku gracza, który to aktywował.
    @editable
    ScorePointsButton:button_device = button_device{}

    # Wyświetla wynik gracza, najwyższy wynik, liczbę zwycięstw i porażek
    @editable
    StatsBillboard:billboard_device = billboard_device{}

    # Resetuje wynik gracza i przyznaje mu zwycięstwo lub porażkę
    # zależy to od tego, czy aktualny wynik jest wyższy niż WinScore.
    @editable
    CheckWinButton:button_device = button_device{}

    # Wynik, jaki gracze muszą osiągnąć, aby uzyskać zwycięstwo po 
    # aktywacji przycisku CheckWinButton.
    @editable
    WinScore:int = 10

    # Ilość punktów przyznawanych za naciśnięcie przycisku.
    @editable
    AwardScore:int = 1

    # Zarządza i aktualizuje statystki dla każdego gracza.
    PlayerStatsManager:player_stats_manager = player_stats_manager{}

    # Wyświetla statystyki gracza na billboardzie.
    StatsMessage<localizes>(Player:agent, Score:int, Wins:int, Losses:int):message = "{Player}, Stats:\n  Score: {Score}\n Wins: {Wins}\n  Losses: {Losses}"

    # Działa po uruchomieniu urządzenia w aktywnej grze
    OnBegin<override>()<suspends>:void=
        # Rejestracja zdarzenia przycisku
        ScorePointsButton.InteractedWithEvent.Subscribe(AddScore)

        CheckWinButton.InteractedWithEvent.Subscribe(CheckWin)

        Players := GetPlayspace().GetPlayers()

        # Zainicjuj statystyki gracza
        PlayerStatsManager.InitializeAllPlayers(Players)

    # Dodaje do wyniku danego gracza i aktualizuje jego tabele jego statystyk
    # w PlayerStatsManager i billboardzie w poziomie.
    AddScore(Agent:agent):void=
        if:
            CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
            CurrentScore := CurrentPlayerStats.Score
        then:
            Print("Aktualny wynik to: {CurrentScore}")
            PlayerStatsManager.AddScore(Agent, AwardScore)
            UpdateStatsBillboard(Agent)
       
    # Pobiera statystyki danego gracza i wyświetla jego statystyki
    # na StatsBillboard.
    UpdateStatsBillboard(Agent:agent):void=
        if:
            # Pobierz aktualne statystyki danego agenta.
            CurrentPlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
        then:
            StatsBillboard.SetText(
                StatsMessage(
                    Player := Agent,
                    Score:=CurrentPlayerStats.Score,
                    Wins:=CurrentPlayerStats.Wins,
                    Losses:=CurrentPlayerStats.Losses
                )
            )

    # Przyznaje graczowi zwycięstwo lub porażkę, gdy wchodzi w interakcję
    # z CheckWinButton.
    CheckWin(Agent:agent):void=
        var CurrentScore:int = 0
        if:
            PlayerStats := PlayerStatsManager.GetPlayerStats[Agent]
            set CurrentScore = PlayerStats.Score
        then:
            Print("Aktualny wynik to: {CurrentScore}") 
        if:
            CurrentScore > WinScore
        then:
            PlayerStatsManager.AddWin(Agent, 1)
            # Reset wynik gracza, zapisując jego statystykę wyniku jako 0.
            PlayerStatsManager.AddScore(Agent, -CurrentScore)
        else:
            PlayerStatsManager.AddLoss(Agent, 1)
            # Reset wynik gracza, zapisując jego statystykę wyniku jako 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