Faça sua própria tabela de liderança no jogo em Verse

Neste tutorial, serão desenvolvidos os conceitos mostrados em estatísticas persistentes do jogador, então vamos ver isso primeiro!

Tabelas de liderança são uma marca dos jogos competitivos. Com elas, os jogadores podem exibir suas habilidades e ficarem famosos. Ajudam os jogadores a desenvolver um senso de progressão e os incentiva a voltar o tempo todo para conferir se estão subindo de posição.

A persistência em Verse fornece a ferramenta que permite a criação das tabelas de líderes e acrescentam um toque de competitividade à sua experiência. Você já viu como rastrear dados persistentes entre as sessões de jogo no tutorial de estatísticas persistentes do jogador e como modificar e atualizar os dados de acordo com diferentes eventos. Agora você aplicará esse conhecimento para aprender a criar tabelas de liderança locais completas, classificar as estatísticas dos jogadores e reunir tudo isso em um jogo de corrida!

Funcionalidades da linguagem Verse usadas

• Class: este exemplo cria uma classe Verse persistente que rastreia um grupo de estatísticas para cada jogador.

• Constructor: está é uma função especial que cria uma instância da classe com a qual está associado.

• Weak_map: este é um mapa simples que não pode sofrer iteração. Os dados persistentes em Verse devem ser armazenados em um "weak_map".

Como configurar o nível

Este exemplo usa os seguintes adereços e dispositivos:

• 3x Cartaz: São exibidas estatísticas de tempo de vida de cada jogador. Você as classificará de acordo com os pontos de tempo de vida para exibir os melhores jogadores no lobby.

• 3 dispositivos Referência de Jogador: em conjunto com os cartazes, as referências de jogador identificarão quem são os jogadores com melhor desempenho, assim os outros saberão quem procurar durante o jogo.

• 3 dispositivos Ponto de Verificação: são os pontos de verificação pelos quais os jogadores passam para terminar a corrida.

• 1 dispositivo Gerenciador de Corrida: rastreia quando os jogadores começam e terminam a corrida e concede pontos com base na posição final deles.

• 1 dispositivo Gerador de Caminhonete: gera o veículo que será usado durante a corrida. Você pode mudar para qualquer veículo adequado para a sua experiência.

Para configurar seu nível, siga estas etapas:

Cartazes e referências de jogador

Para exibir as estatísticas do jogador, será usada uma combinação de cartazes e referências do jogador. Em cada cartaz, serão exibidas as estatísticas de tempo de vida do jogador. Já, na referência visual, será mostrada uma representação visual do jogador. Para adicionar esses elementos, siga estas etapas:

1. Adicione três dispositivos Referência de Jogador ao seu nível e posicione-os perto um do outro.

2. Para cada referência de jogador, selecione no Organizador. No painel Detalhes, em Opções do Usuário, defina Cor Personalizada para a cor que você quiser usar para representar o primeiro, segundo e terceiro jogador com melhor desempenho no lobby. Neste exemplo, são usadas as cores dourado, prateado e bronze.

   

3. Adicione três dispositivos Cartaz ao seu nível e coloque um na frente de cada referência de jogador. No início do jogo, você atualizará os dispositivos com as estatísticas de cada jogador usando Verse.

Pontos de verificação, caminhonete e gerenciador de corrida

Como é uma corrida, você precisará de algo para usar para correr! Você também precisará de pontos de controle para passar, e um gerenciador de corrida para orientar a corrida durante o jogo. Para adicionar esses elementos, siga estas etapas:

1. Adicione três dispositivos Ponto de Verificação de Corrida ao seu nível. Coloque-os na ordem em que você quer que os jogadores passem por eles. Para cada ponto de verificação, no Organizador, verifique se o Número do Ponto de Verificação corresponde à ordem em que os jogadores passam pelos pontos de verificação.

   

2. Adicione um dispositivo Gerenciador de Corrida ao seu nível. Serve para administrar a corrida e direcionar os jogadores para os pontos de controle. Você escutará o RaceCompletedEvent() deste dispositivo mais tarde para saber quando um jogador terminar a corrida.

3. Adicione um dispositivo Gerador de Caminhonete ao seu nível. O veículo é opcional, mas neste guia é usada uma caminhonete para se adequar ao modelo Circuito e dar aos jogadores algo para dirigirem.

Como modificar sua tabela de estatísticas

Neste exemplo, é usada uma versão modificada do arquivo player_stats_table das estatísticas persistentes do jogador. Esta é parecida com a do arquivo usado no exemplo, mas com algumas diferenças importantes que alteram a implementação.

Siga os passos abaixo para criar sua tabela de estatísticas do jogador:

1. Na sua classe player_stats_table:

   1. Remova a estatística Derrotas.

   2. Altere a estatística Pontuação para Pontos.

      Verse

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

2. Modifique a função do construtor MakePlayerStatsTable() no seu arquivo para alterar as estatísticas atualizadas.

   Verse

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

   Copy full snippet(5 lines long)

3. Adicione uma nova struct player_and_stats ao seu arquivo player_stats_table.verse. Essa struct contém uma referência a um jogador e sua respectiva classe player_stats_table, assim você poderá usar ambos os dados sem precisar recuperá-los o tempo todo. A struct completa player_and_stats deve ficar assim:

   Verse

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

   Copy full snippet(4 lines long)

Como gerenciar atributos

Assim como ocorre nas Estatísticas Persistentes de Jogadores, você usará o arquivo do gerenciador para tratar do gerenciamento e gravação de alterações de estatísticas dos jogadores.

Siga os passos abaixo para compilar seu arquivo player_stats_manager modificado.

1. Modifique a assinatura da função InitializeAllPlayers() e InitializePlayer() para InitializeAllPlayerStats() e InitializePlayerStat(). Esses nomes demonstram melhor a relação com a função GetPlayerStat(). Sua função atualizada deve ficar assim:

   Verse

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

2. Modifique a assinatura da função AddScore() para AddPoints(). Em seguida, remova a função AddLosses(), pois sua player_stats_table não contém mais esse valor. O arquivo completo player_stats_manager deve ficar assim:

   Verse

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

Como criar tabelas de liderança do jogador

Para exibir os dados do jogador nas tabelas de liderança, será preciso fazer algumas coisas. Você precisa ter uma maneira de atualizar o texto mostrado nos cartazes e os jogadores nos dispositivos de referência de jogador. Também será preciso ter uma maneira de classificar esses dispositivos, pois você não irá querer que os melhores jogadores tenham mais destaque na sua tabela de liderança. Como essas funções têm um objetivo parecido, que é modificar dispositivos no nível, é recomendável agrupá-las num mesmo arquivo.

Siga as etapas abaixo para criar funções que atualizam os dispositivos que você tem no nível:

1. Crie um novo arquivo em Verse chamado player_leaderboards.verse. Esse arquivo armazenará as funções compartilhadas para atualizar as tabelas de liderança que você tem no nível.

2. Para o próximo cartaz, você usará uma mensagem capaz de receber argumentos. Crie uma nova mensagem com o nome StatsMessage que recebe CurrentPlayer, Points e Wins, todos do tipo message, e retorna o texto combinado como message.

   Verse

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

   Copy full snippet(3 lines long)

3. Adicione mais três variáveis message, uma para cada entrada de StatsMessage. A mensagem PlayerText recebe um agente Agent; a mensagem PointsText, os pontos do agente; e a mensagem WinsText, as vitórias do agente. StatsMessage constrói uma mensagem com todas essas variáveis para exibir com clareza seus dados no nível.

   Verse

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

   Copy full snippet(6 lines long)

4. Para atualizar um cartaz, chame a função UpdateStatsBillboard() mostrada no tutorial de estatísticas persistentes do jogador. Como essa função é definida num arquivo separado do dispositivo Verse, é preciso adicionar StatsBillboard como argumento adicional para especificar qual cartaz será atualizado.

   Verse

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

   Copy full snippet(2 lines long)

5. Primeiro, use GetPlayerStats[] para obter as estatísticas do jogador passado como argumento. Não é necessário ter uma referência ao player_stats_manager, pois não é mais uma classe separada. Em seguida, crie uma nova StatsMessage usando o jogador, os Pontos e as Vitórias do CurrentPlayerStats dele. Por fim, chame SetText() no StatsBillboard para atualizar o texto do cartaz que está no nível. Sua função UpdateStatsBillboard() concluída deve ficar assim:

   Verse

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

   Copy full snippet(10 lines long)

Como classificar e exibir o melhor jogador

Antes de continuar, é importante pensar em como você deseja classificar os cartazes. Quer que o jogador com a maior pontuação fique no topo, ou o jogador com mais vitórias? E se você quiser classificar segundo estatísticas diferentes? É preciso ter um método para tratar de todos esses casos, e a resposta para isso é um algoritmo de classificação. Ao usar um algoritmo de classificação e uma função de comparação, você poderá especificar critérios de classificação. Em seguida, seus cartazes e as referências do jogador poderão ser classificadas para exibir os melhores jogadores na sua experiência Neste exemplo, é usado o algoritmo de classificação por mesclagem, mas você pode implementar o seu se quiser.

Siga as etapas abaixo para acrescentar comparação e classificação aos seus cartazes e terminar de atualizar os dispositivos no seu nível.

1. Novamente no seu arquivo player_stats_table, você definirá funções de comparação para cada um dos seus atributos. Cada função dessas recebe uma struct Esquerda, Right e player_and_stats e as compara com base em uma estatística específica. Essas funções têm os modificadores <decides><transacts>. Portanto, se a comparação falhar, a função também falhará. Por exemplo, saiba que Esquerda é menor que Direita. Adicione uma nova função chamada MorePointsComparison() ao seu arquivo player_stats_table.verse. Essa função verifica se Left.Points é maior que Right.Points e, caso não seja, falha. Se for bem-sucedida, retorna Esquerda.

   Verse

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

   Copy full snippet(4 lines long)

2. Copie essa função três vezes, uma para uma comparação de menos pontos e duas para comparar vitórias. Suas funções de comparação devem ser parecidas com as seguintes:

   Verse

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

3. Adicione o algoritmo de classificação de mesclagem. Você pode colocar isso em um arquivo ou módulo separado e testar o algoritmo no arquivo de teste fornecido.

4. Em player_leaderboards, adicione uma nova função UpdateStatsBillboards(). Essa função recebe uma matriz de agentes e uma matriz de painéis, classifica-os e chama UpdateStatsBillboard() para atualizar cada painel no nível.

   Verse

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

   Copy full snippet(3 lines long)

5. Em UpdateStatsBillboards(), inicialize uma nova variável de matriz de player_and_stats chamada PlayerAndStatsArray. Defina como o resultado de uma expressão for. Nessa expressão for, para cada agente, obtenha o jogador desse agente e recupere a player_stats_table dele por meio de GetPlayerStats[]. Em seguida, retorne um struct player_and_stats construído a partir do jogador e de sua tabela de estatísticas.

   Verse

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

   Copy full snippet(10 lines long)

6. Para classificar seu PlayerAndStatsArray, inicialize uma nova variável SortedPlayersAndStats com o resultado da chamada MergeSort(), passando a matriz e MorePointsComparison. Após a classificação em uma expressão for, itere por cada elemento em SortedPlayerAndStats, armazenando o índice do elemento em uma variável PlayerIndex. Utilize PlayerIndex para indexar a matriz StatsBillboards e, em seguida, chame UpdateStatsBillboard informando o jogador e o cartaz a ser atualizado. Sua função UpdateStatsBillboards() concluída deve ficar assim:

   Verse

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

7. Para atualizar suas referências de jogador, você usará uma função muito semelhante, chamada UpdatePlayerReferences(). Essa função usa uma matriz de player_reference_device em vez de painéis e, em vez de chamar UpdateStatsBillboard() no final, chama Register() no dispositivo de referência do jogador para cada jogador. Copie seu código UpdateStatsBillboard() em uma nova função UpdatePlayerReferences() com as alterações acima. Sua função UpdatePlayerReferences() concluída deve ficar assim:

   Verse

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

Tabelas de liderança de jogadores no seu nível

Com tudo configurado, é hora de mostrar seus jogadores! Você criará um dispositivo para premiar pontos aos jogadores quando eles interagirem com o botão e classificará as referências e os painéis de jogadores de forma que os melhores jogadores fiquem na frente e no centro. Siga as etapas abaixo para criar um dispositivo Verse com o objetivo de testar as tabelas de liderança no seu nível:

1. Crie um novo dispositivo Verse chamado player_leaderboards_example. Consulte os passos em Crie seu próprio dispositivo usando o Verse.

2. Na parte superior da definição da classe player_leaderboards_example, adicione os seguintes campos:

   • Uma matriz editável de dispositivos de referência de jogador denominada PlayerReferences. Estes fornecem representações visuais de cada jogador na corrida.

     Verse

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

     Copy full snippet(3 lines long)

   • Uma matriz editável de dispositivos Cartaz denominada Tabelas de Liderança. Estes exibem as estatísticas de cada jogador em um painel no nível.

     Verse

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

     Copy full snippet(3 lines long)

   • Um dispositivo Gerenciador de Corrida editável denominado RaceManager. Você se inscreverá em eventos do Gerenciador de Corrida para saber quando um jogador terminar a corrida.

     Verse

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

     Copy full snippet(3 lines long)

   • Um número inteiro editável denominado PlacementRequiredForWin. Essa é a colocação que um jogador precisa atingir para receber uma vitória.

     Verse

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

     Copy full snippet(3 lines long)

   • Uma matriz editável de números inteiros denominada PointsPerPlace. É o número de pontos que cada jogador ganha com base em sua colocação.

     Verse

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

     Copy full snippet(5 lines long)

   • Uma variável inteira denominada CurrentFinishOrder. Essa é a colocação do jogador que mais recentemente completou a corrida.

     Verse

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

     Copy full snippet(3 lines long)

Estatísticas de premiação com base na colocação

Quando um jogador termina a corrida, você deseja atualizar as estatísticas deles com base na colocação. Jogadores com boas colocações devem receber um número maior de pontos, enquanto jogadores com as melhores colocações devem receber uma vitória.

Siga estas etapas para premiar estatísticas aos jogadores quando eles terminarem a corrida:

1. Para tratar disso, adicione uma nova função RecordPlayerFinish() à definição da classe player_leaderboards_example. Essa função recebe como parâmetro o jogador ao qual estatísticas serão premiadas.

   Verse

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

   Copy full snippet(3 lines long)

2. Em RecordPlayerFinish(), obtenha a colocação desse jogador ao receber o valor atual de CurrentFinishOrder em um novo int denominado PlayerFinishOrder. Em seguida, aumente CurrentFinishOrder para que o próximo jogador a terminar não fique na mesma posição.

   Verse

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

   Copy full snippet(3 lines long)

3. Agora é hora de premiar estatísticas. Para saber quantos pontos devem ser concedidos a esse jogador, em uma expressão if, indexe na matriz PointsPerPlace usando PlayerFinishOrder. Em seguida, chame AddPoints() para conceder a esse jogador essa quantidade de pontos.

   Verse

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

   Copy full snippet(5 lines long)

4. Se a colocação do jogador tiver sido alta o suficiente para obter uma vitória, você precisará registrar uma vitória na tabela de estatísticas dele. Em outra expressão if, verifique se PlayerFinishOrder foi menor que PlacementRequiredToWin. Em caso afirmativo, chame AddWin(), informando o jogador e uma vitória para conceder a ele. Sua função RecordPlayerFinish() concluída deve ficar assim:

   Verse

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

Como aguardar os jogadores terminarem a corrida

Agora que você tem o registro de estatísticas pronto, precisa saber quando um jogador termina a corrida para atualizar suas estatísticas. Para fazer isso, você ouvirá o RaceCompletedEvent() do gerenciador de corrida. Esse evento é acionado sempre que um jogador termina a corrida e, portanto, você terá de ouvi-lo continuamente em uma função assíncrona.

1. Adicione uma nova função WaitForPlayerToFinishRace() à definição da classe player_leaderboards_example. Essa função usa um jogador e espera ele terminar a corrida.

   Verse

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

   Copy full snippet(2 lines long)

2. Em WaitForPlayerToFinishRace(), em uma expressão race, inicie dois loops. O primeiro aguardará que o jogador termine a corrida, e o outro cuidará do que acontece se o jogador sair da sessão antes de terminar. Se um jogador sair, você não quer que o loop continue sendo executado para sempre e, portanto, precisa de uma maneira de sair dele nessa situação.

   Verse

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

   Copy full snippet(7 lines long)

3. No primeiro loop, aguarde o RaceManager.RaceCompletedEvent e armazene o resultado em uma variável chamada FinishingPlayer. Como esse evento é acionado sempre que um jogador termina a corrida, é preciso garantir que o jogador armazenado seja o jogador que você estava monitorando. Compare FinishingPlayer com o jogador que este loop está monitorando. Se os dois forem iguais, informe o jogador para RecordPlayerFinish() e saia do loop

   Verse

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

   Copy full snippet(8 lines long)

4. No segundo loop, aguarde o evento do espaço de jogo PlayerRemovedEvent(). Como antes, obtenha o jogador que acabou de sair e armazene-o em uma variável LeavingPlayer. Se o jogador que acabou de sair for o jogador que esse loop está esperando, saia do loop. Sua função WaitForPlayerToFinishRace() concluída deve ficar assim:

   Verse

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

É hora de juntar tudo

Com suas funções configuradas, é hora de vinculá-las aos seus dispositivos e começar a correr!

Siga estas etapas para vincular sua lógica aos seus dispositivos:

1. Em OnBegin(), obtenha todos os jogadores no espaço de jogo usando GetPlayers(). Informe essa matriz em InitializeAllPlayerStats() para configurar player_stats_tables para cada um deles.

   Verse

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

   Copy full snippet(6 lines long)

2. Chame UpdateStatsBillboards(), passando as matrizes Jogadores e Tabelas de Liderança para atualizar os painéis no nível com os dados atuais de cada jogador. Em seguida, chame UpdatePlayerReferences() para atualizar as referências em nível para corresponderem aos jogadores. Por fim, em uma expressão for, gere uma função WaitForPlayerToFinishRace() para cada jogador. Sua função OnBegin() concluída deve ficar assim:

   Verse

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

3. Salve o código e compile-o.

Arraste o dispositivo player_leaderboards_example para seu nível. Atribua suas referências de jogador à matriz PlayerReferences, observando a ordem. O dispositivo no primeiro índice deve corresponder à referência do jogador para o melhor jogador, o segundo índice para o segundo melhor jogador e assim por diante. Faça o mesmo com tabelas de liderança, certificando-se de mantê-las alinhadas com os dispositivos de referência do jogador. Não se esqueça de atribuir seu dispositivo Gerenciador de Corrida também!

Como testar tabelas de liderança persistentes

Você pode testar seus dados persistentes em uma sessão de edição, mas esses dados serão redefinidos quando você sair e reiniciar a sessão. Para que seus dados persistam entre as sessões, você terá que iniciar uma sessão de teste e alterar certas configurações em Configurações da Ilha. Para obter informações sobre como configurar sua ilha para testar dados persistentes em sessões de edição e de teste, consulte Como testar com dados persistentes e altere certas configurações nas Configurações da Ilha. Para obter informações sobre como configurar sua ilha para testar dados persistentes em sessões de edição e de teste, consulte Como testar com dados persistentes.

Depois de configurar sua sessão, ao testar seu nível, os jogadores que terminarem a corrida devem receber pontos com base na colocação. Eles devem receber uma vitória se a colocação for alta o suficiente, e essas estatísticas devem persistir entre as sessões de jogo. Os jogadores e suas estatísticas devem ser ordenados, com o jogador com mais pontos aparecendo em primeiro lugar.

Por si só

Ao concluir este guia, você aprendeu a criar tabelas de liderança que exibem estatísticas persistentes dos jogadores no seu nível. Você também aprendeu a classificar e atualizar essas tabelas de liderança, garantindo que todos saibam quem são os melhores jogadores. Tente adaptar este tutorial às suas próprias experiências e mostre o melhor dos melhores!

Código completo

player_stats_table.verse

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

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

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

player_leaderboards.verse

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

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

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

player_stats_manager.verse

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

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

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

player_leaderboards_example.verse

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

    # See https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse for how to create a verse device.

    # A Verse-authored creative device that can be placed in a level
    player_leaderboards_example := class(creative_device):
        # Visual representations of each player.