Crea tu propio marcador en el juego en Verse

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:

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

2. 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.

   

3. 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:

1. 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.

   

2. 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.

3. 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:

1. En la clase player_stats_table:

   1. Elimina la estadística Losses.

   2. Cambia la estadística Score a Points.

      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. 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.Wins

   Copy full snippet(5 lines long)

3. Añade una nueva struct player_and_stats a tu archivo player_stats_table.verse. Esta struct contiene una referencia a un player y a su clase player_stats_table para que puedas utilizar ambos datos en funciones sin necesidad de recuperarlos repetidamente. Tu struct player_and_stats completa 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

   Copy full snippet(4 lines long)

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.

1. Modifica la firma de las funciones InitializeAllPlayers() e InitializePlayer() por InitializeAllPlayerStats() e InitializePlayerStat(). Estos nombres reflejan mejor su relación con la función GetPlayerStat(). 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{}
   
   Expand code Copy full snippet(12 lines long)

2. Modifica la firma de la función AddScore() a AddPoints(). A continuación, elimina la función AddLosses(), ya que tu player_stats_table ya no contiene ese valor. Tu archivo player_stats_manager deberí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=
   
   Expand code Copy full snippet(55 lines long)

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:

1. 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.

2. Para el texto de la valla publicitaria, utilizarás un mensaje al que puedas pasar argumentos. Crea un nuevo mensaje con el nombre StatsMessage que tome CurrentPlayer, Points y Wins, todos de tipo message y devuelva el texto combinado como un 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. Añade tres variables message más, una para cada una de las entradas de StatsMessage. El mensaje PlayerText toma un Agent, el mensaje PointsText toma los puntos de ese agente y el mensaje WinsText toma las victorias de ese agente. StatsMessage creará 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"

   Copy full snippet(6 lines long)

4. 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ñadir StatsBillboard como 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=

   Copy full snippet(2 lines long)

5. Primero, obtén las estadísticas del jugador pasado como argumento utilizando GetPlayerStats[]. No necesitas una referencia a player_stats_manager porque ya no es una clase independiente. A continuación, construye un nuevo StatsMessage con el jugador y los Points y Wins de sus CurrentPlayerStats. Por último, llama a SetText() en StatsBillboard para actualizar el texto de la valla publicitaria a nivel interno. Tu función UpdateStatsBillboard() 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)

   Copy full snippet(10 lines long)

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.

1. 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 struct player_and_stats Left y Right, 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 que Left es menor que Right. Añade una nueva función con el nombre MorePointsComparison() a tu archivo player_stats_table.verse. Esta función comprueba si Left.Points es mayor que Right.Points, y falla si no es así. 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 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
            Left
   
   
   Expand code Copy full snippet(19 lines long)

3. Añ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.

4. De vuelta a player_leaderboards, añade una nueva función UpdateStatsBillboards(). Esta función toma una matriz de agentes y una matriz de vallas publicitarias, las ordena y llama a UpdateStatsBillboard() 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=

   Copy full snippet(3 lines long)

5. En UpdateStatsBillboards(), inicializa una nueva variable de matriz de player_and_stats con el nombre PlayerAndStatsArray. Especifica que es igual al resultado de una expresión for. En esa expresión for, para cada agent, obtén el player de ese agent y recupera su player_stats_table mediante GetPlayerStats[]. A continuación, devuelve una struct player_and_stats construida a partir del player 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 nueva variable SortedPlayersAndStats para el resultado de llamar a MergeSort() y pasar la matriz y MorePointsComparison. Después de ordenar en una expresión for, itera por cada elemento en SortedPlayerAndStats y almacena el índice del elemento en una variable PlayerIndex. Utiliza PlayerIndex para indexarlo en la matriz StatsBillboards y, a continuación, llama a UpdateStatsBillboard pasando el jugador y la valla publicitaria que deseas actualizar. Tu función UpdateStatsBillboards() 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:
   
   Expand code Copy full snippet(24 lines long)

7. 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 de player_reference_device en vez de vallas publicitarias y, en vez de llamar a UpdateStatsBillboard() al final, llama a Register() en el dispositivo de referencias del jugador de cada jugador. Copia tu código de UpdateStatsBillboard() en una nueva función UpdatePlayerReferences() con los cambios anteriores. Tu función UpdatePlayerReferences() 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:
   
   Expand code Copy full snippet(25 lines long)

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:

1. 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.

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

     Copy full snippet(3 lines long)

   • 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{}
     

     Copy full snippet(3 lines long)

   • 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{}
     

     Copy full snippet(3 lines long)

   • 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 = 1
     

     Copy full snippet(3 lines long)

   • Una 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}
     

     Copy full snippet(5 lines long)

   • 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
     

     Copy full snippet(3 lines long)

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:

1. Para gestionar esto, añade una nueva función RecordPlayerFinish() a tu definición de la clase player_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=
   

   Copy full snippet(3 lines long)

2. En RecordPlayerFinish(), obtén la posición de este jugador mediante la obtención del valor actual de CurrentFinishOrder en un nuevo int con el nombre PlayerFinishOrder. A continuación, incrementa CurrentFinishOrder para que el próximo jugador que finalice no acabe en la misma posición.

   Verse

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

   Copy full snippet(3 lines long)

3. Ahora 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 matriz PointsPerPlace con el PlayerFinishOrder. A continuación, llama a AddPoints() para conceder al jugador tal cantidad de puntos.

   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 como para obtener una victoria, tienes que registrar una victoria en su tabla de estadísticas. En otra expresión if, comprueba si PlayerFinishOrder era menor que PlacementRequiredToWin. Si es así, llama a AddWin(), pasando el jugador y concédele una victoria. Tu función RecordPlayerFinish() 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)
   
   
   Expand code Copy full snippet(16 lines long)

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.

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

   Copy full snippet(2 lines long)

2. En WaitForPlayerToFinishRace(), en una expresión race, 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:
   

   Copy full snippet(7 lines long)

3. En el primer bucle, espera el RaceManager.RaceCompletedEvent y almacena el resultado en una variable con el nombre FinishingPlayer. 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 el FinishingPlayer con el jugador que está monitorizando este bucle. Si los dos son iguales, pasa el jugador a RecordPlayerFinish() 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)
                break
   

   Copy full snippet(8 lines long)

4. En 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 variable LeavingPlayer. Si el jugador que acaba de irse es el jugador que bucle está esperando, sal del bucle. Tu función WaitForPlayerToFinishRace() 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)
   
   Expand code Copy full snippet(19 lines long)

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:

1. En OnBegin(), obtén todos los jugadores del espacio de juego mediante GetPlayers(). Pasa esta matriz a InitializeAllPlayerStats() para establecer las player_stats_tables de 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)

   Copy full snippet(6 lines long)

2. Llama a UpdateStatsBillboards(), pasando las matrices Players y Leaderboards para actualizar las vallas publicitarias dentro del nivel con los datos actuales de cada jugador. A continuación, llama a UpdatePlayerReferences() para actualizar las referencias del nivel para que coincidan con los jugadores. Por último, en una expresión for, genera una función WaitForPlayerToFinishRace() para cada jugador. Tu función OnBegin() 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.
   
   Expand code Copy full snippet(15 lines long)

3. 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.