creature_placer_device: Summoning Enemies on Cue

Overview

The creature_placer_device is the simplest way to put a hand-placed creature into your island and then drive it from code. Unlike the creature spawner (which spits out waves), the placer manages one creature instance: you tell it to Spawn(), you can Despawn() it, and you can even relocate the spawn with SpawnAt(Position, ?Rotation).

Reach for it when you want a scripted enemy — a vault guardian that appears the moment a player steps on a pressure plate, a mini-boss that respawns at a new location each round, or a trap creature that vanishes when a lever is pulled. Because the device fires SpawnedEvent (with the creature agent) and EliminatedEvent (with the killer agent, or false for environmental kills), you can build full combat loops: spawn → fight → reward → respawn.

API Reference

creature_placer_device

Used to spawn a creature at a specified location.

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

creature_placer_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 guardian. When a player steps on a trigger plate, the placer spawns a creature. When that creature is eliminated, we open a door (a prop_mover here is just a door device that we Disable/Enable — we'll use a real creature_placer_device plus a trigger_device and a barrier_device). When the player wants to retreat, a second trigger despawns the guardian.

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

vault_guardian := class(creative_device):

    # The placer that holds our single guardian creature.
    @editable Placer : creature_placer_device = creature_placer_device{}

    # Player steps here to summon the guardian.
    @editable StartFight : trigger_device = trigger_device{}

    # Player steps here to give up and clear the creature.
    @editable Retreat : trigger_device = trigger_device{}

    # The vault door — a barrier we drop when the guardian dies.
    @editable VaultDoor : barrier_device = barrier_device{}

    OnBegin<override>()<suspends>:void =
        # Subscribe the trigger plates to our handler methods.
        StartFight.TriggeredEvent.Subscribe(OnStartFight)
        Retreat.TriggeredEvent.Subscribe(OnRetreat)

        # React to the creature's lifecycle.
        Placer.SpawnedEvent.Subscribe(OnGuardianSpawned)
        Placer.EliminatedEvent.Subscribe(OnGuardianEliminated)

    # TriggeredEvent hands us a ?agent; unwrap before use.
    OnStartFight(Agent : ?agent):void =
        Print("A challenger approaches — summoning the guardian!")
        Placer.Spawn()

    OnRetreat(Agent : ?agent):void =
        Print("Challenger retreated — guardian despawned.")
        Placer.Despawn()

    # SpawnedEvent gives us the creature agent directly (not optional).
    OnGuardianSpawned(Creature : agent):void =
        Print("Guardian has entered the arena!")
        # Keep the vault sealed while the guardian lives.
        VaultDoor.Enable()

    # EliminatedEvent gives us a ?agent: the killer, or false for environment.
    OnGuardianEliminated(MaybeKiller : ?agent):void =
        if (Killer := MaybeKiller?):
            Print("Guardian slain by a player — vault opens!")
        else:
            Print("Guardian destroyed by the environment — vault opens!")
        # Drop the barrier so players can loot the vault.
        VaultDoor.Disable()

Line by line:

• The four @editable fields are the devices you place in the level and link in the Details panel. Every device you call MUST be a field like this — a bare Placer.Spawn() on an undeclared name fails with Unknown identifier.
• OnBegin<override>()<suspends>:void = runs once when the level starts. We subscribe all our handlers here.
• StartFight.TriggeredEvent.Subscribe(OnStartFight) wires the plate's event to a method on the class. Handlers are ordinary methods at class scope.
• OnStartFight calls Placer.Spawn() — this brings the placer's configured creature to life at the device's location.
• OnGuardianSpawned(Creature : agent) — SpawnedEvent is listenable(agent), so the handler receives a plain agent (the creature). We Enable the barrier to keep the vault locked.
• OnGuardianEliminated(MaybeKiller : ?agent) — EliminatedEvent is listenable(?agent). We unwrap with if (Killer := MaybeKiller?); when it succeeds a player did the kill, when it fails (else) the environment did. Either way we Disable the door.

Common patterns

Spawn at a precise location with SpawnAt

SpawnAt is <suspends> and returns ?agent, so call it from OnBegin or another suspending context and unwrap the result. Here we drop a creature at a fixed coordinate when the round begins.

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

ambush_spawner := class(creative_device):

    @editable Placer : creature_placer_device = creature_placer_device{}

    OnBegin<override>()<suspends>:void =
        # Build a world position 500cm up from the device origin.
        SpawnPos : vector3 = vector3{ X := 1000.0, Y := 0.0, Z := 500.0 }

        # SpawnAt suspends while the creature loads, then returns ?agent.
        MaybeCreature := Placer.SpawnAt(SpawnPos)
        if (Creature := MaybeCreature?):
            Print("Ambush creature spawned at the chosen position!")
        else:
            Print("Could not spawn — device hit its max spawn count.")

React to spawns to grant the spawner a reward

You can count or respond to each spawn independently. This snippet uses SpawnedEvent to log a kill-quota and re-arm the encounter.

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

spawn_counter := class(creative_device):

    @editable Placer : creature_placer_device = creature_placer_device{}
    var SpawnCount : int = 0

    OnBegin<override>()<suspends>:void =
        Placer.SpawnedEvent.Subscribe(OnSpawned)
        # Kick off the first creature.
        Placer.Spawn()

    OnSpawned(Creature : agent):void =
        set SpawnCount += 1
        Print("Creatures spawned so far: {SpawnCount}")

Despawn to clear the arena between rounds

Despawn() removes the current creature without an elimination — perfect for resetting state when a round ends.

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

round_reset := class(creative_device):

    @editable Placer : creature_placer_device = creature_placer_device{}
    @editable EndRound : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        EndRound.TriggeredEvent.Subscribe(OnEndRound)

    OnEndRound(Agent : ?agent):void =
        Print("Round over — clearing the arena.")
        Placer.Despawn()

Gotchas

• SpawnAt suspends. It is declared <suspends> because the creature has to load. You can only call it from a <suspends> context (like OnBegin or inside spawn{}). Calling it from a non-suspending event handler will not compile.
• SpawnAt returns ?agent, not agent. Always unwrap with if (Creature := MaybeCreature?). A false result means the device already hit its maximum spawn count — handle that branch.
• SpawnedEvent vs EliminatedEvent payloads differ. SpawnedEvent is listenable(agent) (handler param is a plain agent — no unwrap). EliminatedEvent is listenable(?agent) (handler param is ?agent — you MUST unwrap, and false means an environmental/vehicle kill).
• Trigger handlers also hand you ?agent. trigger_device.TriggeredEvent gives (Agent : ?agent); unwrap with if (A := Agent?) if you need the player who stepped on it.
• Every device must be an @editable field. Declaring @editable Placer : creature_placer_device = creature_placer_device{} then linking it in the Details panel is what connects your code to the real placed device.
• Spawn() vs SpawnAt(). Spawn() uses the device's own placed location and is instant. SpawnAt() overrides the position (and optionally rotation) and is asynchronous. Don't reach for SpawnAt just to use the device's spot — use Spawn().