button_device: Interactive Buttons That Drive Game Logic

Overview

The button_device represents a physical interactable button placed in your island. When a player walks up to it and holds the interact key for the configured duration, the button fires InteractedWithEvent and sends the agent who pressed it.

When to reach for it:

• A vault door that only opens after a player presses a button for 3 seconds
• A one-time-use switch that arms a trap and then permanently disables itself
• A puzzle where the prompt text changes dynamically to hint at the next step
• Any situation where you need player-initiated, hold-to-confirm input

Unlike a trigger plate (which fires automatically on contact), the button requires deliberate player action and supports configurable hold time — making it ideal for high-stakes or gated interactions.

API Reference

button_device

Used to create a button which can trigger other devices when an agent interacts with it.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A Vault Door with a Timed Button and a Use Limit

You have a vault door made from a barrier device. Players must hold a button for 2 seconds to open it, but the button only works 3 times total (simulating a limited power supply). After each press, the prompt updates to show how many uses remain. On the final press, the button disables itself permanently.

Place a button_device, a barrier_device, and this Verse device in your island. Wire them up via the @editable fields in the Details panel.

vault_button_device := class(creative_device):

    # Wire this to the Button device placed in your level
    @editable
    VaultButton : button_device = button_device{}

    # Wire this to the Barrier device acting as the vault door
    @editable
    VaultDoor : barrier_device = barrier_device{}

    # Localized helper so we can pass dynamic strings as 'message'
    UpdatedPrompt<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Set a 2-second hold time — players must commit to opening the vault
        VaultButton.SetInteractionTime(2.0)

        # Cap the button at 3 total uses
        VaultButton.SetMaxTriggerCount(3)

        # Give players a clear initial prompt
        VaultButton.SetInteractionText(UpdatedPrompt("Open Vault (3 uses left)"))

        # Subscribe: every successful interaction calls OnVaultButtonPressed
        VaultButton.InteractedWithEvent.Subscribe(OnVaultButtonPressed)

    OnVaultButtonPressed(Interactor : agent) : void =
        # Disable the barrier so the vault door opens
        VaultDoor.Disable()

        # Check how many presses remain after this one
        Remaining := VaultButton.GetTriggerCountRemaining()

        if (Remaining > 0):
            # Update the prompt to reflect remaining uses
            VaultButton.SetInteractionText(UpdatedPrompt("Open Vault ({Remaining} uses left)"))
        else:
            # No uses left — disable the button so it can't be interacted with
            VaultButton.Disable()
            VaultButton.SetInteractionText(UpdatedPrompt("Vault Power Depleted"))

Line-by-line breakdown:

Common patterns

Pattern 1 — Toggle a device on/off with a single button

A player presses a button to toggle a storm controller on and off. Demonstrates Enable / Disable and the InteractedWithEvent handler pattern.

storm_toggle_device := class(creative_device):

    @editable
    ToggleButton : button_device = button_device{}

    @editable
    StormController : storm_controller_device = storm_controller_device{}

    PromptOn<localizes>(S : string) : message = "{S}"

    var StormActive : logic = false

    OnBegin<override>()<suspends> : void =
        ToggleButton.SetInteractionText(PromptOn("Activate Storm"))
        ToggleButton.InteractedWithEvent.Subscribe(OnTogglePressed)

    OnTogglePressed(Interactor : agent) : void =
        if (StormActive?):
            StormController.Deactivate()
            set StormActive = false
            ToggleButton.SetInteractionText(PromptOn("Activate Storm"))
        else:
            StormController.Activate()
            set StormActive = true
            ToggleButton.SetInteractionText(PromptOn("Deactivate Storm"))

Pattern 2 — Read interaction time and max count for a HUD display

Before the round starts, query the button's configured values and print them to the log for debugging or to feed into a UI widget. Demonstrates GetInteractionTime and GetMaxTriggerCount.

button_info_logger := class(creative_device):

    @editable
    InfoButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        HoldTime := InfoButton.GetInteractionTime()
        MaxUses  := InfoButton.GetMaxTriggerCount()

        # MaxUses == 0 means unlimited
        if (MaxUses = 0):
            Print("Button hold time: {HoldTime}s | Uses: unlimited")
        else:
            Print("Button hold time: {HoldTime}s | Max uses: {MaxUses}")

        InfoButton.InteractedWithEvent.Subscribe(OnInfoButtonPressed)

    OnInfoButtonPressed(Interactor : agent) : void =
        Remaining := InfoButton.GetTriggerCountRemaining()
        Print("Button pressed. Uses remaining: {Remaining}")

Pattern 3 — Race two buttons: first player to press wins

Two teams compete to press their respective buttons first. Uses race so whichever button fires first wins and the other is immediately disabled. Demonstrates Disable and concurrent event awaiting.

first_press_wins_device := class(creative_device):

    @editable
    RedButton  : button_device = button_device{}

    @editable
    BlueButton : button_device = button_device{}

    @editable
    RedReward  : item_granter_device = item_granter_device{}

    @editable
    BlueReward : item_granter_device = item_granter_device{}

    WinText<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        RedButton.SetInteractionText(WinText("Press for Red Team!"))
        BlueButton.SetInteractionText(WinText("Press for Blue Team!"))

        # Race: whichever branch completes first wins; the other is cancelled
        race:
            block:
                RedWinner := RedButton.InteractedWithEvent.Await()
                BlueButton.Disable()
                RedReward.GrantItem(RedWinner)
                RedButton.SetInteractionText(WinText("Red Team Wins!"))
            block:
                BlueWinner := BlueButton.InteractedWithEvent.Await()
                RedButton.Disable()
                BlueReward.GrantItem(BlueWinner)
                BlueButton.SetInteractionText(WinText("Blue Team Wins!"))

Gotchas

1. @editable is mandatory — you cannot construct a live device in code

You must declare button_device as an @editable field inside your class(creative_device). Writing MyButton := button_device{} inside OnBegin gives you a disconnected default object — it is not the device placed in your level and none of its events will fire.

# WRONG — this is a blank object, not your placed device
OnBegin<override>()<suspends> : void =
    MyButton := button_device{}
    MyButton.InteractedWithEvent.Subscribe(OnPressed)  # never fires

# RIGHT — declare at class scope
@editable
MyButton : button_device = button_device{}

2. SetInteractionText requires a message, not a string

The parameter type is message (a localized type). Passing a raw string literal causes a compile error. Always wrap with a <localizes> helper:

# WRONG
MyButton.SetInteractionText("Open Door")  # compile error: string ≠ message

# RIGHT
DoorPrompt<localizes>(S : string) : message = "{S}"
MyButton.SetInteractionText(DoorPrompt("Open Door"))

3. GetTriggerCountRemaining returns 0 for unlimited buttons

If GetMaxTriggerCount() returns 0 (meaning no limit), then GetTriggerCountRemaining() also returns 0 — not a large number. Always check GetMaxTriggerCount() first before interpreting the remaining count:

if (MyButton.GetMaxTriggerCount() = 0):
    # Unlimited — remaining count is meaningless
else:
    Remaining := MyButton.GetTriggerCountRemaining()
    # Safe to use Remaining here

4. InteractedWithEvent fires AFTER the full hold time

The event does not fire on button-down — it fires only after the player holds for the full GetInteractionTime() duration. If you call SetInteractionTime(5.0), your handler won't run until 5 seconds of uninterrupted holding. Design your UX accordingly — if the time is too long, players will assume the button is broken.

5. SetMaxTriggerCount clamps to 0–10000

Passing a value outside [0, 10000] is clamped. Pass 0 explicitly for unlimited. There is no -1 sentinel — using negative values is undefined behavior.

6. Event handlers are class-scope methods, not lambdas

Subscribe takes a method reference. Define your handler as a method on the class (not inside OnBegin) and pass it by name:

# WRONG — anonymous function inside OnBegin won't compile as a subscriber
MyButton.InteractedWithEvent.Subscribe((A : agent) => { ... })

# RIGHT — class-scope method
OnPressed(Interactor : agent) : void =
    # your logic here

OnBegin<override>()<suspends> : void =
    MyButton.InteractedWithEvent.Subscribe(OnPressed)