capture_item_spawner_device: Flags, Idols, and Capture-the-Objective

Overview

The capture_item_spawner_device spawns and tracks one item as a game objective — think the flag in Capture-the-Flag, an idol in a heist mode, or a glowing relic an escort team must carry home. Unlike the generic item_spawner_device (which just hands out weapons/consumables that players keep), the capture spawner cares about the item's lifecycle as an objective: who picked it up, who dropped it, who returned it to base, and who finally captured it.

Reach for this device when:

• You're building a CTF / Steal-the-Diamond / King-of-the-Hill-with-an-object mode.
• You need to award points the moment an objective is captured.
• You want to show "BLUE TEAM HAS THE FLAG!" the instant someone grabs it.
• You want to disable the objective during a setup phase, then enable it when the round starts.

The Verse surface is small and event-driven: four events (ItemCapturedEvent, ItemPickedUpEvent, ItemDroppedEvent, ItemReturnedEvent) plus Enable/Disable. Each event sends you the agent involved, so you can credit the right player or team. The closely related item_spawner_device rounds out this article for when you also want to respawn loot on a timer.

API Reference

capture_item_spawner_device

Spawns and tracks a single item as a game objective (e.g. flag).

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

item_spawner_device

Used to configuration and spawn items that players can pick up and use.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from base_item_spawner_device.

item_spawner_device<public> := class<concrete><final>(base_item_spawner_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a Steal-the-Idol objective. An idol sits on a pedestal. When a player picks it up we flash a HUD message and start a map indicator; if they drop it we warn the field; if they carry it to the enemy base and capture it we award score; if a defender returns it we announce the recovery. We also keep the idol disabled until we manually enable it at round start.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Game }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Localized helper: `message`-typed params need a localizes function, NOT a raw string.
idol_msg<localizes>(S:string):message = "{S}"

steal_the_idol := class(creative_device):

    # The objective spawner. Set this to your placed Capture Item Spawner in the Details panel.
    @editable
    IdolSpawner:capture_item_spawner_device = capture_item_spawner_device{}

    # HUD message device used to broadcast objective status to everyone.
    @editable
    StatusHud:hud_message_device = hud_message_device{}

    # Score manager to reward the capturing player's team.
    @editable
    CaptureScore:score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends>:void =
        # Keep the idol locked during setup, then arm it for the round.
        IdolSpawner.Disable()
        Sleep(3.0)
        IdolSpawner.Enable()

        # Wire each lifecycle event to its handler.
        IdolSpawner.ItemPickedUpEvent.Subscribe(OnIdolPickedUp)
        IdolSpawner.ItemDroppedEvent.Subscribe(OnIdolDropped)
        IdolSpawner.ItemReturnedEvent.Subscribe(OnIdolReturned)
        IdolSpawner.ItemCapturedEvent.Subscribe(OnIdolCaptured)

    # Fired when an agent grabs the idol off the pedestal.
    OnIdolPickedUp(Agent:agent):void =
        StatusHud.Show(idol_msg("The Idol has been stolen! Stop the carrier!"))

    # Fired when the carrier drops the idol (eliminated, or manually dropped).
    OnIdolDropped(Agent:agent):void =
        StatusHud.Show(idol_msg("The Idol was dropped! Grab it or return it!"))

    # Fired when a defender returns the idol to its home pedestal.
    OnIdolReturned(Agent:agent):void =
        StatusHud.Show(idol_msg("The Idol has been returned to its pedestal."))

    # Fired when the idol is successfully captured at the goal.
    OnIdolCaptured(Agent:agent):void =
        StatusHud.Show(idol_msg("IDOL CAPTURED! +100 points!"))
        # Credit the player who completed the capture.
        CaptureScore.SetScoreAward(100)
        CaptureScore.Activate(Agent)

Line by line:

• idol_msg<localizes>(S:string):message — HUD/message parameters require a localized value. This tiny function wraps any string. There is no StringToMessage.
• @editable IdolSpawner:capture_item_spawner_device — you MUST declare the device as an @editable field so you can bind it to the placed device in the Details panel. Calling methods on a bare local would fail with Unknown identifier.
• IdolSpawner.Disable() then Sleep(3.0) then Enable() — a clean setup phase. While disabled, no item is tracked; Enable spawns/arms the objective.
• .Subscribe(OnIdolPickedUp) — every event is a listenable(agent), so we subscribe a method that takes (Agent:agent). Handlers are ordinary class-scope methods.
• In OnIdolCaptured we award score to the exact agent who captured — this is why the device sends agents along with every event.

Common patterns

Pattern 1 — Award and re-arm on capture with ItemCapturedEvent

A minimal CTF scorer: each capture grants a point to the capturer, then re-enables the spawner for the next round of play.

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

ctf_scorer := class(creative_device):

    @editable
    FlagSpawner:capture_item_spawner_device = capture_item_spawner_device{}

    @editable
    PointAward:score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends>:void =
        FlagSpawner.Enable()
        FlagSpawner.ItemCapturedEvent.Subscribe(OnCaptured)

    OnCaptured(Agent:agent):void =
        PointAward.Activate(Agent)
        # Re-arm the objective so a fresh flag spawns for the next push.
        FlagSpawner.Disable()
        FlagSpawner.Enable()

Pattern 2 — Reacting to drops with ItemDroppedEvent

When a carrier is eliminated the idol drops. Here we light up a debug sphere where it happens (a quick visual placeholder you could swap for VFX) and unwrap the player from the agent.

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

drop_watcher := class(creative_device):

    @editable
    Spawner:capture_item_spawner_device = capture_item_spawner_device{}

    @editable
    AlarmVfx:vfx_spawner_device = vfx_spawner_device{}

    OnBegin<override>()<suspends>:void =
        Spawner.Enable()
        Spawner.ItemDroppedEvent.Subscribe(OnDropped)

    OnDropped(Agent:agent):void =
        # Pulse an alarm VFX whenever the objective hits the ground.
        AlarmVfx.Restart()

Pattern 3 — Timed loot with item_spawner_device (SetTimeBetweenSpawns / SetEnableRespawnTimer)

The sibling item_spawner_device doesn't track captures, but it can respawn loot on a timer and cycle through configured items — handy for supply-drop weapons next to your objective. Note SetEnableRespawnTimer takes a logic.

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

supply_drop := class(creative_device):

    @editable
    LootSpawner:item_spawner_device = item_spawner_device{}

    OnBegin<override>()<suspends>:void =
        # Turn on timed respawns, 15s between pickups.
        LootSpawner.SetEnableRespawnTimer(true)
        LootSpawner.SetTimeBetweenSpawns(15.0)
        LootSpawner.Enable()
        LootSpawner.SpawnItem()

        # When someone grabs the loot, rotate to a different weapon for next time.
        LootSpawner.ItemPickedUpEvent.Subscribe(OnLootGrabbed)

    OnLootGrabbed(Agent:agent):void =
        LootSpawner.CycleToNextItem()

Gotchas

• Bind the @editable field. Declaring capture_item_spawner_device{} only gives you a placeholder. You must drag your placed device into the Details panel slot, or the events never fire because there's no real device behind the field.
• message is not a string. hud_message_device.Show wants a message. Use a <localizes> helper (idol_msg("...")) — passing a raw "..." won't compile, and there is no StringToMessage.
• Every event hands you an agent, not a player. If you need player/character APIs, unwrap: if (Char := Agent.GetFortCharacter[]) { ... }. For score awards you can pass the agent straight through.
• Disable resets the objective. Disabling the capture spawner stops tracking and clears the current item; re-Enable to spawn a fresh one. Use this for round resets rather than expecting the same physical flag to persist.
• SetEnableRespawnTimer is logic, not a number. On the item_spawner_device, pass true/false, then set the duration with SetTimeBetweenSpawns(float). Verse won't auto-convert an int — use 15.0, never 15.
• Capture vs. pickup are different events. Picking the item up (ItemPickedUpEvent) is not the same as scoring it (ItemCapturedEvent). Award points on captured, broadcast warnings on picked up.
• The capture spawner has no SpawnItem. Only the generic item_spawner_device exposes SpawnItem/CycleToNextItem. The capture spawner arms its single objective via Enable.