En esta sección, verás cómo agregar una secuencia de comandos de Verse y colocar el dispositivo de Verse para personalizar tu jugabilidad.

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

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

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

Haz doble clic en el archivo de Verse del dispositivo para abrir la secuencia de comandos de Verse. Copia y pega el siguiente código.
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 }
# La Fortaleza es un modo de juego en el que el objetivo es que los jugadores eliminen a todos los enemigos hostiles en una fortaleza muy protegida.
# El dispositivo de Verse de administrador de juego de Fortaleza se utiliza para gestionar, supervisar y controlar las IA en la Fortaleza.
stronghold_game_manager := class(creative_device):
# Referencia del dispositivo para que el dispositivo generador de guardias siga las eliminaciones
@editable
GuardsInitialSpawners:[]guard_spawner_device := array{}
# Referencia del dispositivo para que el dispositivo generador de guardias siga las eliminaciones del escalamiento multijugador
@editable
GuardsInitialSpawnersAdditional:[]guard_spawner_device := array{}
# Referencia del dispositivo para que el dispositivo generador de guardias de refuerzo se active cuando se alerta a uno de los guardias de la Fortaleza
@editable
GuardsReinforcementSpawners:[]guard_spawner_device := array{}
# Referencia del dispositivo para que el dispositivo generador de guardias de refuerzo se active cuando se alerta a uno de los guardias de la Fortaleza del escalamiento multijugador
@editable
GuardsReinforcementSpawnersAdditional:[]guard_spawner_device := array{}
# Referencia del dispositivo para visualizar y seguir objetivos
@editable
ObjectiveTracker:tracker_device := tracker_device{}
# Referencia del dispositivo para mostrar mensaje de refuerzo en el juego
@editable
MessageDeviceReinforcement:hud_message_device := hud_message_device{}
# Referencia del dispositivo para mostrar mensaje de retirada en el juego
@editable
MessageDeviceFallback:hud_message_device := hud_message_device{}
# Dispositivo de referencia para finalizar la partida con una victoria si los jugadores completan la Fortaleza sin ser detectados
@editable
EndGameVictoryDeviceUndetected:end_game_device := end_game_device{}
# Dispositivo de referencia para finalizar la partida con una victoria si los jugadores completan la Fortaleza mientras son detectados
@editable
EndGameVictoryDeviceDetected:end_game_device := end_game_device{}
# Referencia del dispositivo para finalizar la partida con un error si los jugadores se quedan sin reintentos
@editable
EndGameFailDevice:end_game_device := end_game_device{}
# Ajustar la cantidad de vidas de los jugadores
@editable
var PlayerRetries:int = 2
# Dispositivo para hacer referencia a la posición de la rienda de la Fortaleza
@editable
ReinforcementLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Dispositivo para hacer referencia a la posición de la rienda de retirada
@editable
FallbackLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Las riendas que se deben deshabilitar después de 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 se controla mediante esta secuencia de comandos, las otras secuencias de comandos pueden suscribirse a esos eventos
# Evento que se transmite cuando un guardia pide refuerzos
ReinforcementsCalledEvent:event(agent) = event(agent){}
# Evento que se transmite cuando los guardias defienden el centro de la Fortaleza
FallbackEvent:event() = event(){}
# Evento que se transmite cuando un vigilante empieza a sospechar
GuardsSuspiciousEvent:event(agent) = event(agent){}
# Evento que se transmite cuando todos los guardias se vuelven desprevenidos
GuardsUnawareEvent:event(agent) = event(agent){}
# Evento que se transmite cuando se detecta a un jugador
PlayerDetectedEvent:event(agent) = event(agent){}
# Evento que se transmite cuando todos los guardias perdieron su objetivo
PlayerLostEvent:event(agent) = event(agent){}
# Listas de guardias en un estado de alerta específico para supervisar los cambios de percepción
# Variable para guardar guardias de refuerzo
var<private> NumGuardsSpawned:int := 0
# Variable para guardar todos guardias de la Fortaleza
var<private> StrongholdGuards:[]agent := array{}
# Variable para guardar guardias de refuerzo
var<private> ReinforcementGuards:[]agent := array{}
# Lista de guardias que sospechan actualmente
var<private> SuspiciousGuards : []agent = array{}
# Lista de guardias en alerta actualmente
var<private> AlertedGuards : []agent = array{}
# Lista de guardias en investigación actualmente
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 de juego
# Variable para seguir la cantidad de eliminaciones de todos los generadores de guardias de la Fortaleza
var<private> GuardsEliminated:int := 0
# Variable para seguir si se llamó al refuerzo o no
var<private> ReinforcementTriggered:logic := false
# Variable para saber si se activó la retirada
var<private> FallbackTriggered:logic := false
# Variable para guardar el primer agente jugador que detectan los guardias
var<private> DetectedPlayer:?player := false
# Se ejecuta cuando el dispositivo se inicia en un juego en ejecución.
OnBegin<override>()<suspends>:void=
# Comprobar la escala de dificultad del jugador activo
AllPlayers := GetPlayspace().GetPlayers()
NumberOfActivePlayers := AllPlayers.Length
set GuardsInitialSpawnersInternal = GuardsInitialSpawners
set GuardsReinforcementSpawnersInternal = GuardsReinforcementSpawners
# Añadir Generador de guardia adicional cuando hay más de 2 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 al evento generado de refuerzo
GuardReinforcementSpawner.SpawnedEvent.Subscribe(OnReinforcementSpawned)
GuardReinforcementSpawner.AlertedEvent.Subscribe(OnReinforcementAlerted)
GuardReinforcementSpawner.UnawareEvent.Subscribe(OnReinforcementUnaware)
# Suscripción al 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 activa 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()
# La activación del dispositivo generador de guardias de refuerzo garantiza que aparezca la cantidad de guardias configurada en el dispositivo generador de guardias.
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
GuardReinforcementSpawner.Enable()
set NumGuards += GuardReinforcementSpawner.GetSpawnLimit()
ObjectiveTracker.SetTarget(NumGuards)
# Visualización de mensajes en el juego para la detección y el refuerzo que entra
MessageDeviceReinforcement.Show()
set ReinforcementTriggered = true
# Evento de refuerzo de señales
ReinforcementsCalledEvent.Signal(Guard)
# Añade al guardia a la lista de guardias en alerta si no se añadió 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]}
# Transmite el Evento de jugador detectado cuando un guardia está en alerta
if (AlertedGuards.Length = 1):
PlayerDetectedEvent.Signal(Guard)
# Se ejecuta cuando el generador de guardias de refuerzo recibe un evento de alerta
OnReinforcementAlerted(InteractionResult:device_ai_interaction_result):void=
if:
not FallbackTriggered?
Guard:=InteractionResult.Source?
then:
# Despeja la rienda para reforzar la alerta a fin de que ataquen 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?):
# Retira la rienda
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}
# Transmite el evento de sospecha cuando un guardia sospecha
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]}
# Transmite el Evento desprevenido cuando ningún guardia está sospechando, en alerta ni 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 en alerta; 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}
Transmite el Evento de 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 aparece 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?):
# Elimina la guardia que se eliminó de la lista de guardias en alerta
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?):
# Aumento del valor de progreso para el dispositivo de seguimiento en cada eliminación
ObjectiveTracker.Increment(EliminationAgent)
if (ReinforcementTriggered?):
if (NumGuardsSpawned - GuardsEliminated = 3):
StartFallback()
# Finaliza el modo de juego si todos los guardias se eliminaron sin los refuerzos
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceDetected.Activate(EliminationAgent)
else:
# Finaliza el modo de juego si todos los guardias se eliminaron con los refuerzos.
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceUndetected.Activate(EliminationAgent)
# Asigna una nueva rienda de retirada cuando queden pocos guardias en alerta para defender el centro de la fortaleza.
StartFallback():void=
# Visualización del mensaje en el juego para los guardias que se retiran dentro de la construcción 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 un 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 de Verse.

A continuación, arrastra tu dispositivo de Verse al mapa. Esto solo aparecerá después de compilar la secuencia de comandos de Verse.
Con tu dispositivo de Verse seleccionado, ve al panel de detalles y actualiza las opciones de usuario como se muestra a continuación.

Opción | Valor | Explicación |
---|---|---|
Visible durante el juego | Falso | Este dispositivo no será visible durante el juego. |
Guards_InitialSpawners | 3 elementos de matriz | Haz clic en el signo más para añadir tres elementos a esta configuración. |
0 | Generador de guardias | Esto es una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
1 | Generador de guardias de francotirador de la torre 1 | Esto es una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
2 | Generador de guardias de francotirador de la torre 2 | Esto es una matriz de todos los dispositivos utilizados para generar los guardias iniciales en la fortaleza. |
Guards_ReinforcementSpawner | Refuerzo de generador de guardias | Se generan los refuerzos de guardias. |
Rastreador de objetivos | Rastreador | Muestra los objetivos de la fortaleza y el recuento de eliminaciones. |
MessageDeviceReinforcement | Refuerzo del dispositivo de mensaje del HUD | Muestra el mensaje de refuerzo en pantalla. |
MessageDeliverFallback | Retirada de dispositivo de mensaje del HUD | Muestra el mensaje de retirada en pantalla. |
EndGameVictoryDeviceUndetected | Dispositivo de finalización de partida no detectado | Muestra la pantalla de victoria y finalización no detectado. |
EndGameVictoryDeviceDetected | Dispositivo de fin de partida detectado | Muestra la pantalla de victoria y finalización detectado. |
EndGameFailDevice | Error del dispositivo de finalización del juego | Muestra la pantalla de finalización con error porque el jugador se quedó 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 activaciones de refuerzos. |
PlayerRetries | 2 | Determina la cantidad 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 la rienda de la fortaleza | Los dispositivos de Posición de la rienda utilizan su posición como origen de la rienda de la fortaleza. |
FallbackLeashReference | Posición de retirada de rienda | El dispositivo de la posición de la rienda usa su posición como origen de la rienda de retirada. |
StrongholdLeashInnerRadius | 2400.0 | Determina en centímetros el radio interior de la rienda de la fortaleza. Debe ser más pequeño que el radio exterior. |
StrongholdLeashOuterRadius | 2500.0 | Determina el radio exterior de la rienda de la fortaleza. |
DefendFallbackLeashInnerRadius | 700.0 | Determina en centímetros el radio interior de la rienda de defensa de retirada. Debe ser más pequeño que el radio exterior. |
DefendFallbackLeashOuterRadius | 750.0 | Determina en centímetros el radio exterior de la rienda de defensa de retirada. |
Sección siguiente
%verse-stronghold-template-4-add-devices-in-unreal-editor-for-fortnite:topic%