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:
Adicione três dispositivos Referência de Jogador ao seu nível e posicione-os perto um do outro.
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.
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:
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.
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.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:
Na sua classe
player_stats_table:Remova a estatística
Derrotas.Altere a estatística
PontuaçãoparaPontos.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.
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.WinsAdicione uma nova struct
player_and_statsao seu arquivo player_stats_table.verse. Essa struct contém uma referência a umjogadore sua respectiva classeplayer_stats_table, assim você poderá usar ambos os dados sem precisar recuperá-los o tempo todo. A struct completaplayer_and_statsdeve 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
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.
Modifique a assinatura da função
InitializeAllPlayers()eInitializePlayer()paraInitializeAllPlayerStats()eInitializePlayerStat(). Esses nomes demonstram melhor a relação com a funçãoGetPlayerStat(). 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{}Modifique a assinatura da função
AddScore()paraAddPoints(). Em seguida, remova a funçãoAddLosses(), pois suaplayer_stats_tablenão contém mais esse valor. O arquivo completoplayer_stats_managerdeve 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=
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:
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.
Para o próximo cartaz, você usará uma mensagem capaz de receber argumentos. Crie uma nova mensagem com o nome
StatsMessageque recebeCurrentPlayer,PointseWins, todos do tipomessage, e retorna o texto combinado comomessage.Verse# The message to display on the stats billboard. StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message= "{CurrentPlayer}:\n{Points}\n{Wins}"Adicione mais três variáveis
message, uma para cada entrada deStatsMessage. A mensagemPlayerTextrecebe um agenteAgent; a mensagemPointsText, os pontos do agente; e a mensagemWinsText, as vitórias do agente.StatsMessageconstró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"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 adicionarStatsBillboardcomo 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=Primeiro, use
GetPlayerStats[]para obter as estatísticas do jogador passado como argumento. Não é necessário ter uma referência aoplayer_stats_manager, pois não é mais uma classe separada. Em seguida, crie uma novaStatsMessageusando o jogador, osPontose asVitóriasdoCurrentPlayerStatsdele. Por fim, chameSetText()noStatsBillboardpara atualizar o texto do cartaz que está no nível. Sua funçãoUpdateStatsBillboard()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)
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.
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 structEsquerda,Righteplayer_and_statse 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 queEsquerdaé menor queDireita. Adicione uma nova função chamadaMorePointsComparison()ao seu arquivo player_stats_table.verse. Essa função verifica seLeft.Pointsé maior queRight.Pointse, caso não seja, falha. Se for bem-sucedida, retornaEsquerda.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 LeftCopie 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 LeftAdicione 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.
Em
player_leaderboards, adicione uma nova funçãoUpdateStatsBillboards(). Essa função recebe uma matriz de agentes e uma matriz de painéis, classifica-os e chamaUpdateStatsBillboard()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=Em
UpdateStatsBillboards(), inicialize uma nova variável de matriz deplayer_and_statschamadaPlayerAndStatsArray. Defina como o resultado de uma expressãofor. Nessa expressãofor, para cadaagente, obtenha ojogadordesseagentee recupere aplayer_stats_tabledele por meio deGetPlayerStats[]. Em seguida, retorne um structplayer_and_statsconstruído a partir dojogadore de sua tabela de estatísticas.VerseUpdateStatsBillboards<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 := PlayerStatsPara classificar seu
PlayerAndStatsArray, inicialize uma nova variávelSortedPlayersAndStatscom o resultado da chamadaMergeSort(), passando a matriz eMorePointsComparison. Após a classificação em uma expressãofor, itere por cada elemento emSortedPlayerAndStats, armazenando o índice do elemento em uma variávelPlayerIndex. UtilizePlayerIndexpara indexar a matrizStatsBillboardse, em seguida, chameUpdateStatsBillboardinformando o jogador e o cartaz a ser atualizado. Sua funçãoUpdateStatsBillboards()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:Para atualizar suas referências de jogador, você usará uma função muito semelhante, chamada
UpdatePlayerReferences(). Essa função usa uma matriz deplayer_reference_deviceem vez de painéis e, em vez de chamarUpdateStatsBillboard()no final, chamaRegister()no dispositivo de referência do jogador para cada jogador. Copie seu códigoUpdateStatsBillboard()em uma nova funçãoUpdatePlayerReferences()com as alterações acima. Sua funçãoUpdatePlayerReferences()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:
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:
Crie um novo dispositivo Verse chamado player_leaderboards_example. Consulte os passos em Crie seu próprio dispositivo usando o Verse.
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{}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{}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{}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 = 1Uma 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}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
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:
Para tratar disso, adicione uma nova função
RecordPlayerFinish()à definição da classeplayer_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=Em
RecordPlayerFinish(), obtenha a colocação desse jogador ao receber o valor atual deCurrentFinishOrderem um novointdenominadoPlayerFinishOrder. Em seguida, aumenteCurrentFinishOrderpara que o próximo jogador a terminar não fique na mesma posição.VerseRecordPlayerFinish(Player:agent):void= PlayerFinishOrder:int = CurrentFinishOrder set CurrentFinishOrder += 1Agora é hora de premiar estatísticas. Para saber quantos pontos devem ser concedidos a esse jogador, em uma expressão
if, indexe na matrizPointsPerPlaceusandoPlayerFinishOrder. Em seguida, chameAddPoints()para conceder a esse jogador essa quantidade de pontos.Verseset CurrentFinishOrder += 1 if: PointsToAward := PointsPerPlace[PlayerFinishOrder] then: AddPoints(Player, PointsToAward)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 sePlayerFinishOrderfoi menor quePlacementRequiredToWin. Em caso afirmativo, chameAddWin(), informando o jogador e uma vitória para conceder a ele. Sua funçãoRecordPlayerFinish()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)
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.
Adicione uma nova função
WaitForPlayerToFinishRace()à definição da classeplayer_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=Em
WaitForPlayerToFinishRace(), em uma expressãorace, 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:No primeiro loop, aguarde o
RaceManager.RaceCompletedEvente armazene o resultado em uma variável chamadaFinishingPlayer. Como esse evento é acionado sempre que um jogador termina a corrida, é preciso garantir que o jogador armazenado seja o jogador que você estava monitorando. CompareFinishingPlayercom o jogador que este loop está monitorando. Se os dois forem iguais, informe o jogador paraRecordPlayerFinish()e saia do loopVerse# Waiting for this player to finish the race and then record the finish. loop: FinishingPlayer := RaceManager.RaceCompletedEvent.Await() if: FinishingPlayer = Player then: RecordPlayerFinish(Player) breakNo 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ávelLeavingPlayer. Se o jogador que acabou de sair for o jogador que esse loop está esperando, saia do loop. Sua funçãoWaitForPlayerToFinishRace()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)
É 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:
Em
OnBegin(), obtenha todos os jogadores no espaço de jogo usandoGetPlayers(). Informe essa matriz emInitializeAllPlayerStats()para configurarplayer_stats_tablespara 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)Chame
UpdateStatsBillboards(), passando as matrizesJogadoreseTabelas de Liderançapara atualizar os painéis no nível com os dados atuais de cada jogador. Em seguida, chameUpdatePlayerReferences()para atualizar as referências em nível para corresponderem aos jogadores. Por fim, em uma expressãofor, gere uma funçãoWaitForPlayerToFinishRace()para cada jogador. Sua funçãoOnBegin()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.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.