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)