Este tutorial parte de los conceptos explicados en Estadísticas de jugador persistentes, ¡así que échale un vistazo primero!
Las tablas de clasificación son un elemento básico de los juegos competitivos, ya que permiten a los jugadores mostrar sus habilidades y dar a conocer su nombre. Ayudan a los jugadores a desarrollar un sentido de progresión y los animan a regresar y repetir para que puedan verse a sí mismos llegar a lo más alto.
La persistencia de Verse proporciona la herramienta que te permite crear estos marcadores y añadir ese toque competitivo a tu experiencia. Ya has visto cómo puedes hacer un seguimiento de los datos persistentes entre sesiones de juego en el tutorial Estadísticas de jugador persistentes y cómo modificar y actualizar esos datos en función de distintos acontecimientos. Ahora aplicarás esos conocimientos para aprender a crear tablas de clasificación locales completas, ordenar las estadísticas de los jugadores y ponerlo todo junto en un juego de carreras.
Funciones del lenguaje Verse utilizadas
Clase: este ejemplo crea una clase de Verse persistente que realiza un seguimiento de un grupo de estadísticas por jugador.
Constructor: un constructor es una función especial que crea una instancia de la clase con la que está asociado.
weak_map: es un mapa simple en el cual no se puede iterar. Los datos de persistencia de Verse se deben almacenar en un weak_map.
Cómo configurar el nivel
Este ejemplo utiliza los siguientes elementos y dispositivos:
3 dispositivos Valla publicitaria: en ellas se mostrarán las estadísticas del historial de cada jugador y podrás ordenarlas en función del historial de puntos para mostrar a los mejores jugadores de la sala.
3 dispositivos Referencia del jugador: en combinación con las vallas publicitarias, las referencias de los jugadores pondrán cara al nombre de tus mejores jugadores, para que los demás sepan a quién deben tener en cuenta durante la partida.
3 dispositivos Punto de control: estos son los puntos de control por los que los jugadores corren para completar la carrera.
1 dispositivo Gestor de carreras: registra cuándo los jugadores empiezan y terminan la carrera y les otorga puntos en función de su posición final.
1 dispositivo Generador de camionetas: genera el vehículo que utilizarás durante la carrera, pero puedes cambiarlo por cualquier vehículo que se adapte a tu experiencia.
Sigue estos pasos para configurar el nivel:
Vallas publicitarias y referencias de jugadores
Para mostrar las estadísticas de los jugadores, utilizarás una combinación de vallas publicitarias y referencias de jugadores. Cada valla publicitaria mostrará las estadísticas del historial del jugador, mientras que la referencia de jugador mostrará una representación visual del mismo. Sigue estos pasos para añadir estos elementos:
Añade tres dispositivos de Referencia del jugador a tu nivel y colócalos uno al lado del otro.
Selecciona cada referencia de jugador en el esquematizador. En el panel Detalles, en Opciones de usuario, establece Color personalizado en el color que quieras que represente al primero, segundo y tercer jugador con mejor rendimiento en la sala. Este ejemplo utiliza oro, plata y bronce como colores.
Añade tres dispositivos Valla publicitaria a tu nivel y coloca uno delante de cada referencia de jugador. Las actualizarás con las estadísticas de cada jugador utilizando Verse cuando empiece la partida.
Puntos de control, camioneta y gestor de carreras
Esto es una carrera, así que necesitarás algo con lo que correr. También necesitarás puntos de control por los que pasar y un gestor de carreras que dirija la carrera durante la partida. Sigue estos pasos para añadir estos elementos:
Añade tres dispositivos Punto de control de carrera a tu nivel. Colócalos en el orden en que quieras que los jugadores pasen por ellos. Para cada punto de control, en el esquematizador, asegúrate de que el Número de punto de control coincida con el orden en que los jugadores pasan por los puntos de control.
Añade un dispositivo Gestor de carreras al nivel. Se encargará de dirigir la carrera y dirigir a los jugadores hacia los puntos de control. Escucharás a
RaceCompletedEvent()desde este dispositivo más adelante para saber cuándo un jugador termina la carrera.Añade un dispositivo Generador de camionetas a tu nivel. Es opcional que haya un vehículo, pero en esta guía se utiliza una camioneta para ajustarse a la plantilla de carrera de velocidad y ofrecer a los jugadores algo con lo que desplazarse.
Cómo modificar la tabla de estadísticas
Este ejemplo utiliza una versión modificada del archivo player_stats_table de Estadísticas de jugador persistentes. Tendrá un aspecto similar al archivo de ese ejemplo, con algunas diferencias importantes que cambian la implementación.
Sigue los pasos que se indican a continuación para crear tu tabla de estadísticas de jugadores:
En la clase
player_stats_table:Elimina la estadística
Losses.Cambia la estadística
ScoreaPoints.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.
Modifica la función del constructor
MakePlayerStatsTable()en el archivo para reflejar las estadísticas actualizadas.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.WinsAñade una nueva struct
player_and_statsa tu archivo player_stats_table.verse. Esta struct contiene una referencia a unplayery a su claseplayer_stats_tablepara que puedas utilizar ambos datos en funciones sin necesidad de recuperarlos repetidamente. Tu structplayer_and_statscompleta debería tener el siguiente aspecto:Verse# Structure for passing a player and their stats as arguments. player_and_stats<public> := struct: Player<public>:player StatsTable<public>:player_stats_table
Cómo gestionar las estadísticas
Igual que en Estadísticas de jugador persistentes, vas a utilizar un archivo gestor para gestionar y registrar los cambios de estadísticas de los jugadores.
Sigue los siguientes pasos para crear tu archivo player_stats_manager modificado.
Modifica la firma de las funciones
InitializeAllPlayers()eInitializePlayer()porInitializeAllPlayerStats()eInitializePlayerStat(). Estos nombres reflejan mejor su relación con la funciónGetPlayerStat(). Tu función actualizada debería tener el siguiente aspecto: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{}Modifica la firma de la función
AddScore()aAddPoints(). A continuación, elimina la funciónAddLosses(), ya que tuplayer_stats_tableya no contiene ese valor. Tu archivoplayer_stats_managerdebería tener el siguiente aspecto: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=
Cómo crear marcadores de jugadores
Para mostrar los datos de los jugadores en tus tablas de clasificación, vas a necesitar unas cuantas cosas. Necesitas una forma de actualizar el texto de las vallas publicitarias y de los jugadores en los dispositivos de referencia de los jugadores. También necesitas una forma de clasificar estos dispositivos, ya que quieres que los mejores jugadores sean los más destacados en tu tabla de clasificación. Como estas funciones tienen un objetivo similar de modificar los dispositivos del nivel, es buena idea agruparlas en un archivo común.
Sigue los pasos que se indican a continuación para crear funciones que actualicen tus dispositivos en nivel:
Crea un nuevo archivo de Verse con el nombre player_leaderboards.verse. Este archivo almacenará las funciones comunes para actualizar tus tablas de clasificación en el nivel.
Para el texto de la valla publicitaria, utilizarás un mensaje al que puedas pasar argumentos. Crea un nuevo mensaje con el nombre
StatsMessageque tomeCurrentPlayer,PointsyWins, todos de tipomessagey devuelva el texto combinado como unmessage.Verse# The message to display on the stats billboard. StatsMessage<localizes>(CurrentPlayer:message, Points:message, Wins:message):message= "{CurrentPlayer}:\n{Points}\n{Wins}"Añade tres variables
messagemás, una para cada una de las entradas deStatsMessage. El mensajePlayerTexttoma unAgent, el mensajePointsTexttoma los puntos de ese agente y el mensajeWinsTexttoma las victorias de ese agente.StatsMessagecreará un mensaje a partir de todos ellos para mostrar de forma clara tus datos en el nivel.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 actualizar una valla publicitaria, llamarás a la función
UpdateStatsBillboard()del tutorial Estadísticas de jugador persistentes. Como esta función se define en un archivo distinto del dispositivo de Verse, tienes que añadirStatsBillboardcomo argumento adicional para especificar qué valla publicitaria vas a actualizar.Verse# Updates the given billboard device to display the stats of the given player. UpdateStatsBillboard<public>(Player:agent, StatsBillboard:billboard_device):void=Primero, obtén las estadísticas del jugador pasado como argumento utilizando
GetPlayerStats[]. No necesitas una referencia aplayer_stats_managerporque ya no es una clase independiente. A continuación, construye un nuevoStatsMessagecon el jugador y losPointsyWinsde susCurrentPlayerStats. Por último, llama aSetText()enStatsBillboardpara actualizar el texto de la valla publicitaria a nivel interno. Tu funciónUpdateStatsBillboard()completa debería tener el siguiente aspecto: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)
Cómo ordenar y mostrar el mejor jugador
Antes de continuar, es importante que consideres cómo quieres ordenar estas vallas publicitarias. ¿Quieres que el jugador con más puntos esté arriba, o el jugador con más victorias? ¿Y si quieres ordenar por diferentes estadísticas? Necesitas un método que se encargue de todo esto, y un algoritmo de ordenación es la respuesta. Utilizando un algoritmo de ordenación y una función de comparación puedes especificar por qué criterios quieres ordenar. A continuación, puedes ordenar tus vallas publicitarias y referencias de jugadores para mostrar los mejores jugadores de tu experiencia. Este ejemplo utiliza el algoritmo Merge Sort (ordenamiento por mezcla), pero eres libre de aplicar el tuyo propio.
Sigue los pasos que se indican a continuación para añadir la comparación y ordenación a tus vallas publicitarias, y termina de actualizar los dispositivos de tu nivel.
De vuelta al archivo
player_stats_table, vas a definir funciones de comparación para cada una de tus estadísticas. Cada una de ellas toma una structplayer_and_statsLeftyRight, y los compara en función de una estadística concreta. Estas funciones tienen los modificadores<decides><transacts>, por lo que si la comparación falla, la función también fallará. Por ejemplo, avisarte de queLeftes menor queRight. Añade una nueva función con el nombreMorePointsComparison()a tu archivo player_stats_table.verse. Esta función comprueba siLeft.Pointses mayor queRight.Points, y falla si no es así. Si tiene éxito, devuelveLeft`.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 LeftCopia esta función tres veces, una para obtener una comparación de menos puntos y dos para comparar las victorias. Las funciones de tu comparación deberían parecerse a lo siguiente:
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 LeftAñade el algoritmo Merge Sort (ordenamiento por mezcla). Puedes colocarlo en un archivo o módulo aparte y probar el algoritmo en el archivo de prueba proporcionado.
De vuelta a
player_leaderboards, añade una nueva funciónUpdateStatsBillboards(). Esta función toma una matriz de agentes y una matriz de vallas publicitarias, las ordena y llama aUpdateStatsBillboard()para actualizar cada valla publicitaria en el nivel.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=En
UpdateStatsBillboards(), inicializa una nueva variable de matriz deplayer_and_statscon el nombrePlayerAndStatsArray. Especifica que es igual al resultado de una expresiónfor. En esa expresiónfor, para cadaagent, obtén elplayerde eseagenty recupera suplayer_stats_tablemedianteGetPlayerStats[]. A continuación, devuelve una structplayer_and_statsconstruida a partir delplayery su tabla de estadí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 ordenar tu
PlayerAndStatsArray, inicializa una nueva variableSortedPlayersAndStatspara el resultado de llamar aMergeSort()y pasar la matriz yMorePointsComparison. Después de ordenar en una expresiónfor, itera por cada elemento enSortedPlayerAndStatsy almacena el índice del elemento en una variablePlayerIndex. UtilizaPlayerIndexpara indexarlo en la matrizStatsBillboardsy, a continuación, llama aUpdateStatsBillboardpasando el jugador y la valla publicitaria que deseas actualizar. Tu funciónUpdateStatsBillboards()completa debería tener el siguiente aspecto: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 actualizar las referencias de tu jugador, vas a utilizar una función muy similar con el nombre
UpdatePlayerReferences(). Esta función toma una matriz deplayer_reference_deviceen vez de vallas publicitarias y, en vez de llamar aUpdateStatsBillboard()al final, llama aRegister()en el dispositivo de referencias del jugador de cada jugador. Copia tu código deUpdateStatsBillboard()en una nueva funciónUpdatePlayerReferences()con los cambios anteriores. Tu funciónUpdatePlayerReferences()completa debería tener el siguiente aspecto: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:
Marcadores de jugadores en tu nivel
Si lo tienes todo preparado, ¡es hora de presumir de jugadores! Crearás un dispositivo para conceder puntos a los jugadores cuando interactúen con el botón y ordenarás las referencias de los jugadores y las vallas publicitarias para que los mejores jugadores estén en primer plano. Sigue los pasos que se indican a continuación para crear un dispositivo Verse y probar los marcadores en tu nivel:
Crea un nuevo dispositivo de Verse con el nombre player_leaderboards_example. Consulta Cómo crear tu propio dispositivo con Verse para ver los pasos.
En la parte superior de la definición de la clase
player_leaderboards_example, añade los siguientes campos:Una matriz editable de dispositivos de referencia de jugadore con el nombre
PlayerReferences. Proporcionan representaciones visuales de cada participante en la carrera.Verse# Visual representations of each player. @editable PlayerReferences:[]player_reference_device = array{}Una matriz editable de dispositivos de vallas publicitarias con el nombre
Leaderboards. Muestran las estadísticas de cada jugador en una valla publicitaria del nivel.Verse# Billboards that display each player's stats. @editable Leaderboards:[]billboard_device = array{}Un dispositivo editable del gestor de carreras con el nombre
RaceManager. Te suscribirás a los eventos del gestor de carreras para saber cuándo un jugador termina la carrera.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{}Un entero editable con el nombre
PlacementRequiredForWin. Esta es la posición que debe alcanzar un jugador para que se le conceda una victoria.Verse# The placement of a player must be at or below to award a win. @editable PlacementRequiredForWin:int = 1Una matriz editable de enteros con el nombre
PointsPerPlace. Se trata del número de puntos que gana cada jugador en función de su posición.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}Una variable entera con el nombre
CurrentFinishOrder. Esta es la posición del jugador que ha completado la carrera más recientemente.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
Cómo conceder estadísticas basadas en la posición
Cuando un jugador termina la carrera, te interesa actualizar sus estadísticas en función de su posición. Los jugadores que obtienen buenas posiciones deben recibir un mayor número de puntos, y los jugadores que obtuvieron las mejores posiciones deben recibir una victoria.
Sigue estos pasos para conceder estadísticas a los jugadores cuando terminen la carrera:
Para gestionar esto, añade una nueva función
RecordPlayerFinish()a tu definición de la claseplayer_leaderboards_example. Esta función toma como parámetro el jugador al que se le van a asignar las estadísticas.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=En
RecordPlayerFinish(), obtén la posición de este jugador mediante la obtención del valor actual deCurrentFinishOrderen un nuevointcon el nombrePlayerFinishOrder. A continuación, incrementaCurrentFinishOrderpara que el próximo jugador que finalice no acabe en la misma posición.VerseRecordPlayerFinish(Player:agent):void= PlayerFinishOrder:int = CurrentFinishOrder set CurrentFinishOrder += 1Ahora es el momento de conceder las estadísticas. Para saber cuántos puntos conceder a este jugador, en una expresión
if, indexa en la matrizPointsPerPlacecon elPlayerFinishOrder. A continuación, llama aAddPoints()para conceder al jugador tal cantidad de puntos.Verseset CurrentFinishOrder += 1 if: PointsToAward := PointsPerPlace[PlayerFinishOrder] then: AddPoints(Player, PointsToAward)Si la posición del jugador fue lo suficientemente buena como para obtener una victoria, tienes que registrar una victoria en su tabla de estadísticas. En otra expresión
if, comprueba siPlayerFinishOrderera menor quePlacementRequiredToWin. Si es así, llama aAddWin(), pasando el jugador y concédele una victoria. Tu funciónRecordPlayerFinish()completa debería tener el siguiente aspecto: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)
Cómo esperar a que los jugadores acaben la carrera
Ahora que ya tienes listo el registro de estadísticas, necesitas saber cuándo termina un jugador la carrera para actualizar sus estadísticas. Para ello, escucharás el RaceCompletedEvent() del gestor de carreras. Este evento se activa cada vez que cualquier jugador termina la carrera, por lo que tendrás que escucharlo continuamente en una función asíncrona.
Añade una nueva función
WaitForPlayerToFinishRace()a la definición de tu claseplayer_leaderboards_example. Esta función toma un jugador y espera a que termine la carrera.Verse# When a player finishes the race, record a finish in their stats table. WaitForPlayerToFinishRace(Player:agent)<suspends>:void=En
WaitForPlayerToFinishRace(), en una expresiónrace, inicia dos bucles. El primero esperará a que el jugador termine la carrera, y el otro se encargará de lo que ocurre si un jugador abandona la sesión antes de terminar. Si un jugador se va, no querrás que el bucle continúe para siempre, por lo que necesitas una forma de salir de él en esa situación.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:En el primer bucle, espera el
RaceManager.RaceCompletedEventy almacena el resultado en una variable con el nombreFinishingPlayer. Dado que este evento se activa cada vez que cualquier jugador termina la carrera, debes asegurarte de que el jugador almacenado es el que estabas monitorizando. Compara elFinishingPlayercon el jugador que está monitorizando este bucle. Si los dos son iguales, pasa el jugador aRecordPlayerFinish()y sal del bucle.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) breakEn el segundo bucle, espera el evento de espacio de juego
PlayerRemovedEvent(). Igual que antes, obtén el jugador que acaba de irse y almacénalo en la variableLeavingPlayer. Si el jugador que acaba de irse es el jugador que bucle está esperando, sal del bucle. Tu funciónWaitForPlayerToFinishRace()completa debería tener el siguiente aspecto: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)
Cómo unirlo todo
Una vez configuradas las funciones, es hora de vincularlas a tus dispositivos y ¡a correr!
Sigue estos pasos para vincular tu lógica a tus dispositivos:
En
OnBegin(), obtén todos los jugadores del espacio de juego medianteGetPlayers(). Pasa esta matriz aInitializeAllPlayerStats()para establecer lasplayer_stats_tablesde cada uno.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)Llama a
UpdateStatsBillboards(), pasando las matricesPlayersyLeaderboardspara actualizar las vallas publicitarias dentro del nivel con los datos actuales de cada jugador. A continuación, llama aUpdatePlayerReferences()para actualizar las referencias del nivel para que coincidan con los jugadores. Por último, en una expresiónfor, genera una funciónWaitForPlayerToFinishRace()para cada jugador. Tu funciónOnBegin()completa debería tener el siguiente aspecto: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.Guarda el código y compílalo.
Arrastra el dispositivo player_leaderboards_example a tu nivel. Asigna tus referencias de jugador a la matriz PlayerReferences y ten en cuenta el orden. El dispositivo del primer índice debe corresponder a la referencia del mejor jugador, el segundo índice al segundo mejor jugador y así sucesivamente. Haz lo mismo con las tablas de clasificación y asegúrate de mantenerlas alineadas con los dispositivos de referencia del jugador. No olvides asignar también tu dispositivo Gestor de carreras.
Cómo probar tus marcadores persistentes
Puedes probar tus datos de persistencia en una sesión de edición, pero estos datos se reiniciarán cuando cierres y vuelvas a comenzar la sesión. Para que tus datos persistan entre sesiones, tendrás que iniciar una sesión de prueba de juego y cambiar ciertos ajustes en la Configuración de la isla. Para obtener más información sobre cómo configurar la isla para probar datos persistentes tanto en sesiones de edición como de prueba de juego, consulta Cómo realizar pruebas con datos persistentes y cambia ciertos ajustes en la configuración de tu isla. Para obtener más información sobre cómo configurar la isla para probar datos persistentes tanto en sesiones de edición como de prueba de juego, consulta Cómo realizar pruebas con datos persistentes.
Después de configurar la sesión, cuando pruebes el nivel, los jugadores que terminen la carrera deberían recibir puntos en función de su posición. Se les debería conceder una victoria si su posición es lo suficientemente buena, y estas estadísticas deberían persistir en todas las sesiones de juego. Deben ordenarse los jugadores y sus estadísticas para que aparezca en primer lugar el jugador que tenga más puntos.
Por tu cuenta
Al completar esta guía, has aprendido a crear marcadores que muestren las estadísticas persistentes de los jugadores en el nivel. También has aprendido a clasificar y actualizar dichos marcadores, para que todo el mundo sepa quiénes son los mejores. Intenta adaptar este tutorial a tus propias experiencias, ¡y lúcete!
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.