Crea tu propia tabla de clasificación en el juego en Verse

Este tutorial se basa en los conceptos de Estadísticas persistentes de jugador, así que primero consúltalos.

Las tablas de clasificación son un elemento básico de los juegos competitivos, porque les permiten a los jugadores mostrar sus habilidades y dar a conocer su nombre. Además, les ayudan a saber cuánto avanzaron y les alientan a seguir regresando para que se vean alcanzando la cima.

La persistencia de Verse brinda la herramienta que te permite compilar estas tablas de clasificación y añadir esa naturaleza competitiva a tu experiencia. En el tutorial de estadísticas persistentes de jugador, ya viste cómo rastrear los datos persistentes entre las sesiones de juego y cómo modificar y actualizar esos datos según los diferentes eventos. Ahora aplicarás esos conocimientos para aprender a crear tablas de clasificación locales completas, clasificar las estadísticas de jugador y ponerlo todo en un juego de carreras.

Funciones usadas del lenguaje Verse

• Clase: en este ejemplo, se crea una clase persistente de Verse que rastrea un grupo de estadísticas para un jugador.

• Constructor: un constructor es una función especial que crea una instancia de la clase a la que está asociado.

• weak_map: un weak_map es un simple mapa sobre el que no se puede iterar. Los datos persistentes de Verse deben almacenarse en la variable weak_map.

Configuración del nivel

En este ejemplo, se utilizan la utilería y los dispositivos que aparecen a continuación:

• 3 x dispositivo de cartelera: se mostrarán las estadísticas de tiempo de vida de cada jugador, y podrás ordenarlas en función de los puntos acumulados de vida para mostrar a los mejores jugadores de la sala.

• 3 x dispositivo de referencia de los jugadores: junto con las carteleras, las referencias de los jugadores le pondrán cara al nombre de tus mejores jugadores para que los demás sepan a quién vigilar durante el juego.

• 3 x dispositivo de punto de control: estos son los puntos de control por los que pasan los jugadores para completar la carrera.

• 1 x dispositivo administrador de carreras: este dispositivo registra cuándo los jugadores empiezan y terminan la carrera, además de darles puntos según la posición en la que terminan.

• 1 x dispositivo generador de camionetas: este dispositivo genera el vehículo que usarás durante la carrera, aunque puedes cambiarlo por cualquier otro que se adapte a tu experiencia.

Para configurar tu nivel, sigue estos pasos:

Carteleras y referencias de jugador

Para mostrar las estadísticas de jugador, usarás una combinación de carteleras y referencias de jugador. Cada cartelera indicará las estadísticas de tiempo de vida de un jugador, mientras que la referencia de jugador mostrará una representación visual de ese jugador. Para añadir estos elementos, sigue estos pasos:

1. Añade tres dispositivos de referencia de jugador a tu nivel y colócalos uno al lado del otro.

2. Para cada referencia de jugador, selecciónalo en el esquematizador. En el panel de detalles, en Opciones de usuario, establece un color personalizado con el color que quieras que represente a los tres mejores jugadores en la sala. En este ejemplo, se usan los colores dorado, plateado y bronce.

   

3. Añade tres dispositivos de cartelera a tu nivel y colócalos frente a cada referencia de jugador. Cuando empiece la partida, los actualizarás con las estadísticas de cada jugador utilizando Verse.

Puntos de control, camioneta y administrador de carreras

Dado que se trata de una carrera, necesitarás algo con lo que competir. Además, durante la partida, necesitarás puntos de control para pasar y un administrador de carreras que la dirija. Para añadir estos elementos, sigue estos pasos:

1. Añade tres dispositivos de puntos de control de carrera a tu nivel. Colócalos en el orden en el que quieras que los jugadores pasen por ellos. En el esquematizador, asegúrate de que el número de puntos de control coincida con el orden en el que los jugadores pasan por cada punto de control.

   

2. Añade un dispositivo administrador de carreras a tu nivel. Este dispositivo se encargará de realizar la carrera y dirigir a los jugadores hacia los puntos de control. Más tarde, escucharás el RaceCompletedEvent() de este dispositivo para saber cuándo un jugador termina la carrera.

3. Añade un dispositivo generador de camionetas a tu nivel. Si bien es opcional tener un vehículo, en esta guía, se usa una camioneta para que se ajuste a la plantilla de circuito y para que los jugadores conduzcan un vehículo.

Cómo modificar la tabla de estadísticas

En este ejemplo, se usa una versión modificada del archivo player_stats_table de Estadísticas persistentes de jugador. Tendrá un aspecto similar al archivo de ese ejemplo, pero con algunas grandes diferencias que cambian la implementación.

Sigue los pasos que se indican a continuación para crear la tabla de estadísticas de jugador:

1. En tu clase player_stats_table, haz lo siguiente:

   1. Elimina la estadística de derrotas.

   2. Cambia la estadística de puntuación a puntos.

      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. En tu archivo, modifica la función de constructor MakePlayerStatsTable() para mostrar 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.Wins

   Copy full snippet(5 lines long)

3. Añade una nueva estructura player_and_stats a tu archivo player_stats_table.verse. Esta estructura contiene una referencia a un jugador y a su clase player_stats_table que te permite usar ambos datos en funciones sin necesidad de recuperarlos a cada rato. Tu estructura player_and_stats completa debería verse de la siguiente manera:

   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)

Cómo administrar las estadísticas

Al igual que en Estadísticas persistentes de jugador, utilizarás un administrador de archivo para gestionar y registrar los cambios que se generan en las estadísticas de los jugadores.

Sigue los pasos que aparecen a continuación para compilar el archivo player_stats_manager que se modificó.

1. Modifica la firma de las funciones de InitializeAllPlayers() y InitializePlayer() a InitializeAllPlayerStats() y InitializePlayerStat(). Estos nombres reflejan mejor su relación con la función GetPlayerStat(). La función actualizada debería verse así:

   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. Modifica la firma de las funciones de AddScore() a AddPoints(). Luego, elimina la función AddLosses(), dado que tu player_stats_table ya no tiene ese valor. Tu archivo player_stats_manager completo debería verse de la siguiente manera:

   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)

Cómo crear tablas de clasificación de jugador

Para mostrar los datos de los jugadores en tus tablas de clasificación, necesitarás algunas cosas. En primer lugar, necesitas una forma de actualizar el texto de las carteleras y 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 se destaquen más en tu tabla de clasificación. Dado que estas funciones tienen un objetivo similar de modificar los dispositivos en el nivel, puedes agrupar las funciones en un archivo común.

Sigue los pasos que se indican a continuación para crear funciones que actualicen tus dispositivos en el nivel:

1. Crea un nuevo archivo de Verse llamado player_leaderboards.verse. Este archivo almacenará las funciones comunes a la actualización de tus tablas de clasificación en el nivel.

2. Para el texto de la cartelera, utilizarás un mensaje al que puedes pasar argumentos. Crea un nuevo mensaje llamado StatsMessage que toma un CurrentPlayer, puntos y victorias, todos de tipo message, y devuelve el texto combinado como un mensaje.

   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. Añade tres variables message adicionales, una para cada una de las entradas de StatsMessage. El mensaje PlayerText toma un agente, el mensaje PointsText toma los puntos de ese agente, y el mensaje WinsText toma las victorias de ese agente. El StatsMessage construirá un mensaje a partir de todos ellos para mostrar claramente 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"

   Copy full snippet(6 lines long)

4. Para actualizar una cartelera, deberás llamar a la función UpdateStatsBillboard() del tutorial Estadísticas persistentes de jugador. Dado que esta función se define en un archivo independiente del dispositivo de Verse, es necesario añadir StatsBillboard como argumento adicional para especificar qué cartelera se va a actualizar.

   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. Primero, obtén las estadísticas del jugador pasado como argumento usando GetPlayerStats[]. No necesitas una referencia a player_stats_manager, puesto que ya no es una clase separada. Luego, construye un nuevo StatsMessage con el jugador y los puntos y las victorias de su CurrentPlayerStats. Por último, llama a SetText() en el StatsBillboard para actualizar el texto de la cartelera en el nivel. La función UpdateStatsBillboard() completa debería verse así:

   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)

Cómo clasificar y mostrar al mejor jugador

Antes de continuar, es importante analizar cómo deseas ordenar estas carteleras. ¿Quieres que el jugador con más puntos quede primero o que sea el jugador con más victorias? ¿O quieres ordenar por diferentes estadísticas? Necesitas un método para manejar todo esto, y un algoritmo de clasificación es la respuesta. Al utilizar un algoritmo de clasificación y una función de comparación, puedes especificar según qué criterios quieres ordenar. A continuación, puedes ordenar tus carteleras y referencias de jugadores para mostrar los mejores jugadores de tu experiencia. En este ejemplo, se utiliza el algoritmo de ordenamiento por mezcla, pero puedes implementar el tuyo propio.

Sigue los pasos que se indican a continuación para añadir comparaciones y clasificaciones a tus carteleras, y termina de actualizar los dispositivos de tu nivel.

1. De vuelta en tu archivo player_stats_table, vas a definir funciones de comparación para cada una de tus estadísticas. Cada una de ellas toma una estructura de player_and_stats izquierda y derecha, y las 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, al avisarte que izquierda es menor que derecha. Añade una nueva función llamada MorePointsComparison() a tu archivo player_stats_table.verse. Esta función comprueba si Left.Points es mayor que Right.Points y, en caso contrario, falla. Si tiene éxito, devuelve Left`.

   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. Copia esta función tres veces: una para comparar puntuaciones bajas y dos para comparar victorias. Las funciones de comparación tienen que verse de la siguiente manera:

   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. Añade el algoritmo de ordenamiento por mezcla. Puedes colocarlo en un archivo o módulo por separado y probar el algoritmo en el archivo de prueba suministrado.

4. Regresa a player_leaderboards y añade una función UpdateStatsBillboards() nueva. Esta función toma una matriz de agentes y una matriz de carteleras, las ordena y llama a la función UpdateStatsBillboard() para actualizar cada cartelera 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=

   Copy full snippet(3 lines long)

5. En UpdateStatsBillboards(), inicializa una nueva variable de matriz de player_and_stats denominada PlayerAndStatsArray. Establece esto igual al resultado de una expresión for. En esa expresión for, para cada agente, obtén el jugador para ese agente y recupera su player_stats_table con GetPlayerStats[]. Luego, devuelve una estructura de player_and_stats creada a partir del jugador y su tabla de estadí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 ordenar tu PlayerAndStatsArray, inicializa una variable SortedPlayersAndStats nueva en el resultado de llamar a MergeSort(), y pasa la matriz y la MorePointsComparison. Después de ordenar en una expresión for, itera por medio de cada elemento en SortedPlayerAndStats y almacena el índice de elemento en una variable PlayerIndex. Utiliza PlayerIndex para indexar en la matriz StatsBillboards; luego, llama a UpdateStatsBillboard pasando el jugador y la cartelera que se deben actualizar. La función UpdateStatsBillboards() completa debería verse así:

   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 actualizar tus referencias de jugador, vas a usar una función muy similar denominada UpdatePlayerReferences(). Esta función toma una matriz de player_reference_device en vez de carteleras, y en lugar de llamar a UpdateStatsBillboard() al final, llama a Register() en el dispositivo de referencia de jugador para cada jugador. Copia el código de UpdateStatsBillboard() en una función UpdatePlayerReferences() nueva con los cambios anteriores. La función UpdatePlayerReferences() completa debería verse así:

   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)

Tablas de clasificación de jugadores en tu nivel

Ya tienes todo listo. Ahora es momento de mostrar a tus jugadores. Crearás un dispositivo para otorgar puntos a los jugadores cuando interactúen con el botón, y ordenarás las carteleras y las referencias de jugador para que los mejores jugadores queden en el centro de atención. Sigue los pasos a continuación para crear un dispositivo de Verse y probar las tablas de clasificación en tu nivel:

1. Crea un nuevo dispositivo de Verse llamado player_leaderboards_example. Consulta Cómo crear tu propio dispositivo con Verse para conocer los pasos.

2. 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 jugador denominada PlayerReferences. Estos dispositivos proporcionan representaciones visuales de cada jugador en la carrera.

     Verse

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

     Copy full snippet(3 lines long)

   • Una matriz editable de dispositivos de cartelera denominada Leaderboards. Estos dispositivos muestran las estadísticas de cada jugador en una cartelera en el nivel.

     Verse

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

     Copy full snippet(3 lines long)

   • Un dispositivo administrador de carreras editable denominado RaceManager. Te suscribirás a eventos del administrador de carreras para saber cuándo termina la carrera un jugador.

     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)

   • Un entero editable denominado PlacementRequiredForWin. Se trata de la posición que tiene que ocupar un jugador para recibir una victoria.

     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)

   • Una matriz editable de enteros denominada PointsPerPlace. Se trata de la cantidad de puntos que cada jugador gana de acuerdo con 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}
     

     Copy full snippet(5 lines long)

   • Una variable entera denominada CurrentFinishOrder. Se trata de la posición del jugador que terminó 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
     

     Copy full snippet(3 lines long)

Cómo otorgar estadísticas según la posición

Cuando un jugador termina la carrera, deseas actualizar sus estadísticas en función de su posición. Los jugadores que tienen una buena posición reciben una mayor cantidad de puntos, y los que ocuparon las mejores posiciones deben recibir una victoria.

Sigue estos pasos para otorgar estadísticas a los jugadores cuando terminen la carrera:

1. Para manejar esto, añade una función RecordPlayerFinish() nueva a la definición de la clase player_leaderboards_example. Esta función toma como parámetro al jugador a quien se otorgarán 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=
   

   Copy full snippet(3 lines long)

2. En RecordPlayerFinish(), puedes obtener la posición de este jugador si obtienes el valor actual de CurrentFinishOrder en una variable int nueva denominada PlayerFinishOrder. Luego, aumenta el valor de CurrentFinishOrder para que el siguiente jugador que termine no quede en el mismo lugar.

   Verse

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

   Copy full snippet(3 lines long)

3. Ahora tienes que otorgar estadísticas. Para saber cuántos puntos debes otorgar a este jugador, en una expresión if, indexa en la matriz PointsPerPlace mediante PlayerFinishOrder. Después, llama a la función AddPoints() para otorgar esa cantidad de puntos a ese jugador.

   Verse

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

   Copy full snippet(5 lines long)

4. Si la posición del jugador fue lo suficientemente buena para recibir una victoria, tienes que registrar una victoria en su tabla de estadísticas. En otra expresión if, comprueba si el valor de PlayerFinishOrder fue menor que el de PlacementRequiredToWin. Si es así, llama a AddWin(), pasando el jugador y una victoria para premiarlo. La función RecordPlayerFinish() completa debería verse así:

   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)

Cómo esperar a que los jugadores finalicen la carrera

Ahora que ya tienes listo el registro de estadísticas, tienes que saber cuándo un jugador completa la carrera para actualizar sus estadísticas. Para hacer esto, escucharás el RaceCompletedEvent() del administrador de carreras. Este evento se activa cada vez que cualquier jugador termina la carrera, de modo que tendrás que escucharlo de forma continua en una función asincrónica.

1. Añade una función WaitForPlayerToFinishRace() nueva a la definición de la clase player_leaderboards_example. Esta función toma a 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=
   

   Copy full snippet(2 lines long)

2. En WaitForPlayerToFinishRace(), en una expresión race, inicia dos bucles. El primer bucle esperará a que el jugador termine la carrera y el segundo se encargará de lo que sucede si un jugador abandona la sesión antes de terminar. Si un jugador abandona, no es conveniente que el bucle se siga ejecutando para siempre, así que necesitas una manera de liberarte 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:
   

   Copy full snippet(7 lines long)

3. En el primer bucle, aguarda a RaceManager.RaceCompletedEvent y almacena el resultado en una variable denominada FinishingPlayer. Debido a que este evento se activa cada vez que cualquier jugador termina la carrera, tienes que asegurarte de que el jugador que almacenaste sea el jugador que estabas supervisando. Compara el FinishingPlayer con el jugador que este bucle supervisa. Si los dos son iguales, pasa el jugador a RecordPlayerFinish() y rompe el 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)
                break
   

   Copy full snippet(8 lines long)

4. En el segundo bucle, aguarda al evento de espacio de juego PlayerRemovedEvent(). Como antes, obtén el jugador que acaba de irse y almacénalo en una variable LeavingPlayer. Si el jugador que acaba de irse es el jugador que este bucle está esperando, rompe el bucle. La función WaitForPlayerToFinishRace() completa debería verse así:

   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)

Integración

Una vez que tienes las funciones configuradas, vincúlalas a los dispositivos y ¡a correr!

Sigue estos pasos para vincular la lógica a los dispositivos:

1. En OnBegin(), reúne a todos los jugadores en el espacio de juego con la función GetPlayers(). Pasa esta matriz a InitializeAllPlayerStats() a fin de configurar player_stats_tables para cada uno de ellos.

   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. Llama a la función UpdateStatsBillboards(), pasando las matrices de jugadores y tablas de clasificación para actualizar las carteleras en el nivel con los datos actuales de cada jugador. Luego, llama a UpdatePlayerReferences() para actualizar las referencias en el nivel a fin de que coincidan con los jugadores. Por último, en una expresión for, genera una función WaitForPlayerToFinishRace() para cada jugador. La función OnBegin() completa debería verse así:

   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. Guarda tu código y compílalo.

Arrastra el dispositivo player_leaderboards_example hacia tu nivel. Asigna las referencias de jugador a la matriz PlayerReferences teniendo en cuenta el orden. El dispositivo del primer índice debe corresponder con la referencia de jugador del mejor jugador, el segundo índice con el segundo mejor jugador y así sucesivamente. Haz lo mismo para las tablas de clasificación; asegúrate de mantenerlas alineadas con los dispositivos de referencia de jugador. No olvides asignar también el dispositivo administrador de carreras.

Cómo poner a prueba las tablas de clasificación persistentes

Puedes probar los datos de persistencia en una sesión de edición, pero estos datos se restablecerán cuando salgas de la sesión y la vuelvas a iniciar. Para que los datos persistan en todas las sesiones, tendrás que iniciar una sesión de prueba de juego y cambiar cierta configuración en los ajustes de la isla. Para obtener información sobre cómo configurar tu isla a fin de probar los datos persistentes en las sesiones de edición y de prueba de juego, consulta Cómo realizar pruebas con datos persistentes y cambia algunos valores de la configuración de tu isla. Para obtener información sobre cómo configurar tu isla a fin de probar los datos persistentes en las sesiones de edición y de prueba de juego, consulta Cómo realizar pruebas con datos persistentes.

Después de configurar la sesión, cuando realizas la prueba de juego del nivel, los jugadores que terminan la carrera deben recibir puntos de acuerdo con su posición. Deben recibir una victoria si su posición es lo suficientemente buena, y estas estadísticas deben persistir en todas las sesiones de juego. Los jugadores y sus estadísticas deben aparecer ordenados: el jugador con mayor cantidad de puntos tiene que aparecer en primer lugar.

Hazlo por tu cuenta

Al completar esta guía, aprendiste cómo crear tablas de clasificación que muestren estadísticas de jugador persistentes en tu nivel. También aprendiste cómo ordenar y actualizar estas tablas de clasificación, para que todos sepan cuáles son los mejores jugadores. Intenta adaptar este tutorial a tus propias experiencias, y ve a mostrar lo mejor de lo mejor.

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.