1. Epic GamesDeveloper
  3. 6. Cómo añadir la secuencia de comandos completa

6. Cómo añadir la secuencia de comandos completa

Utiliza estos dispositivos para personalizar la experiencia de juego en Unreal Editor para Fortnite.

6. Cómo añadir la secuencia de comandos completa

Esta sección incluye el código completo para añadir a los archivos de Verse que has creado.

Código completo

Hay varios archivos de Verse en este proyecto.

  • heartbeat.verse: consulta a continuación el código completo del archivo.

  • base_team.verse: consulta a continuación el código completo del archivo.

  • hunter_team.verse: consulta a continuación el código completo del archivo.

  • prop_team.verse: consulta a continuación el código completo del archivo.

  • round_timer.verse: consulta a continuación el código completo del archivo.

  • waiting_for_more_players.verse: consulta a continuación el código completo del archivo.

heartbeat.verse

using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Fortnite.com/UI }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/UI }
using { /Verse.org/Colors }
using { /Verse.org/Simulation }

log_heart_beat := class(log_channel){}

# Estos mensajes se utilizan para notificar a un agente de elementos con un mensaje (u ocultarlo) cuando necesitan moverse para evitar que su latido se haga visible.
HeartBeatWarningMessage<localizes>(Time:int):message = "Latido en {Time} segundos. ¡Muévete!"
HeartBeatWarningClear<localizes>:message = ""

# Esta clase expone las propiedades editables para el latido al dispositivo prop_hunt.
heart_beat := class<concrete>():
    Logger:log = log{Channel:=log_heart_beat}

    @editable # Número de segundos antes de que un agente de elementos deba moverse antes de que el latido revele su posición.
    MoveTime:float = 15.0

    @editable # Segundos restantes antes de que aparezca el aviso de latido. No debe ser > que HeartBeatTimer.
    WarningTime:float = 5.0

    @editable # Matriz de dispositivos de efectos visuales de latido. Hay una por jugador.
    AgentVFX:[]heartbeat_vfx = array{}

    @editable # Dispositivo reproductor de audio que se utiliza para reproducir los efectos de sonido (SFX) de latidos.
    SFXPlayer:radio_device = radio_device{}

    # Este mapa asocia una interfaz de usuario para mostrar el aviso de latido a cada agente de elementos.
    var WarningUI:[agent]heartbeat_warning_ui = map{}

    # Realiza un seguimiento de cuántos jugadores tienen un latido activo para que podamos gestionar el dispositivo de efectos de sonido.
    var NumberOfHeartBeats:int = 0

    # Configura la interfaz de usuario de latidos para el agente.
    SetUpUI(PropAgent:agent):void =
        if:
            not WarningUI[PropAgent]
            AsPlayer := player[PropAgent]
            PlayerUI := GetPlayerUI[AsPlayer]
        then:
            UIData:heartbeat_warning_ui = heartbeat_warning_ui{}
            UIData.CreateCanvas()
            PlayerUI.AddWidget(UIData.Canvas, player_ui_slot{ZOrder := 1})
            if (set WarningUI[PropAgent] = UIData) {}

    # Activa los efectos visuales y de sonido de latido para el jugador especificado.
    Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
        if:
            # Obtén el personaje que se utiliza para encontrar la posición del agente de elementos en la escena.
            Character := PropAgent.GetFortCharacter[]
        then:

            # Configura la posición de los efectos visuales de latido a la posición del agente de elementos.
            HeartBeatVFXData.Activate(Character.GetTransform())

            # Incrementa el número de latidos, y si este es el primer latido que se reproduce, tenemos que reproducir el audio para que comience.
            set NumberOfHeartBeats += 1
            if (NumberOfHeartBeats = 1) then SFXPlayer.Play()

            # Registra el agente de elementos en el dispositivo reproductor de audio para que el audio del latido se reproduzca desde esa posición.
            SFXPlayer.Register(PropAgent)
        else:
            Logger.Print("Character, Index, o HeartBeatVFXData no encontrados. No se puede iniciar el latido.")

    # Borra los efectos visuales y de sonido de latido del agente de elementos especificado.
    Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
        Logger.Print("Desactivando latido.")

        # Desactiva los efectos visuales.
        HeartBeatVFXData.Deactivate()

        # Anula el registro del agente de elementos del dispositivo reproductor de audio; esto provocará que el audio del latido se detenga.
        SFXPlayer.Unregister(PropAgent)

        # Disminuye el contador de latidos. Este contador no debe bajar nunca de 0.
        set NumberOfHeartBeats -= 1
        if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0

    # Borra todos los efectos visuales y de sonido de latido para todos los agentes de elementos.
    DisableAll():void =
        Logger.Print("Desactivando todos los latidos.")

        # Itera por todos los efectos visuales y muévelos a 0,0,0.
        for (HeartBeatVFXDevice : AgentVFX):
            HeartBeatVFXDevice.Deactivate()

        # Anula el registro de todos los jugadores del audio de latidos.
        SFXPlayer.UnregisterAll()

        # Reinicializa el contador de latidos a 0.
        set NumberOfHeartBeats = 0

# La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de interfaz de usuario y el text_block (bloque de texto) por jugador, así como la función para crear un nuevo lienzo de interfaz de usuario de aviso de latido.
heartbeat_warning_ui := class:
    var Canvas:canvas = canvas{}
    var Text:text_block = text_block{}

    # Crea el lienzo de interfaz de usuario para el mensaje de aviso.
    CreateCanvas():void =
        set Text = text_block{DefaultTextColor := NamedColors.White, DefaultShadowColor := NamedColors.Black}
        set Canvas = canvas:
            Slots := array:
                canvas_slot:
                    Anchors := anchors{Minimum := vector2{X := 0.5, Y := 0.75}, Maximum := vector2{X := 0.5, Y := 0.75}}
                    Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
                    Alignment := vector2{X := 0.5, Y := 1.0}
                    SizeToContent := true
                    Widget := Text

# La clase heartbeat_vfx contiene una estructura de datos para rastrear la raíz de los efectos visuales y los objetos vfx_spawner_device por jugador, así como las funciones para fijar los efectos visuales en una posición o reiniciarla.
heartbeat_vfx := class<concrete>:

    @editable # Dispositivo de efectos visuales para cada latido.
    VFXDevice:vfx_spawner_device = vfx_spawner_device{}

    # Este desplazamiento se utiliza para posicionar el latido por encima de la cabeza de un agente de elementos.
    HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}

    # Establece la posición de los efectos visuales de latido y luego los habilita.
    Activate(Transform:transform):void =
        VFXPosition := Transform.Translation + HeartBeatVFXOffset
        if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
            VFXDevice.Enable()
  
    # Desactiva los efectos visuales, ocultando los elementos visuales de latido.
    Deactivate():void =
        VFXDevice.Disable()

base_team.verse

using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Fortnite.com/UI }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /UnrealEngine.com/Temporary/UI }
using { /Verse.org/Colors }
using { /Verse.org/Simulation }

log_team := class(log_channel){}

# Esta clase define los dispositivos necesarios para los diferentes equipos de la experiencia.

# Esta clase es abstracta por lo que no se puede utilizar por sí sola. Tiene que ser heredada por otra clase.
base_team := class<abstract>:
    Logger:log = log{Channel:=log_team}

    @editable # Se utiliza para asignar un jugador al equipo.
    ClassSelector:class_and_team_selector_device = class_and_team_selector_device{}

    @editable # Se utiliza para otorgar puntuación a los agentes del equipo.
    ScoreManager:score_manager_device = score_manager_device{}
  
    @editable # Se utiliza para mostrar el título de la asignación del equipo.
    TeamTitle:hud_message_device = hud_message_device{}
  
    @editable # Se utiliza para mostrar la descripción de la asignación del equipo.
    TeamDescription:hud_message_device = hud_message_device{}
  
    @editable # Se utiliza para suscribirse a eventos eliminados de miembros del equipo (equipo de elementos) o enemigos (equipo de cazadores).
    TeamManager:team_settings_and_inventory_device = team_settings_and_inventory_device{}

    # Esto es una matriz de agentes en el equipo.
    var TeamAgents<private>:[]agent = array{}

    # Este evento recibe una señal cuando la matriz TeamAgents se vacía (indicando el final de la ronda).
    TeamEmptyEvent:event() = event(){}

    # Devuelve la matriz actual de TeamAgents.

    # Esto es necesario porque la matriz TeamAgents es privada, por lo que otras clases no pueden acceder a ella directamente.
    GetAgents()<decides><transacts>:[]agent =
        TeamAgents

    # Devuelve el tamaño de la matriz TeamAgents.

    # Esto requiere una función porque la matriz TeamAgents es privada, por lo que otras clases no pueden acceder a ella directamente.
    Count()<transacts>:int =
        TeamAgents.Length

    # Devuelve un índice en la matriz TeamAgents de un agente; en caso contrario devuelve un error.
    FindOnTeam(Agent:agent)<decides><transacts>: int =
        Index := TeamAgents.Find[Agent]
      
    # Asigna el agente al equipo y notifica al jugador.
    InitializeAgent(Agent:agent):void =
        AddAgentToTeam(Agent)
        ClassSelector.ChangeTeamAndClass(Agent)
        DisplayTeamInformation(Agent)

    # Añade un agente a TeamAgents.
    AddAgentToTeam(AgentToAdd:agent):void =
        if (not FindOnTeam[AgentToAdd]):
            Logger.Print("Añadiendo agente al equipo.")
            set TeamAgents += array{AgentToAdd}

    # Activa los dispositivos Mensaje del HUD para mostrar al jugador en qué equipo está.
    DisplayTeamInformation(Agent:agent):void =
        TeamTitle.Show(Agent)
        TeamDescription.Show(Agent)

    # Cuando un agente abandona la partida, elimínalo de la matriz TeamAgents y comprueba el final de la ronda.
    EliminateAgent(Agent:agent)<suspends>:void =
        Sleep(0.0) # Retrasa 1 tic de juego para asegurarte de la reaparición del jugador antes de proceder.
        RemoveAgentFromTeam(Agent)

    # Elimina un agente de TeamAgents.

    # Si el agente eliminado era el último, emite la señal TeamEmptyEvent.
    RemoveAgentFromTeam(AgentToRemove:agent):void =
        set TeamAgents = TeamAgents.RemoveAllElements(AgentToRemove)
        Logger.Print("Quedan {Count()} agente(s) en el equipo.")
        if (Count() < 1):
            Logger.Print("No quedan agentes en el equipo. Finalizando la ronda.")
            TeamEmptyEvent.Signal()

hunter_team.verse

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

# Hereda de la clase base_team. La clase hunter_team contiene las definiciones de dispositivos y funciones relacionadas con el equipo de cazadores y sus agentes.
hunter_team := class<concrete>(base_team):

    @editable # Se crea un agente cazador en cada ronda por cada X jugadores. Por ejemplo: HunterTeamPerNumberOfPlayers = 5.0 es 1 por cada 5 jugadores. Si los jugadores = 6, se crean 2 agentes cazadores.
    HunterAgentPerNumberOfPlayers:float = 5.0 # Se impone un mínimo de 1.1 para asegurar que se crea al menos 1 agente elemento.

    @editable # Número de segundos antes de que aparezcan los agentes cazadores, dando a los agentes elementos una ventaja para esconderse.
    SpawnDelay:float = 15.0

    @editable # Máximo de puntos base que un agente cazador obtiene por eliminar a un agente elemento. Estos puntos se dividen por el número de agentes elementos restantes.
    MaxEliminationScore:int = 5000

    @editable # Dispositivo cronómetro que se utiliza para dar a los elementos una prórroga para ocultarse.
    WaitTimer:timer_device = timer_device{}

    # Configura el agente como agente cazador.
    InitializeAgent<override>(NewHunterAgent:agent):void =
        Logger.Print("Estableciendo un nuevo agente cazador.")
        (super:)InitializeAgent(NewHunterAgent)

    # Cuando un agente cazador abandona la partida, elimínalo de la matriz HunterAgents y comprueba el final de la ronda.

    # Observa que estamos anulando esta función porque no necesitamos pasar datos adicionales aquí como lo hacemos para el equipo de elementos.
    EliminateAgent<override>(HunterAgent:agent)<suspends>:void =
        Logger.Print("Agente cazador eliminado.")
        (super:)EliminateAgent(HunterAgent)

prop_team.verse

using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Fortnite.com/UI }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /UnrealEngine.com/Temporary/UI }
using { /Verse.org/Colors }
using { /Verse.org/Simulation }

# Este mensaje se utiliza para mostrar el número de elementos restantes a todos los jugadores durante una ronda.
PropAgentsRemainingMessage<localizes>(Count:int):message = "Elementos restantes: {Count}"

# Hereda de la clase base_team. La clase prop_team contiene las definiciones de dispositivos y funciones relacionadas con el equipo de elementos y sus agentes.

# El comportamiento del latido de un agente elemento puede encontrarse especialmente en esta clase.
prop_team := class<concrete>(base_team):

    @editable # Puntuación que un agente elemento recibe por segundo.
    ScorePerSecond:int = 10

    @editable # Distancia mínima que debe moverse un agente elemento para reiniciar el cronómetro de latidos.
    MinimumMoveDistance:float = 100.0

    @editable # Dispositivo cronómetro utilizado para otorgar puntuación a un elemento.
    ScoreTimer:timer_device = timer_device{}

    @editable # Este dispositivo rastreador se utiliza para mostrar los elementos restantes en la pantalla.
    PropsRemainingTracker:tracker_device = tracker_device{}
  
    @editable # Obtén las propiedades de la clase heart_beat.
    HeartBeat:heart_beat = heart_beat{}

    # Configura el agente como agente elemento y asigna la interfaz de usuario de aviso de latido.
    InitializeAgent<override>(NewPropAgent:agent):void =
        Logger.Print("Estableciendo un nuevo agente elemento.")
        (super:)InitializeAgent(NewPropAgent)

    # Cuando el PropScoreTimer se complete, otorga puntos a todos los agentes elemento. PropInstigator es necesario para la suscripción al evento pero no se utiliza.
    OnPropsScore(PropInstigator:?agent):void =
        if (PropAgents := GetAgents[]):
            for (PropAgent : PropAgents):
                ScoreManager.Activate(PropAgent)

    # Cuando un agente elemento sea eliminado o abandone la partida, elimínalo de la matriz PropAgents y comprueba el final de la ronda.

    # Ten en cuenta que esto no es una anulación porque estamos pasando todos los jugadores a la función para actualizar el mensaje de los elementos restantes.
    EliminateAgent<override>(PropAgent:agent)<suspends>:void =
        Logger.Print("Agente de elementos eliminado.")
        (super:)EliminateAgent(PropAgent)

        # Actualiza el número restante de elementos.
        UpdatePropsRemainingTracker()

    # Actualiza el valor del dispositivo rastreador mostrando el número de elementos restantes.
    UpdatePropsRemainingTracker():void =
        PropsRemainingTracker.SetValue(Count())

    # Si el agente de elementos deja de moverse, entonces corre para ver si el agente de elementos se mueve más allá de la MinimumMoveDistance, si se completa el cronómetro de latido o si el agente de elementos es eliminado.
    RunPropGameLoop(PropAgent:agent)<suspends>:void =
        Logger.Print("Iniciando bucle de juego del agente de elementos.")

        # Realiza un bucle eterno por el comportamiento del elemento hasta que el agente de elementos sea eliminado o el jugador abandone la sesión.
        race:
            PropAgent.AwaitNoLongerAProp()
            loop:

                # Espera a que el agente de elementos se mueva menos de la distancia mínima y luego avanza.
                PropAgent.AwaitStopMoving(MinimumMoveDistance)

                # Hasta que el agente elemento se mueva más allá de la distancia mínima, inicia la cuenta atrás hasta el latido y luego reproduce el latido indefinidamente.
                race:
                    PropAgent.AwaitStartMoving(MinimumMoveDistance)
                    block:
                        CountdownTimer(PropAgent)
                        PropAgent.StartHeartbeat()
                Sleep(0.0) # Una vez finalizada la carrera (el agente de elementos se mueve), vuelve a iniciar el bucle.

    # Realiza un bucle hasta que el agente de elementos ya no forme parte de la matriz PropAgents. La eliminación se produce si el agente de elementos es eliminado y convertido en cazador o si el jugador abandona la sesión.
    (PropAgent:agent).AwaitNoLongerAProp()<suspends>:void =
        loop:
            if (not FindOnTeam[PropAgent]):
                Logger.Print("Cancelando el comportamiento del agente de elementos.")
                break
            Sleep(0.0) # Avanza al siguiente tic de juego.

    # Realiza un bucle hasta que el agente se mueve menos de la MinimumDistance.
    (PropAgent:agent).AwaitStopMoving(MinimumDistance:float)<suspends>:void =
        Logger.Print("Comprobando si el agente se ha movido menos de la distancia mínima.")

        # Obtén la posición inicial del agente a partir del personaje del agente en la escena.
        if (Tracked := PropAgent.GetFortCharacter[]):
            var StartPosition:vector3 = Tracked.GetTransform().Translation
            loop:
                Sleep(0.0) # Obtén la posición del agente en el siguiente tic del juego.
                NewPosition := Tracked.GetTransform().Translation

                # Si la distancia de la nueva posición respecto a la posición inicial es menor que MinimumDistance, significa que el agente no se ha movido, por lo que interrumpimos el bucle.
                if (Distance(StartPosition, NewPosition) < MinimumDistance):
                    Logger.Print("El agente se ha movido menos de la distancia mínima.")
                    break

                # En caso contrario, restablecemos StartPosition para asegurarnos de que el jugador se mueve desde la nueva posición.
                else:
                    set StartPosition = NewPosition

    # Realiza un bucle hasta que el agente se mueve más de la MinimumDistance.
    (PropAgent:agent).AwaitStartMoving(MinimumDistance:float)<suspends>:void =
        Logger.Print("Comprobando si el agente se mueve más allá de la distancia mínima.")

        # Obtén la posición inicial del agente a partir del personaje del agente en la escena.
        if (Tracked := PropAgent.GetFortCharacter[]):
            StartPosition:vector3 = Tracked.GetTransform().Translation
            loop:
                Sleep(0.0) # Obtén la posición del agente en el siguiente tic del juego.
                NewPosition := Tracked.GetTransform().Translation

                # Si la distancia de la nueva posición respecto a la posición inicial es mayor o igual que MinimumDistance, significa que el agente se ha movido, por lo que interrumpimos el bucle.
                if (Distance(StartPosition, NewPosition) >= MinimumDistance):
                    Logger.Print("El agente se ha movido más o igual que la distancia mínima.")
                    break

    # Se retrasa hasta que se inicie HeartBeatWarningTime. A continuación, realiza una cuenta atrás según HeartBeatWarningTime y establece el texto de la cuenta atrás. Borra el texto cuando se aplaza.
    CountdownTimer(PropAgent:agent)<suspends>:void =
        Logger.Print("Iniciando cuenta atrás de latido.")
        if (UIData := HeartBeat.WarningUI[PropAgent]):
            Sleep(HeartBeat.MoveTime - HeartBeat.WarningTime) # Permanece inactivo el tiempo necesario antes de que aparezca el aviso.
            Logger.Print("Iniciando aviso de latido.")
            var WarningTimeRemaining:int = 0
            if (set WarningTimeRemaining = Ceil[HeartBeat.WarningTime]) {}

            # Cuando la función se completa o esta se cancela, como por ejemplo si se pierde una carrera, ocurre un aplazamiento.

            # En este caso, el texto del aviso se borra cuando termina la cuenta atrás o si el agente de elementos se mueve antes de que termine la cuenta atrás.
            defer:
                UIData.Text.SetText(HeartBeatWarningClear)

            # Establece el texto de aviso en el tiempo restante, espera un segundo y luego reduce el tiempo restante. Si se completa la cuenta atrás, interrumpe el bucle.
            loop:
                Logger.Print("Latido en {WarningTimeRemaining} segundos.")
                UIData.Text.SetText(HeartBeatWarningMessage(WarningTimeRemaining))
                Sleep(1.0)
                set WarningTimeRemaining -= 1
                if (WarningTimeRemaining <= 0):
                    break
        else:
            Logger.Print("UIData no encontrados.")
          
    # Enciende los efectos visuales y de sonido de latidos. Espera infinitamente hasta que se aplaza y luego desactiva los efectos visuales y de sonido de latidos.
    (PropAgent:agent).StartHeartbeat()<suspends>:void =
        Logger.Print("Generando latido.")

        # Guarda los datos del latido para que podamos pasarlos en el aplazamiento más adelante, después de que el PropAgent sea destruido o abandone el juego.
        var HeartBeatVFXData:heartbeat_vfx = heartbeat_vfx{}
        if:

            # Obtén el índice del agente elemento en la matriz PropAgents para luego acceder al actor de efectos visuales de latidos correspondiente.
            Index := FindOnTeam[PropAgent]
            set HeartBeatVFXData = HeartBeat.AgentVFX[Index]
        then:
            HeartBeat.Enable(PropAgent, HeartBeatVFXData)

        # Cuando esta función se cancela porque el agente elemento se mueve, es eliminado o el jugador abandona la sesión, desactiva el latido.
        defer:
            HeartBeat.Disable(PropAgent, HeartBeatVFXData)
        Sleep(Inf) # Permanece inactivo hasta que finalice la carrera.

round_timer.verse

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

log_round_timer_device := class(log_channel){}

# Un entero que permite valores entre los rangos especificados. Este tipo es requerido por player_ui_slot.ZOrder.
round_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}

# Este mensaje se utiliza para imprimir el tiempo restante antes de que termine una ronda.
TimeRemainingMessage<localizes>(Minutes:string, Seconds:string):message = "{Minutes}:{Seconds}"

<#
Esta clase contiene toda la lógica para gestionar el tiempo de la ronda y mostrarlo en la pantalla.
Puedes utilizar este dispositivo con un round_settings_device para finalizar realmente la ronda.

Este dispositivo gestiona el tiempo sin necesidad de utilizar un cronómetro.
Para utilizar esta clase:

    1) Añade el archivo a tu proyecto.

    2) Compila el código de Verse desde el menú Verse de la barra de herramientas.

    3) Arrastra el dispositivo a tu isla desde la carpeta Contenido/Dispositivos del modo Creativo de tu isla en el explorador de contenido.

    4) Incluye la clase waiting_for_more_players en otra secuencia de comandos de Verse con:

        @editable
        RoundTimer:round_timer = round_timer{}

    5) Compila el código de Verse desde el menú Verse de la barra de herramientas.

    6) Conecta el dispositivo que creaste en el paso 3 al dispositivo de Verse.

    7) Inicia el cronómetro de la ronda con el siguiente código de Verse:
        RoundTimer.Start()

    8) Reinicia o detén el cronómetro con las funciones equivalentes.

    9) Espera a que el cronómetro se inicie:
        RoundTimer.AwaitStart()

    10) Espera a que el cronómetro termine con:
        RoundTimer.AwaitEnd()
        Llama a la función EndRound en un round_settings_device para finalizar realmente la ronda de juego.

#>
round_timer := class(creative_device):
    Logger:log = log{Channel:=log_prop_hunt_device}

    @editable # Tiempo que dura una ronda, en minutos.
    RoundTimeInMinutes:float = 5.0

    @editable # Posición horizontal y vertical de la IU del cronómetro en la pantalla. X 0-1 es izquierda-derecha e Y 0-1 es arriba-abajo.
    UIPosition:vector2 = vector2{X:= 0.98, Y:=0.13}

    @editable # Posición horizontal y vertical de la IU del cronómetro en la pantalla. X 0-1 es izquierda-derecha e Y 0-1 es arriba-abajo.
    UIAlignment:vector2 = vector2{X := 1.0, Y := 0.0}

    @editable # ZOrder de la interfaz de usuario comparado con otros elementos de la interfaz de usuario.
    UIZOrder:round_int_clamped = 4

    # Recibe una señal cuando la ronda ha comenzado.
    RoundStarted:event() = event(){}

    # Recibe una señal cuando la ronda está a punto de terminar.
    RoundEndedEvent:event() = event(){}

    # Este mapa asocia un cuadro de texto para mostrar el tiempo a cada jugador.  
    var TimeRemainingTextBlocks:[player]text_block = map{}

    # El tiempo restante antes de que la ronda se complete, en forma de entero.
    var TimeRemainingInSeconds:int = 0

    # Espera hasta que se inicie el cronómetro de la ronda.
    AwaitStart()<suspends>:void =
        RoundStarted.Await()
        Logger.Print("Cronómetro de la ronda iniciado.")
  
    # Se utiliza para iniciar el cronómetro de la ronda.
    Start():void =
        Logger.Print("Iniciando el cronómetro de la ronda.")
        RoundStarted.Signal()
        set TimeRemainingInSeconds = GetRoundTimeInSeconds()
        spawn{ Running() }

    # Reinicia el cronómetro a RoundTime.
    Restart():void =
        Logger.Print("Reniciando el cronómetro de la ronda.")
        set TimeRemainingInSeconds = GetRoundTimeInSeconds()

    # Ejecuta la lógica del cronómetro.
    Running()<suspends>:void =
        Logger.Print("Cronómetro de la ronda en marcha.")
        loop:
            UpdateTimeUI()
            Sleep(1.0)

            # Disminuye TimeRemaining en 1 segundo y comprueba si se ha agotado el tiempo. Si es así, termina la ronda.
            set TimeRemainingInSeconds -= 1
            if (TimeRemainingInSeconds < 0):
                Stop()
                break
        
    # Detiene el cronómetro y finaliza la ronda.
    Stop():void =
        Logger.Print("Cronómetro de la ronda finalizando.")

        # Obtenemos un jugador de los que quedan en la escena para terminar la ronda.
        Players:[]player = GetPlayspace().GetPlayers()
        if (Instigator := Players[0]):
            RoundEndedEvent.Signal()

    # Espera hasta que el cronómetro de la ronda esté a punto de terminar.
    AwaitEnd()<suspends>:void =
        RoundEndedEvent.Await()
        Logger.Print("El cronómetro de la ronda ha terminado.")

    # Acepta un valor de tiempo en minutos y devuelve el valor en segundos.
    GetRoundTimeInSeconds():int =
        var InSeconds:int = 0
        if (set InSeconds = Round[RoundTimeInMinutes * 60.0]) {}
        InSeconds

    # Cuando el cronómetro finalice, actualiza el tiempo restante y comprueba si el tiempo se ha acabado.
    UpdateTimeUI():void =

        # Establece Minutes a TimeRemainingInSeconds/60 sin el restante.
        var Minutes:int = 0
        if (set Minutes = Floor(TimeRemainingInSeconds / 60)) {}

        # Establece Seconds al restante de TimeRemainingInSeconds/60.
        var Seconds:int = 0
        if (set Seconds = Mod[TimeRemainingInSeconds, 60]) {}

        # Convierte Minutes y Seconds a cadenas.
        MinutesAsString := string("{Minutes}")

        # Si Seconds < 10, entonces necesitamos añadir un 0 delante del valor para que se muestre como :0# en lugar de :#.
        SecondsAsString := if (Seconds < 10) then Join(array{string("{0}"),string("{Seconds}")},string()) else string("{Seconds}")

        # Itera por todos los jugadores, comprueba si tienen un TimeRemainingTextBlock, si no, dales uno y a continuación actualiza el texto.
        Players:[]player = GetPlayspace().GetPlayers()
        for (Player : Players):
            var TextBlock:text_block = text_block{}
            if (set TextBlock = TimeRemainingTextBlocks[Player]) {}
            else:
                set TextBlock = SetUpTimeRemainingUI(Player)
            TextBlock.SetText(TimeRemainingMessage(MinutesAsString, SecondsAsString))

    # Acepta un jugador y después añade un lienzo de interfaz de usuario de tiempo de la ronda a su pantalla y almacena su TimeRemainingTextBlock para actualizarlo más tarde.
    SetUpTimeRemainingUI(Player:player):text_block =
        Logger.Print("Añadiendo la interfaz de usuario del cronómetro de la ronda a un jugador.")

        # Este es el text_block que imprime el texto del tiempo restante en la pantalla.
        TextBlock:text_block = text_block:
            DefaultTextColor := NamedColors.White
            DefaultShadowColor := NamedColors.Black
        if (PlayerUI := GetPlayerUI[Player]):
            if (set TimeRemainingTextBlocks[Player] = TextBlock) {}

            # Este es el lienzo que contiene y posiciona el text_block en la pantalla.
            Canvas := canvas:
                Slots := array:
                    canvas_slot:
                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
                        Alignment := UIAlignment
                        SizeToContent := true
                        Widget := TextBlock

            # El lienzo se asigna al jugador.
            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})

        # El text_block se devuelve para que pueda guardarse en el mapa y actualizarse más adelante a medida que transcurre el tiempo.
        return TextBlock

waiting_for_more_players.verse

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

log_waiting_for_more_players_device := class(log_channel){}

# Un entero que permite valores entre los rangos especificados. Este tipo es requerido por player_ui_slot.ZOrder.
waiting_int_clamped := type{_X:int where 0 <= _X, _X <= 2147483647}

# Este mensaje se utiliza para imprimir el número de jugadores necesarios antes de que comience una ronda.
WaitingForMorePlayersMessage<localizes>(Count:int):message = "Esperando a más jugadores: {Count}"

# Esta clase sirve para mostrar la cantidad de jugadores que se necesitan para empezar la ronda.
waiting_for_more_players_ui := class:
    var Canvas:canvas
    var TextBlock:text_block
<#
Esta clase contiene toda la lógica para establecer un número mínimo de jugadores y comprobar si hay suficientes para empezar la ronda.
Para utilizar esta clase:
    1) Añade el archivo a tu proyecto.

    2) Compila el código de Verse desde el menú Verse de la barra de herramientas.

    3) Arrastra el dispositivo a tu isla desde la carpeta Contenido/Dispositivos del modo Creativo de tu isla en el explorador de contenido.

    4) Conecta un dispositivo Cronómetro a la propiedad WaitingForMorePlayersTimer de este dispositivo.

    5) Incluye la clase waiting_for_more_players en otra secuencia de comandos de Verse con:
        @editable
        WaitingForMorePlayers:waiting_for_more_players = waiting_for_more_players{}

    6) Compila el código de Verse desde el menú Verse de la barra de herramientas.

    7) Conecta el dispositivo que creaste en el paso 3 al dispositivo de Verse y la propiedad que expusiste en el paso 6.

    8) Espera las funciones CheckForMinimumNumberOfPlayers pasándole un jugador. Por ejemplo:
        Players = GetPlayspace().GetPlayers()
        CheckForMinimumNumberOfPlayers(Players)

    9) En IslandSettings, establece la cuenta atrás de inicio del juego en 0.0.
#>
waiting_for_more_players := class(creative_device):
    Logger:log = log{Channel:=log_waiting_for_more_players_device}

    @editable # Número mínimo de jugadores necesarios en la partida para que comience una ronda.
    MinimumNumberOfPlayers:int = 2

    @editable # Posición horizontal y vertical de la IU del cronómetro en la pantalla. X 0-1 es izquierda-derecha e Y 0-1 es arriba-abajo.
    UIPosition:vector2 = vector2{X:= 0.5, Y:=0.4}

    @editable # Posición horizontal y vertical de la IU del cronómetro en la pantalla. X 0-1 es izquierda-derecha e Y 0-1 es arriba-abajo.
    UIAlignment:vector2 = vector2{X := 0.5, Y := 0.5}

    @editable # ZOrder de la interfaz de usuario comparado con otros elementos de la interfaz de usuario.
    UIZOrder:waiting_int_clamped = 3

    @editable # Este cronómetro se utiliza para la cuenta atrás hasta el inicio de la ronda después de esperar a que los jugadores se unan a la partida.
    WaitingForMorePlayersTimer:timer_device = timer_device{}
 
   # Este mapa asocia un lienzo de interfaz de usuario para mostrar el número de jugadores necesarios para comenzar una ronda a cada jugador.
    var WaitingForMorePlayersUI:[player]?waiting_for_more_players_ui = map{}
  
  # Comprueba si hay suficientes jugadores para empezar la ronda. Si no es así, espera hasta que el número de jugadores >= MinimumNumberOfPlayers.
    WaitForMinimumNumberOfPlayers(Players:[]player)<suspends>:[]player =
        Logger.Print("Esperando si hay suficientes jugadores para que empiece la ronda.")
        # Voy a crear una nueva variable para poder modificarla a medida que se unan más jugadores y la voy a inicializar con una matriz de jugadores pasados a la función.
        var PlayersWaiting:[]player = Players
        # Si el número de jugadores es inferior al mínimo necesario para comenzar la ronda...
        if (PlayersWaiting.Length < MinimumNumberOfPlayers):
            loop: # Realiza un bucle hasta que el número de jugadores sea mayor o igual que el mínimo necesario.
                Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} jugadores necesarios para que comience la ronda.")
                # Actualiza la interfaz de usuario de espera a más jugadores.
                DisplayWaitingForMorePlayers(PlayersWaiting)
                Sleep(2.0) # Espera a ver si más jugadores se unen a la partida y luego comprueba si hay suficientes jugadores para empezar la ronda.
                set PlayersWaiting = GetPlayspace().GetPlayers()
                if (PlayersWaiting.Length >= MinimumNumberOfPlayers):
                    # Si ya hay suficientes jugadores, borra la interfaz de espera de más jugadores.
                    Logger.Print("{PlayersWaiting.Length}/{MinimumNumberOfPlayers} jugadores en la ronda, preparándose para el comienzo de la ronda.")
                    ClearWaitingForMorePlayers()
                    # A continuación, interrumpe el bucle.
                    break
        # Inicia la cuenta atrás de inicio de ronda, y espera hasta que la cuenta atrás se complete.
        WaitingForMorePlayersTimer.Start()
        WaitingForMorePlayersTimer.SuccessEvent.Await()
        Logger.Print("Iniciando la ronda.")
        # Devuelve la lista de jugadores de la sesión.
        return PlayersWaiting
   
 # Muestra el mensaje de interfaz de usuario "Esperando a más jugadores" para todos los jugadores si aún no tienen uno. Actualiza el contador de jugadores de todos los jugadores.
    DisplayWaitingForMorePlayers(Players:[]player):void =
        PlayersNeededCount := MinimumNumberOfPlayers - Players.Length
        Logger.Print("{Players.Length} jugador(es) en la ronda, esperando a que se una(n) {PlayersNeededCount} jugador(es) más.")
        for (Player : Players):
       
     # Si el jugador tiene una WaitingForMorePlayersUI, obtén el TextBlock y refresca el texto para que muestre el número correcto de jugadores necesarios para empezar la ronda.
            if (UIData := WaitingForMorePlayersUI[Player]?):
                UIData.TextBlock.SetText(WaitingForMorePlayersMessage(PlayersNeededCount))
            # Si no, crea una WaitingForMorePlayersUI para el jugador.
            else:
                SetUpWaitingForMorePlayersUI(Player, PlayersNeededCount)
     
  # Acepta un jugador y player_ui y añade un lienzo de interfaz de usuario de espera a más jugadores a su pantalla.
    SetUpWaitingForMorePlayersUI(Player:player, PlayersNeededCount:int):void =
        Logger.Print("Creando la interfaz de usuario de espera a más jugadores.")
        if (PlayerUI := GetPlayerUI[Player]):
            # Este es el text_block que imprime en pantalla el texto de espera a más jugadores.
            TextBlock:text_block = text_block:
                DefaultText := WaitingForMorePlayersMessage(PlayersNeededCount)
                DefaultTextColor := NamedColors.White
                DefaultShadowColor := NamedColors.Black
          
  # Este es el lienzo que contiene y posiciona el text_block en la pantalla.
            Canvas := canvas:
                Slots := array:
                    canvas_slot:
                        Anchors := anchors{Minimum := UIPosition, Maximum := UIPosition}
                        Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
                        Alignment := UIAlignment
                        SizeToContent := true
                        Widget := TextBlock
            # El lienzo se asigna al jugador.
            PlayerUI.AddWidget(Canvas, player_ui_slot{ZOrder := UIZOrder})
            # El text_block se guarda en el mapa para que podamos actualizar el texto más adelante a medida que más jugadores se unan al juego.
            if (set WaitingForMorePlayersUI[Player] = option{ waiting_for_more_players_ui{Canvas := Canvas, TextBlock := TextBlock} }) {}
  
  # Elimina el mensaje de interfaz de usuario "Esperando a más jugadores" para los jugadores que tengan uno.
    ClearWaitingForMorePlayers():void =
        Logger.Print("Borrando la interfaz de usuario de espera a más jugadores.")
        for (Player -> UIData : WaitingForMorePlayersUI):
            if:
                PlayerUI := GetPlayerUI[Player]
                Canvas := UIData?.Canvas
                set WaitingForMorePlayersUI[Player] = false
            then:
                PlayerUI.RemoveWidget(Canvas)

Siguiente sección

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page