guard_spawner_device: AI Guards for PvE and Objective Defense

Overview

The guard_spawner_device is your one-stop shop for AI combatants. Placed in the editor, it spawns guard-type NPCs that already know how to patrol an area (or follow an AI Patrol Path Node), fill a suspicion meter when they see a target, go Alert, chase, and attack. You configure their weapons, team, accuracy, and spawn count in the device's User Options; you drive the timing and reactions from Verse.

Reach for it when you need:

• PvE enemies — waves of guards to fight through.
• Objective defense — guards protecting a vault, terminal, or capture point that turn hostile when players approach.
• Hireable allies — guards a player can recruit that leash to and protect them.
• Scripted encounters — spawn a guard at an exact position, then force it to hunt a chosen player.

The key rule to remember: changing device properties only affects guards spawned afterward, and the device has a spawn limit. Verse lets you subscribe to a rich set of perception events (SuspiciousEvent, AlertedEvent, TargetLostEvent, UnawareEvent) plus combat events (DamagedEvent, EliminatedEvent, EliminatingEvent) and hiring events (HiredEvent, DismissedEvent), so you can react to the full guard lifecycle.

API Reference

guard_spawner_device

Used to spawn guards that can patrol and attack other agents. Changing properties will only affect newly spawned guards.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

guard_spawner_device<public> := class<concrete><final>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a vault-defense encounter. Two guards defend a vault. A pressure plate (a trigger_device) tells the spawner when the raiding player steps into the room, so we spawn the defenders and force them to attack that player. We track eliminations, and when the last defender falls we open the vault door (a barrier_device we Disable to let the player through).

using { /Fortnite.com/Devices }
using { /Fortnite.com }
using { /Verse.org/Simulation }
using { /Verse.org/Chat }

vault_defense := class(creative_device):

    # The spawner that produces our defending guards.
    @editable
    GuardSpawner : guard_spawner_device = guard_spawner_device{}

    # Pressure plate the raider steps on to trigger the fight.
    @editable
    IntrusionPlate : trigger_device = trigger_device{}

    # The vault door barrier; we disable it once all guards are down.
    @editable
    VaultDoor : barrier_device = barrier_device{}

    # How many guards are still alive.
    var GuardsRemaining : int = 0

    # Localized helper so we can name our guards (message, not string).
    NameText<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Give the guards a name shown in the elimination feed.
        GuardSpawner.SetName(NameText("Vault Sentinel"))

        # React to the whole guard lifecycle.
        GuardSpawner.SpawnedEvent.Subscribe(OnGuardSpawned)
        GuardSpawner.AlertedEvent.Subscribe(OnGuardAlerted)
        GuardSpawner.EliminatedEvent.Subscribe(OnGuardEliminated)

        # The plate starts the encounter.
        IntrusionPlate.TriggeredEvent.Subscribe(OnPlateStepped)

    # Player stepped on the plate: wake the spawner and force the fight.
    OnPlateStepped(Agent : ?agent) : void =
        if (Raider := Agent?):
            # Enable the device so it will accept spawns.
            GuardSpawner.Enable()
            # Spawn up to the device's configured count.
            SpawnLimit := GuardSpawner.GetSpawnLimit()
            var Count : int = 0
            loop:
                if (Count >= SpawnLimit):
                    break
                GuardSpawner.Spawn()
                set Count = Count + 1
            # Everything the device has produced should hunt the raider.
            for (Guard : GuardSpawner.GetAgents()):
                GuardSpawner.ForceAttackTarget(Raider, ?ForgetTime := 600.0)

    # Count each guard as it appears.
    OnGuardSpawned(Guard : agent) : void =
        set GuardsRemaining = GuardsRemaining + 1

    # A guard spotted someone — nothing extra needed, but log-worthy hook.
    OnGuardAlerted(Result : device_ai_interaction_result) : void =
        # Source is the guard, Target is who alerted them (optional agent).
        if (Target := Result.Target?):
            # We could highlight the raider here; left as a hook.
            GuardSpawner.ForceAttackTarget(Target, ?ForgetTime := 600.0)

    # A guard died. When the last one falls, open the vault.
    OnGuardEliminated(Result : device_ai_interaction_result) : void =
        set GuardsRemaining = GuardsRemaining - 1
        if (GuardsRemaining <= 0):
            # Reward: drop the barrier so the player can loot the vault.
            VaultDoor.Disable()

Line by line:

• The @editable fields let you drop the real placed devices into the panel. Without declaring the spawner as a field you could not call any of its methods.
• NameText<localizes> builds a message — SetName requires localized text, so we can never pass a raw string.
• In OnBegin we subscribe our handler methods to the device's events. SpawnedEvent hands us a raw agent; the interaction events hand us a device_ai_interaction_result with Source and Target.
• OnPlateStepped unwraps the optional agent with if (Raider := Agent?). We Enable() the spawner, then call Spawn() in a loop up to GetSpawnLimit() so we never exceed the device's cap.
• GetAgents() returns every agent this device created; we loop and ForceAttackTarget each toward the raider, bypassing perception so the fight starts immediately. ?ForgetTime := 600.0 keeps them locked on for the full 10 minutes.
• OnGuardEliminated decrements the counter and, when it reaches zero, Disable()s the barrier — the vault opens.

Common patterns

Hireable ally guards

Let a player recruit a guard from a button, then hire the spawner's guards onto their team. React to the HiredEvent.

using { /Fortnite.com/Devices }
using { /Fortnite.com }
using { /Verse.org/Simulation }

ally_recruiter := class(creative_device):

    @editable
    AllySpawner : guard_spawner_device = guard_spawner_device{}

    @editable
    HireButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Allow these guards to be recruited.
        AllySpawner.SetGuardsHireable()
        AllySpawner.HiredEvent.Subscribe(OnHired)
        HireButton.InteractedWithEvent.Subscribe(OnHirePressed)

    OnHirePressed(Agent : agent) : void =
        # Hire whatever this spawner has produced onto the player's team.
        AllySpawner.Hire(Agent)

    OnHired(Result : device_ai_interaction_result) : void =
        # Source is the player who hired; Target is the recruited guard.
        if (Player := Result.Source?):
            # Guard now leashes to and protects the player.
            AllySpawner.SetGuardsNotHireable()

Suspicion / detection feedback

Use the perception events to build a stealth loop — light up an alarm when a guard gets suspicious, clear it when they lose the target.

using { /Fortnite.com/Devices }
using { /Fortnite.com }
using { /Verse.org/Simulation }

alarm_system := class(creative_device):

    @editable
    PatrolSpawner : guard_spawner_device = guard_spawner_device{}

    # A light or FX driver enabled while guards are alerted.
    @editable
    AlarmLight : device_ability_kit = device_ability_kit{}

    OnBegin<override>()<suspends> : void =
        PatrolSpawner.Enable()
        PatrolSpawner.SuspiciousEvent.Subscribe(OnSuspicious)
        PatrolSpawner.TargetLostEvent.Subscribe(OnTargetLost)
        PatrolSpawner.UnawareEvent.Subscribe(OnUnaware)

    OnSuspicious(Guard : agent) : void =
        # A guard sees something. Escalate by forcing a spawn of reinforcements.
        PatrolSpawner.Spawn()

    OnTargetLost(Result : device_ai_interaction_result) : void =
        # Guard lost track — dismiss any player-hired guards to reset the scene.
        PatrolSpawner.DismissAllHiredGuards()

    OnUnaware(Guard : agent) : void =
        # Guard fully calmed down; no action needed here.
        PatrolSpawner.Disable()

Scripted spawn at an exact spot

SpawnAt is <suspends> and returns the spawned agent (or fails). Use it for cinematic ambushes at precise coordinates.

using { /Fortnite.com/Devices }
using { /Fortnite.com }
using { /Verse.org/Simulation }
using { /Verse.org/SpatialMath }

ambush_trap := class(creative_device):

    @editable
    AmbushSpawner : guard_spawner_device = guard_spawner_device{}

    @editable
    Tripwire : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        AmbushSpawner.Enable()
        Tripwire.TriggeredEvent.Subscribe(OnTripped)

    OnTripped(Agent : ?agent) : void =
        if (Victim := Agent?):
            spawn { SpringAmbush(Victim) }

    SpringAmbush(Victim : agent)<suspends> : void =
        # Spawn a guard right beside the victim's ambush point.
        SpawnPos : vector3 = vector3{ X := 500.0, Y := 0.0, Z := 100.0 }
        if (Guard := AmbushSpawner.SpawnAt(SpawnPos)):
            # Lock the fresh guard onto the victim immediately.
            AmbushSpawner.ForceAttackTarget(Victim, ?ForgetTime := 120.0)

Gotchas

• Properties are apply-on-spawn. Weapon, team, accuracy, and name changes only affect guards spawned after you set them. SetName before you Spawn, not after.
• SetName needs a message, not a string. There is no StringToMessage. Declare a NameText<localizes>(S:string):message = "{S}" helper and pass NameText("...").
• Respect the spawn limit. Spawn() silently does nothing once the device hits GetSpawnLimit(). Loop against GetSpawnLimit() (as in the walkthrough) or the device just stops producing guards. If you need a fresh batch, the device also offers Reset to reset the spawn count.
• Interaction-event fields are optional. In a device_ai_interaction_result, Source and Target are ?agent — always unwrap with if (X := Result.Source?). When a guard is damaged/eliminated by non-agent damage (fall, environment), Source is false.
• SpawnAt is <suspends> and can fail. Call it from inside a spawn{} block or another <suspends> context, and wrap it in if (Guard := ...SpawnAt(Pos)): because it fails when the device is at max count.
• Enable/Disable and despawn interact. Disable() only despawns guards if the device's Despawn Guards When Disabled option is set — otherwise existing guards stay. Use Despawn() explicitly if you want them gone.
• Patrol paths are set in the editor, not Verse. Match the spawner's Spawn on Patrol Path Group to the AI Patrol Path Node's Patrol Path Group number so fresh guards start patrolling.