item_placer_device: Spawning Pickups On Demand

Overview

The item_placer_device represents a single pickup item placed in the world. By default it can be configured in the UEFN editor to start enabled (visible and collectable) or disabled (invisible and uncollectable). At runtime your Verse code can call Enable() to make the item appear and Disable() to remove it — no respawn logic required on your end.

When to reach for it:

• A chest room that should only reveal its loot after all enemies are defeated.
• A timed challenge where a power-up spawns at the halfway mark.
• A puzzle map where each solved room unlocks a new item pickup.
• A round-based game that resets all pickups between rounds.

Because the device has no events of its own, you pair it with other devices (trigger pads, buttons, creature placers, etc.) that fire the signal your Verse code listens to.

API Reference

item_placer_device

Allows pickup items to be placed in the world..

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

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

Methods (call these to make the device act):

Walkthrough

Scenario: A vault room. When a player steps on a pressure plate, the vault door opens (handled elsewhere) and two weapon pickups appear. If the player steps off the plate, the pickups disappear again — keeping the loot tantalizingly gated.

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

# Place this Verse device in your UEFN level, then wire up the
# @editable fields in the Details panel.
vault_loot_manager := class(creative_device):

    # The pressure plate that guards the vault.
    @editable
    Plate : trigger_device = trigger_device{}

    # Two weapon pickups inside the vault — start them DISABLED
    # in the item_placer_device User Options so they are hidden
    # at match start.
    @editable
    WeaponPickupA : item_placer_device = item_placer_device{}

    @editable
    WeaponPickupB : item_placer_device = item_placer_device{}

    # Called once when the match begins.
    OnBegin<override>()<suspends> : void =
        # Subscribe to the plate's triggered event so we know
        # when a player steps on it.
        Plate.TriggeredEvent.Subscribe(OnPlateTriggered)

    # Handler fires every time an agent steps on the plate.
    # The plate sends a ?agent, so we receive that type.
    OnPlateTriggered(TriggeringAgent : ?agent) : void =
        # Unwrap the optional agent — we only care that
        # *someone* stepped on the plate.
        if (A := TriggeringAgent?):
            # Reveal both weapon pickups inside the vault.
            WeaponPickupA.Enable()   # item becomes visible + collectable
            WeaponPickupB.Enable()

Line-by-line breakdown:

Common patterns

Pattern 1 — Hide pickups at round end, restore at round start

A round manager disables all pickups when the round ends and re-enables them when the next round begins.

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

round_pickup_reset := class(creative_device):

    # The device that signals round end / round start.
    @editable
    RoundManager : round_settings_device = round_settings_device{}

    # All pickups that should reset each round.
    @editable
    Pickups : []item_placer_device = array{}

    OnBegin<override>()<suspends> : void =
        RoundManager.RoundEndedEvent.Subscribe(OnRoundEnded)
        RoundManager.RoundBeganEvent.Subscribe(OnRoundBegan)

    # When the round ends, hide every pickup so players
    # cannot grab loot during the intermission.
    OnRoundEnded(RoundIndex : int) : void =
        for (Pickup : Pickups):
            Pickup.Disable()

    # When the next round starts, restore all pickups.
    OnRoundBegan(RoundIndex : int) : void =
        for (Pickup : Pickups):
            Pickup.Enable()

Key idea: Store multiple item_placer_device references in an array and loop over them — one Enable() or Disable() call per element.

Pattern 2 — Timed pickup reveal with a countdown

A power-up only appears 30 seconds into the match, giving early-game players time to position themselves.

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

timed_powerup_reveal := class(creative_device):

    # The special power-up item — start DISABLED in editor.
    @editable
    PowerUp : item_placer_device = item_placer_device{}

    # How many seconds to wait before the pickup appears.
    @editable
    DelaySeconds : float = 30.0

    OnBegin<override>()<suspends> : void =
        # Suspend this coroutine for the configured delay,
        # then reveal the pickup.
        Sleep(DelaySeconds)
        PowerUp.Enable()

Key idea: Sleep(DelaySeconds) inside a <suspends> coroutine is the idiomatic Verse timer. After the delay, Enable() makes the item appear with no extra wiring needed.

Pattern 3 — Toggle pickup with a button (Enable then Disable cycle)

A button in a prop-hunt map alternately reveals and hides a decoy item, letting the host troll hunters.

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

decoy_toggle := class(creative_device):

    @editable
    ToggleButton : button_device = button_device{}

    # The decoy item pickup — start ENABLED so it is visible.
    @editable
    DecoyItem : item_placer_device = item_placer_device{}

    # Track whether the item is currently visible.
    var IsVisible : logic = true

    OnBegin<override>()<suspends> : void =
        ToggleButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    OnButtonPressed(Agent : agent) : void =
        if (IsVisible?):
            DecoyItem.Disable()   # hide the decoy
            set IsVisible = false
        else:
            DecoyItem.Enable()    # show the decoy
            set IsVisible = true

Key idea: A var logic flag tracks state so each press flips between Enable() and Disable(), demonstrating both methods in a single device.

Gotchas

1. Set the initial state in the editor, not just in code

If you want a pickup to be hidden at match start, open the item_placer_device User Options in UEFN and set Enabled at Game Start to Off. Calling Disable() in OnBegin works too, but there is a single-frame window where the item is briefly visible before Verse runs. Setting it in the editor is the safest approach.

2. Enable() / Disable() are not <suspends> — call them freely

Both methods return void with no effects annotation, so you can call them inside any regular (non-suspending) handler or inside a loop without wrapping them in a spawn or sync block.

3. No events on this device — you must bring your own signal

item_placer_device has zero events. It cannot tell you when the item was picked up. If you need to react to a player collecting the item, pair it with an item_spawner_device (which has a PickedUpEvent) or use a trigger zone placed on top of the pickup.

4. One device = one item slot

Each item_placer_device manages exactly one configured item. To control multiple pickups independently, place multiple devices and expose each as a separate @editable field (or collect them in an []item_placer_device array as shown in Pattern 1).

5. @editable is mandatory

You cannot construct an item_placer_device in Verse code. You must place it in the UEFN level editor and reference it via an @editable field. A bare item_placer_device{} default is only valid as a field initializer — the real device is assigned when you drag-and-drop it in the Details panel.