signal_remote_manager_device: Player-Triggered Remote Signals

Overview

The Signal Remote Manager device listens for a player pressing the Primary or Secondary signal on a Signal Remote item they're holding. Each press fires a Verse event that hands you the agent who triggered it, so you can run any logic you want — open a door for that player, grant them an item, start a cinematic, or detonate a trap.

Think of it as a wireless remote button the player carries around. Unlike a trigger_device (which needs the player to walk onto a pad) or a button_device (which needs the player to stand in front of it), the Signal Remote works from anywhere on the map as long as the player has the item equipped.

Reach for this device when:

• You want a player to summon something on demand (a vehicle, a lift, a drop).
• You have a "detonator" mechanic — press to blow a bridge.
• You want two distinct actions from one item: Primary = call elevator up, Secondary = call it down.

The device also exposes Enable() and Disable() so you can gate whether the remote does anything — useful for cooldowns or phase-gated abilities.

API Reference

signal_remote_manager_device

Used to trigger a custom response to a Primary or Secondary signal, sent by a Signal Remote item.

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

signal_remote_manager_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 summon remote. A player carrying a Signal Remote presses Primary to open a vault door (we'll use a prop_mover_device standing in for the door rig — but here we keep it concrete with a barrier_device style door we toggle). To keep this fully runnable against real devices, we'll drive a prop_mover_device for the door and an item_granter_device to reward the player.

Flow:

1. Player presses Primary → open the vault (move the door) and grant a reward to that player.
2. Player presses Secondary → close the vault again.
3. After the first open, we Disable() the manager briefly so it can't be spammed, then Enable() it again.

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

# A vault that players open with a Signal Remote item.
vault_remote_device := class(creative_device):

    # The manager that listens for Signal Remote button presses.
    @editable
    SignalManager : signal_remote_manager_device = signal_remote_manager_device{}

    # The door we slide open / closed.
    @editable
    VaultDoor : prop_mover_device = prop_mover_device{}

    # Hands the player a reward when they open the vault.
    @editable
    RewardGranter : item_granter_device = item_granter_device{}

    OnBegin<override>()<suspends>:void =
        # React to the two remote buttons.
        SignalManager.PrimarySignalEvent.Subscribe(OnPrimaryPressed)
        SignalManager.SecondarySignalEvent.Subscribe(OnSecondaryPressed)

    # Called when a player presses PRIMARY on their Signal Remote.
    OnPrimaryPressed(Agent : agent) : void =
        Print("Primary pressed - opening vault")
        # Slide the door open.
        VaultDoor.Begin()
        # Reward the player who pressed it.
        RewardGranter.GrantItem(Agent)
        # Briefly lock the remote so it can't be spammed.
        StartCooldown()

    # Called when a player presses SECONDARY on their Signal Remote.
    OnSecondaryPressed(Agent : agent) : void =
        Print("Secondary pressed - closing vault")
        # Send the door back the other way.
        VaultDoor.End()

    # Disable the manager for 5 seconds, then re-enable it.
    StartCooldown()<suspends> : void =
        SignalManager.Disable()
        Sleep(5.0)
        SignalManager.Enable()

Line by line:

• @editable SignalManager : signal_remote_manager_device = signal_remote_manager_device{} — declares the field UEFN will let you point at your placed manager device. You must do this to call its methods; a bare signal_remote_manager_device.Enable() would fail with Unknown identifier.
• VaultDoor and RewardGranter are two more devices we drive in response — the manager is the input, these are the outputs.
• In OnBegin, we subscribe two handler methods to the two events. PrimarySignalEvent and SecondarySignalEvent are both listenable(agent), so each handler receives an agent directly.
• OnPrimaryPressed(Agent : agent) — the parameter Agent is the player who pressed the remote. We Begin() the prop mover to open the door and call GrantItem(Agent) to reward that specific player.
• StartCooldown() is a <suspends> helper: it Disable()s the manager, Sleeps 5 seconds, then Enable()s it. Because OnPrimaryPressed is a plain handler (not suspending), we can still call StartCooldown() — Verse spawns it as concurrent work. (If you want strict control, wrap it in spawn{ StartCooldown() }.)
• OnSecondaryPressed simply calls End() on the prop mover to slide the door closed.

The key point: the manager event gives you the agent, and you forward that agent to whatever device acts on the player.

Common patterns

Primary signal only — a panic teleport button

Give players a Signal Remote and let Primary instantly teleport them to safety. We only subscribe to the one event we care about.

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

panic_button_device := class(creative_device):

    @editable
    SignalManager : signal_remote_manager_device = signal_remote_manager_device{}

    @editable
    SafeZone : teleporter_device = teleporter_device{}

    OnBegin<override>()<suspends>:void =
        SignalManager.PrimarySignalEvent.Subscribe(OnPanic)

    OnPanic(Agent : agent) : void =
        # Teleport the player who hit Primary to the safe zone.
        SafeZone.Teleport(Agent)

Secondary signal — a one-shot self-destruct that disables itself

Here Secondary triggers an explosion and then Disable()s the manager so it can never fire again — a single-use device.

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

self_destruct_device := class(creative_device):

    @editable
    SignalManager : signal_remote_manager_device = signal_remote_manager_device{}

    @editable
    Explosive : explosive_device = explosive_device{}

    OnBegin<override>()<suspends>:void =
        SignalManager.SecondarySignalEvent.Subscribe(OnDetonate)

    OnDetonate(Agent : agent) : void =
        # Blow the charge, then lock the remote forever.
        Explosive.Explode()
        SignalManager.Disable()

Both signals on one manager — a two-way elevator call

Primary calls the lift up, Secondary calls it down. One remote, two behaviours.

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

elevator_remote_device := class(creative_device):

    @editable
    SignalManager : signal_remote_manager_device = signal_remote_manager_device{}

    @editable
    Lift : prop_mover_device = prop_mover_device{}

    OnBegin<override>()<suspends>:void =
        SignalManager.PrimarySignalEvent.Subscribe(OnCallUp)
        SignalManager.SecondarySignalEvent.Subscribe(OnCallDown)

    OnCallUp(Agent : agent) : void =
        Lift.Begin()   # move toward the up target

    OnCallDown(Agent : agent) : void =
        Lift.End()     # move back toward the start

Gotchas

• The player needs a Signal Remote item. The manager does nothing on its own — a player must actually have a Signal Remote in their inventory and press its Primary/Secondary action. Grant it with an Item Granter or place it in a chest. No item = no events.
• You must declare the device as an @editable field. Calling signal_remote_manager_device.Enable() directly fails with Unknown identifier. Declare @editable SignalManager : signal_remote_manager_device = signal_remote_manager_device{} and assign the placed device in the details panel.
• The event gives you the agent — use it. PrimarySignalEvent is listenable(agent), so your handler signature is (Agent : agent). Forward that agent to player-specific calls like GrantItem(Agent) or Teleport(Agent), not some global action.
• Disable() stops the events from firing. While disabled, pressing the remote does nothing — handy for cooldowns and one-shot devices. Remember to Enable() again if you want it back. A disabled manager will silently swallow presses, which can look like a bug if you forget.
• Subscribe in OnBegin, define handlers as class methods. Event handlers are methods at class scope (4-space indent); subscribe to them inside OnBegin (8-space indent). Forgetting to subscribe means your code never runs even though it compiles.
• Plain handlers can't directly Sleep. Event handler methods are not <suspends>. To do timed work (like a cooldown), call a separate <suspends> helper or wrap timed work in spawn{ ... }.