item_spawner_device: Spawn Pickups and React to Grabs

Overview

The item_spawner_device is a Creative device that manages a configurable list of items (weapons, consumables, resources) and places them in the world as physical pickups players can collect. Out of the box you can configure it entirely in the UEFN editor, but Verse gives you runtime control:

• SpawnItem() — force an item to appear on the pad right now, regardless of timer state.
• CycleToNextItem() — advance to the next item in the device's Item List, so the next spawn drops a different pickup.
• SetEnableRespawnTimer() / SetTimeBetweenSpawns() — change whether and how quickly the pad auto-respawns after a pickup.
• ItemPickedUpEvent — a listenable(agent) you subscribe to so your code reacts the instant someone grabs the item.
• Enable() / Disable() — gate the device on or off (a disabled spawner won't auto-spawn and ignores SpawnItem() calls).

When to reach for it: timed loot drops that appear after an objective completes, puzzle rooms that reward a weapon when a switch is flipped, wave-based arenas that cycle through weapon tiers, or any scenario where you need programmatic control over what's on the ground and when.

API Reference

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

Scenario: Vault Weapon Dispenser

A player steps on a pressure plate to unlock a vault. The vault door opens, an item_spawner_device drops a legendary weapon, and when the player picks it up the spawner disables itself (one-time reward) and a scoreboard counter increments.

Place these devices in your level and wire them to the Verse device's @editable fields:

• One item_spawner_device (configure your weapon in its Item List; disable Spawn Item on Timer and Enabled at Game Start so Verse controls everything)
• One trigger_device (the pressure plate)

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

# Vault weapon dispenser: a trigger unlocks the spawner,
# and picking up the weapon disables it permanently.
vault_dispenser_device := class(creative_device):

    # Wire this to your Item Spawner in the UEFN editor.
    @editable
    WeaponSpawner : item_spawner_device = item_spawner_device{}

    # Wire this to your pressure-plate Trigger device.
    @editable
    VaultTrigger : trigger_device = trigger_device{}

    # Tracks how many players have claimed the vault weapon.
    var ClaimCount : int = 0

    OnBegin<override>()<suspends> : void =
        # The spawner starts disabled in the editor.
        # Subscribe to the trigger so stepping on the plate fires the vault.
        VaultTrigger.TriggeredEvent.Subscribe(OnVaultTriggered)

        # React when any player picks up the weapon.
        WeaponSpawner.ItemPickedUpEvent.Subscribe(OnWeaponPickedUp)

    # Called when a player steps on the pressure plate.
    # Agent is ?agent because trigger_device sends ?agent.
    OnVaultTriggered(MaybeAgent : ?agent) : void =
        # Enable the spawner and immediately pop the weapon onto the pad.
        WeaponSpawner.Enable()
        WeaponSpawner.SpawnItem()

    # Called the moment a player grabs the weapon.
    # ItemPickedUpEvent sends a plain `agent` (not optional).
    OnWeaponPickedUp(Collector : agent) : void =
        set ClaimCount = ClaimCount + 1
        # One-time reward: disable the spawner so it never auto-respawns.
        WeaponSpawner.Disable()

Line-by-line explanation:

Editor setup checklist

• Item Spawner → Enabled at Game Start: Off
• Item Spawner → Spawn Item on Timer: Off (Verse calls SpawnItem() manually)
• Item Spawner → Item List: add your legendary weapon
• Trigger → Trigger Delay: 0

Common patterns

Pattern 1 — Cycling loot tiers with CycleToNextItem

Each time a player picks up the current item, the spawner advances to the next item in its list and immediately re-spawns it. Great for a wave-based arena where weapon quality escalates.

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

# Each pickup cycles the spawner to the next (better) weapon
# and immediately re-spawns it for the next player.
escalating_loot_device := class(creative_device):

    @editable
    LootSpawner : item_spawner_device = item_spawner_device{}

    # How many items have been picked up this round.
    var PickupCount : int = 0

    OnBegin<override>()<suspends> : void =
        LootSpawner.SpawnItem()  # Kick off the first item immediately.
        LootSpawner.ItemPickedUpEvent.Subscribe(OnItemPickedUp)

    OnItemPickedUp(Collector : agent) : void =
        set PickupCount = PickupCount + 1
        # Advance the item list to the next configured item.
        LootSpawner.CycleToNextItem()
        # Immediately place the new item on the pad.
        LootSpawner.SpawnItem()

Pattern 2 — Runtime respawn timer control

At round start the spawner respawns quickly (5 s). After 60 seconds of game time, slow it down to 30 s to make loot scarcer. Uses SetEnableRespawnTimer, SetTimeBetweenSpawns, and GetTimeBetweenSpawns.

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

# Starts with a fast respawn timer, then slows it after 60 s.
dynamic_respawn_device := class(creative_device):

    @editable
    SupplySpawner : item_spawner_device = item_spawner_device{}

    # Fast phase duration in seconds.
    FastPhaseDuration : float = 60.0
    FastRespawnTime   : float = 5.0
    SlowRespawnTime   : float = 30.0

    OnBegin<override>()<suspends> : void =
        # Turn on the auto-respawn timer and set the fast interval.
        SupplySpawner.SetEnableRespawnTimer(Respawn := true)
        SupplySpawner.SetTimeBetweenSpawns(FastRespawnTime)
        SupplySpawner.Enable()
        SupplySpawner.SpawnItem()  # Spawn the first item right away.

        # Wait for the fast phase to end, then slow the timer.
        Sleep(FastPhaseDuration)
        SupplySpawner.SetTimeBetweenSpawns(SlowRespawnTime)

        # Confirm the new value (GetTimeBetweenSpawns is <transacts>).
        CurrentInterval := SupplySpawner.GetTimeBetweenSpawns()
        Print("Respawn interval is now {CurrentInterval} seconds")

Pattern 3 — Enable/Disable gating with ItemPickedUpEvent tracking

A control room button enables the spawner for a limited window. Once the item is picked up, the spawner is disabled and a flag is set so the button can't re-trigger it.

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

# A button opens a limited pickup window; once claimed, it's gone.
limited_pickup_device := class(creative_device):

    @editable
    PickupSpawner : item_spawner_device = item_spawner_device{}

    @editable
    ActivateButton : button_device = button_device{}

    # Prevent re-activation after the item has been claimed.
    var ItemClaimed : logic = false

    OnBegin<override>()<suspends> : void =
        PickupSpawner.Disable()  # Start disabled; button activates it.
        ActivateButton.InteractedWithEvent.Subscribe(OnButtonPressed)
        PickupSpawner.ItemPickedUpEvent.Subscribe(OnItemClaimed)

    OnButtonPressed(MaybeAgent : ?agent) : void =
        # Only allow activation if the item hasn't been claimed yet.
        if (ItemClaimed = false):
            PickupSpawner.Enable()
            PickupSpawner.SpawnItem()
            # Lock the button out for this window.
            ActivateButton.Disable()

    OnItemClaimed(Collector : agent) : void =
        set ItemClaimed = true
        PickupSpawner.Disable()

Gotchas

1. @editable is mandatory — bare identifiers won't compile

You cannot write item_spawner_device.SpawnItem() at the top level. Every placed device must be an @editable field inside your class(creative_device). Forgetting this causes an Unknown identifier compile error.

2. ItemPickedUpEvent sends agent, not ?agent

ItemPickedUpEvent is typed listenable(agent) — the handler receives a plain agent, not ?agent. You do not need to unwrap it with if (A := Agent?). Contrast this with trigger_device.TriggeredEvent which sends ?agent and does require unwrapping.

# CORRECT — plain agent, no unwrap needed
OnWeaponPickedUp(Collector : agent) : void =
    # use Collector directly

# WRONG — ?agent unwrap is unnecessary here and won't match the signature
OnWeaponPickedUp(MaybeCollector : ?agent) : void = ...

3. SpawnItem() on a disabled spawner does nothing

If you call SpawnItem() while the device is disabled, the item will not appear. Always call Enable() before SpawnItem() when the spawner starts disabled.

4. SetEnableRespawnTimer uses a named Respawn: parameter

The signature is SetEnableRespawnTimer((local:)Respawn:logic). The (local:) annotation means the label is Respawn at the call site:

Spawner.SetEnableRespawnTimer(Respawn := true)   # correct
Spawner.SetEnableRespawnTimer(true)               # also valid (positional)

5. GetTimeBetweenSpawns and GetEnableRespawnTimer are <transacts>

These getters carry the <transacts> effect, meaning they can only be called from a <transacts> or <decides> context, or directly in a normal expression context (which is fine in most cases). They are not <suspends>, so you don't need Sleep or spawn around them.

6. No int↔float auto-conversion

SetTimeBetweenSpawns takes a float. If you have an int duration, cast it explicitly:

DurationInt : int = 10
Spawner.SetTimeBetweenSpawns(Float[DurationInt])  # correct
Spawner.SetTimeBetweenSpawns(DurationInt)         # compile error

7. CycleToNextItem wraps around

When the spawner is on its last configured item, CycleToNextItem() wraps back to the first item in the list — plan your item ordering accordingly if you want an escalating difficulty curve.