Esta sección te mostrará cómo añadir la secuencia de comandos de Verse y colocar el dispositivo Verse para personalizar el juego.

Ve a Verse > Explorador de Verse para crear una secuencia de comandos de Verse.

A continuación, haz clic con el botón derecho en el nombre del archivo de tu proyecto y selecciona Añadir nuevo archivo de Verse al proyecto.

Selecciona Dispositivo Verse, dale un nombre y haz clic en Crear. En este tutorial, el dispositivo Verse se llama Stronghold_Game_Manager.

Haz doble clic en el archivo de Verse del dispositivo para que aparezca la secuencia de comandos de Verse. Copia y pega el código que aparece a continuación.
using { /Fortnite.com/AI }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Fortnite.com/Game }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Simulation }
using { /Verse.org/Verse }
# Fortaleza es un modo de juego en el que el objetivo es que los jugadores eliminen a todos los enemigos hostiles en una fortaleza fuertemente custodiada.
# El dispositivo Verse Gestor de partida Fortaleza se utiliza para gestionar, supervisar y controlar las IA de la fortaleza.
stronghold_game_manager := class(creative_device):
# Referencia del dispositivo Generador de guardias a tener en cuenta para las eliminaciones
@editable
GuardsInitialSpawners:[]guard_spawner_device := array{}
# Referencia del dispositivo Generador de guardias a tener en cuenta para el escalado multijugador
@editable
GuardsInitialSpawnersAdditional:[]guard_spawner_device := array{}
# Referencia del dispositivo al generador de guardias de refuerzo para que se active cuando uno de los guardias de la fortaleza sea alertado
@editable
GuardsReinforcementSpawners:[]guard_spawner_device := array{}
# Referencia del dispositivo al generador de guardias de refuerzo para que se active cuando uno de los guardias de la fortaleza sea alertado para el escalado multijugador
@editable
GuardsReinforcementSpawnersAdditional:[]guard_spawner_device := array{}
# Referencia del dispositivo para mostrar y seguir los objetivos
@editable
ObjectiveTracker:tracker_device := tracker_device{}
# Referencia del dispositivo para mostrar el mensaje de refuerzo en el juego
@editable
MessageDeviceReinforcement:hud_message_device := hud_message_device{}
# Referencia del dispositivo para mostrar el mensaje de retirada en el juego
@editable
MessageDeviceFallback:hud_message_device := hud_message_device{}
# Referencia del dispositivo para terminar el juego con una victoria si los jugadores completaron la fortaleza sin ser detectados
@editable
EndGameVictoryDeviceUndetected:end_game_device := end_game_device{}
# Referencia del dispositivo para terminar el juego con una victoria si los jugadores completaron la fortaleza mientras estaban siendo detectados
@editable
EndGameVictoryDeviceDetected:end_game_device := end_game_device{}
# Referencia del dispositivo para terminar el juego con un fallo si los jugadores se quedan sin reintentos
@editable
EndGameFailDevice:end_game_device := end_game_device{}
# Número ajustable de vidas del jugador
@editable
var PlayerRetries:int = 2
# Dispositivo para referenciar la posición de separación de la fortaleza
@editable
ReinforcementLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Dispositivo para referenciar la posición de separación de retirada
@editable
FallbackLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Las separaciones que deben desactivarse tras la retirada
@editable
LeashesToDisableForFallback:[]stronghold_leash_position := array{}
# Dispositivo para la explosión
@editable
ExplosiveDevice:explosive_device := explosive_device{}
# La percepción de los guardias es monitorizada por esta secuencia de comandos, las otras secuencias de comandos pueden suscribirse a esos eventos.
# Evento retransmitido cuando un guardia pide refuerzos
ReinforcementsCalledEvent:event(agent) = event(agent){}
# Evento retransmitido cuando los guardias defienden el centro de la fortaleza
FallbackEvent:event() = event(){}
# Evento retransmitido cuando un guardia se vuelve sospechoso
GuardsSuspiciousEvent:event(agent) = event(agent){}
# Evento retransmitido cuando todos los guardias están desprevenidos
GuardsUnawareEvent:event(agent) = event(agent){}
# Evento retransmitido cuando se detecta un jugador
PlayerDetectedEvent:event(agent) = event(agent){}
# Evento retransmitido cuando todos los guardias han perdido su objetivo
PlayerLostEvent:event(agent) = event(agent){}
# Listas de guardias en un estado de alerta específico para controlar los cambios de percepción
# Variable para almacenar guardias de refuerzo
var<private> NumGuardsSpawned:int := 0
# Variable para almacenar todos los guardias de la fortaleza
var<private> StrongholdGuards:[]agent := array{}
# Variable para almacenar guardias de refuerzo
var<private> ReinforcementGuards:[]agent := array{}
# Lista de guardias actualmente sospechosos
var<private> SuspiciousGuards : []agent = array{}
# Lista de guardias alertados actualmente
var<private> AlertedGuards : []agent = array{}
# Lista de guardias que están investigando
var<private> InvestigatingGuards : []agent = array{}
# Generadores de guardias iniciales, se incluirán generadores adicionales con la sesión multijugador.
var<private> GuardsInitialSpawnersInternal:[]guard_spawner_device = array{}
# Generadores de guardias de refuerzo, se incluirán generadores adicionales con la sesión multijugador.
var<private> GuardsReinforcementSpawnersInternal:[]guard_spawner_device = array{}
# Variables lógicas del juego
# Variable para registrar el número de eliminaciones de todos los generadores de guardias de la fortaleza
var<private> GuardsEliminated:int := 0
# Variable para rastrear si se llamó o no al refuerzo
var<private> ReinforcementTriggered:logic := false
# Variable para rastrear si se activó la retirada
var<private> FallbackTriggered:logic := false
# Variable para almacenar el primer agente jugador que es detectado por los guardias
var<private> DetectedPlayer:?player := false
# Se ejecuta cuando el dispositivo se inicia con una partida en marcha.
OnBegin<override>()<suspends>:void=
# Comprueba el escalado de dificultad del jugador activo
AllPlayers := GetPlayspace().GetPlayers()
NumberOfActivePlayers := AllPlayers.Length
set GuardsInitialSpawnersInternal = GuardsInitialSpawners
set GuardsReinforcementSpawnersInternal = GuardsReinforcementSpawners
# Añade un generador de guardias adicional cuando haya más de dos jugadores
if (NumberOfActivePlayers > 2):
set GuardsInitialSpawnersInternal += GuardsInitialSpawnersAdditional
set GuardsReinforcementSpawnersInternal += GuardsReinforcementSpawnersAdditional
var NumInitialGuards:int = 0
for (GuardSpawner : GuardsInitialSpawnersInternal):
GuardSpawner.Enable()
SubscribeToGuardSpawnerEvents(GuardSpawner);
set NumInitialGuards += GuardSpawner.GetSpawnLimit()
ObjectiveTracker.SetTarget(NumInitialGuards)
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
SubscribeToGuardSpawnerEvents(GuardReinforcementSpawner);
# Suscripción a evento generado por refuerzo
GuardReinforcementSpawner.SpawnedEvent.Subscribe(OnReinforcementSpawned)
GuardReinforcementSpawner.AlertedEvent.Subscribe(OnReinforcementAlerted)
GuardReinforcementSpawner.UnawareEvent.Subscribe(OnReinforcementUnaware)
# Suscripción a evento de eliminación de jugadores
for (StrongholdPlayer : AllPlayers, StrongholdPC := StrongholdPlayer.GetFortCharacter[]):
StrongholdPC.EliminatedEvent().Subscribe(OnPlayerEliminated)
StartGameplay()
SubscribeToGuardSpawnerEvents(SpawnerDevice:guard_spawner_device):void =
SpawnerDevice.SpawnedEvent.Subscribe(OnGuardSpawned)
SpawnerDevice.EliminatedEvent.Subscribe(OnGuardEliminated)
SpawnerDevice.SuspiciousEvent.Subscribe(OnGuardSuspicious)
SpawnerDevice.AlertedEvent.Subscribe(OnGuardAlerted)
SpawnerDevice.TargetLostEvent.Subscribe(OnGuardLostTarget)
SpawnerDevice.UnawareEvent.Subscribe(OnGuardUnaware)
# Empieza a rastrear a los guardias eliminados y desencadena la explosión
StartGameplay()<suspends>:void =
ObjectiveTracker.AssignToAll()
Sleep(3.0)
if (FirstPlayer:=GetPlayspace().GetPlayers()[0]):
ExplosiveDevice.Explode(FirstPlayer)
# Se ejecuta cuando el generador de guardias recibe un evento de alerta y solo tiene en cuenta el primer evento de alerta.
OnGuardAlerted(InteractionResult:device_ai_interaction_result):void=
if:
not ReinforcementTriggered?
set DetectedPlayer = option{player[InteractionResult.Target?]}
Guard:=InteractionResult.Source?
then:
var NumGuards:int = ObjectiveTracker.GetTarget()
# Activar el dispositivo Generador de guardias de refuerzo garantiza que generemos la cantidad de guardias configurada en el dispositivo Generador de guardias.
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
GuardReinforcementSpawner.Enable()
set NumGuards += GuardReinforcementSpawner.GetSpawnLimit()
ObjectiveTracker.SetTarget(NumGuards)
# Mostrar mensaje en la partida para detección y refuerzo entrante
MessageDeviceReinforcement.Show()
set ReinforcementTriggered = true
# Evento de refuerzo de señal
ReinforcementsCalledEvent.Signal(Guard)
# Añade el guardia a la lista de guardias alertados si no se ha añadido previamente.
if(Guard:=InteractionResult.Source?):
if (not AlertedGuards.Find[Guard]):
set AlertedGuards += array{Guard}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
# Retransmisión del evento Jugador detectado cuando se alerta a un guardia
if (AlertedGuards.Length = 1):
PlayerDetectedEvent.Signal(Guard)
# Se ejecuta cuando el generador de guardias de refuerzo recibe un evento alertado.
OnReinforcementAlerted(InteractionResult:device_ai_interaction_result):void=
if:
not FallbackTriggered?
Guard:=InteractionResult.Source?
then:
# Despeja la separación para refuerzos al recibir la alerta para que ataque a su objetivo
ReinforcementLeashReference.ClearLeashOnGuard(Guard)
# Se ejecuta cuando el generador de guardias de refuerzo recibe un evento desprevenido.
OnReinforcementUnaware(Guard:agent):void=
if (not FallbackTriggered?):
# Vuelve a ajustar la separación
ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
# Se ejecuta cuando el generador de guardias recibe un evento desprevenido.
OnGuardSuspicious(Guard:agent):void=
if (not SuspiciousGuards.Find[Guard]):
set SuspiciousGuards += array{Guard}
# Retransmisión del evento Sospechoso cuando un guardia sea sospechoso
if:
SuspiciousGuards.Length = 1
AlertedGuards.Length = 0
InvestigatingGuards.Length = 0
then:
GuardsSuspiciousEvent.Signal(Guard)
# Se ejecuta cuando el generador de guardias recibe un evento desprevenido.
OnGuardUnaware(Guard:agent):void=
option {set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
# Retransmisión del evento Desprevenido cuando ningún guardia sea sospechoso, alertado o esté investigando
if:
SuspiciousGuards.Length = 0
AlertedGuards.Length = 0
InvestigatingGuards.Length = 0
then:
GuardsUnawareEvent.Signal(Guard)
# Cuando un guardia pierda de vista al jugador, elimínalo de la lista de guardias alertados; cuando todos los guardias hayan perdido al jugador, señala el evento.
OnGuardLostTarget(InteractionResult:device_ai_interaction_result):void=
if (Guard := InteractionResult.Source?):
if (not InvestigatingGuards.Find[Guard]):
set InvestigatingGuards += array{Guard}
# Retransmisión del evento Jugador perdido cuando no se alerta a ningún guardia
if (set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]):
if (AlertedGuards.Length = 0):
PlayerLostEvent.Signal(Guard)
# Se ejecuta cuando aparece un guardia de refuerzo. Cada guardia de refuerzo se ve obligado a atacar al jugador que alertó a la fortaleza.
OnReinforcementSpawned(Guard:agent):void=
set ReinforcementGuards += array{Guard}
ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
# Asigna como objetivo al jugador que alertó a los guardias de la fortaleza.
if (Target := DetectedPlayer?):
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
GuardReinforcementSpawner.ForceAttackTarget(Target, ?ForgetTime:=30.0)
# Se ejecuta cuando se genera cualquier guardia de la fortaleza.
OnGuardSpawned(Guard:agent):void=
set StrongholdGuards += array{Guard}
set NumGuardsSpawned += 1
# Se ejecuta cuando los generadores iniciales o de refuerzo reciben una eliminación.
OnGuardEliminated(InteractionResult:device_ai_interaction_result):void=
set GuardsEliminated += 1
if (EliminatedAgent := InteractionResult.Target?):
# Quita guardias eliminados de la lista de guardias alertados
option {set AlertedGuards = AlertedGuards.RemoveFirstElement[EliminatedAgent]}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[EliminatedAgent]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[EliminatedAgent]}
option {set StrongholdGuards = StrongholdGuards.RemoveFirstElement[EliminatedAgent]}
if (EliminationAgent := InteractionResult.Source?):
# Aumenta el valor de progreso del dispositivo Rastreador para cada eliminación
ObjectiveTracker.Increment(EliminationAgent)
if (ReinforcementTriggered?):
if (NumGuardsSpawned - GuardsEliminated = 3):
StartFallback()
# Finaliza el modo de juego si todos los guardias son eliminados sin los refuerzos.
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceDetected.Activate(EliminationAgent)
else:
# Finaliza el modo de juego si todos los guardias son eliminados con los refuerzos.
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceUndetected.Activate(EliminationAgent)
# Asigna una nueva separación de retirada cuando queden pocos guardias alertados para defender el centro de la fortaleza.
StartFallback():void=
# Muestra el mensaje en el juego para los guardias que se retiran dentro del edificio de la fortaleza.
MessageDeviceFallback.Show()
set FallbackTriggered = true
for (LeashDevice : LeashesToDisableForFallback):
LeashDevice.DisableLeashAndPatrolPaths()
FallbackLeashPosition := FallbackLeashReference.GetTransform().Translation
FallbackEvent.Signal()
for (Guard : StrongholdGuards):
FallbackLeashReference.ApplyLeashOnGuard(Guard)
# Se ejecuta cuando se recibe un evento de eliminación de jugador.
OnPlayerEliminated(EliminationResult:elimination_result):void=
set PlayerRetries -= 1
if (PlayerRetries = 0, Agent := EliminationResult.EliminatedCharacter.GetAgent[]):
EndGameFailDevice.Activate(Agent)

A continuación, ve a Verse > Compilar código de Verse para compilar la secuencia de comandos de Verse.

Ve a Todos/"Nombre del proyecto"/Dispositivos del modo Creativo/ y selecciona tu dispositivo Verse.

Después, arrastra tu dispositivo Verse al mapa. Solo aparecerá después de compilar la secuencia de comandos de Verse.
Con tu dispositivo Verse seleccionado, ve al panel Detalles y actualiza las Opciones de usuario como se muestra a continuación.

Opción | Valor | Explicación |
---|---|---|
Visible en partida | False | Este dispositivo no será visible durante la partida. |
Guards_InitialSpawners | Tres elementos de matriz | Haz clic en el signo más para añadir tres elementos a esta configuración. |
0 | Generador de guardias | Se trata de una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
1 | Generador de guardias - Torre del tirador 1 | Se trata de una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
2 | Generador de guardias - Torre del tirador 2 | Se trata de una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
Guards_ReinforcementSpawner | Generador de guardias - Refuerzos | Genera los guardias de refuerzo. |
Rastreador de objetivos | Rastreador | Muestra los objetivos de la fortaleza y el recuento de eliminaciones. |
MessageDeviceReinforcement | Mensaje del HUD de refuerzo del dispositivo | Muestra el mensaje de refuerzo en pantalla. |
MessageDeliverFallback | Mensaje del HUD de retirada del dispositivo | Muestra el mensaje de retirada en pantalla. |
EndGameVictoryDeviceUndetected | Dispositivo Fin de partida no detectado | Muestra la victoria y la pantalla de fin de partida sin detectar. |
EndGameVictoryDeviceDetected | Dispositivo Fin de partida detectado | Muestra la victoria y la pantalla de fin de partida detectada. |
EndGameFailDevice | Fallo del dispositivo Fin de partida | Muestra la pantalla de fin de partida fallida porque el jugador se ha quedado sin vidas. |
EliminationCount | 6 | Determina la cantidad de eliminaciones de guardias necesarias para completar la fortaleza sin ser detectado. |
EliminationCountWithReinforcement | 10 | Determina la cantidad de eliminaciones de guardias necesarias para completar la fortaleza con refuerzos activados. |
PlayerRetries | 2 | Determina el número de vidas que tiene el jugador para intentar completar la fortaleza con éxito. Si el jugador se queda sin vidas, la fortaleza fracasa. |
StrongholdLeashReferernce | Posición de separación - Fortaleza | Los dispositivos Posición de separación utilizan su posición como origen de separación de la fortaleza. |
FallbackLeashReference | Posición de separación - Retirada | El dispositivo Posición de separación utiliza su posición como origen de separación de retirada. |
StrongholdLeashInnerRadius | 2400.0 | Determina en centímetros el radio interior de separación de la fortaleza. Debe ser menor que el radio exterior. |
StrongholdLeashOuterRadius | 2500,0 | Determina el radio exterior de separación de la fortaleza. |
DefendFallbackLeashInnerRadius | 700.0 | Determina en centímetros el radio interior de separación de retirada. Debe ser menor que el radio exterior. |
DefendFallbackLeashOuterRadius | 750,0 | Determina en centímetros el radio exterior de separación de retirada. |
Siguiente sección
%verse-stronghold-template-4-add-devices-in-unreal-editor-for-fortnite:topic%