implement interface: Contracts That Power Your Island Devices

Overview

A Verse interface is a named contract: it declares method signatures (and optionally default implementations) that any class can agree to honour by writing class(my_interface). When a class implements an interface, the compiler guarantees it provides every required method — so you can write code that works with any implementor, not just one specific class.

When to reach for it:

• You have several devices or manager classes that share a logical role (e.g. "things that can be activated by a player") but differ in what they actually do.
• You want a single handler to drive multiple device types without a chain of if/else type checks.
• You're building a reusable system (puzzle manager, quest tracker, score board) that shouldn't care which concrete device sits behind it.

The pirate-cove scenario used throughout this article: A sun-drenched dock has two activation sources — a barnacled button bolted to a sea-chest and a pressure trigger hidden under a plank. Both should unlock the same treasure vault door and flash a HUD message to the interacting pirate. An interface called activatable gives both sources a common Activate(Agent:agent):void method, and a single vault_manager device drives the whole thing.

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):

hud_message_device

Used to show custom HUD messages to one or more agents.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

trigger_device

Used to relay events to other linked devices.

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

trigger_device<public> := class<concrete><final>(trigger_base_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Below is the complete, compilable example. Read the line-by-line explanation that follows.

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

# ─── 1. Define the interface ───────────────────────────────────────────────
# Any class that implements `activatable` must provide Activate().
# We also supply a default label so simple implementors need not override it.
activatable := interface:
    # Concrete classes must implement this.
    Activate(Agent : agent) : void

    # Default implementation — classes may override.
    GetLabel() : string = "Activate"

# ─── 2. Implement the interface on a button wrapper ────────────────────────
# This thin wrapper class wires a button_device into the activatable contract.
button_activatable := class(activatable):
    Button : button_device

    Activate(Agent : agent) : void =
        # Re-enable the button so it can be used again after a reset
        Button.Enable()

    GetLabel() : override string = "Press to Unlock Vault"

# ─── 3. Implement the interface on a trigger wrapper ──────────────────────
trigger_activatable := class(activatable):
    Trigger : trigger_device

    Activate(Agent : agent) : void =
        # Fire the trigger programmatically so linked devices react
        Trigger.Trigger(Agent)

    GetLabel() : override string = "Step on the Plank"

# ─── 4. The vault manager device — the only creative_device placed in UEFN ─
vault_manager := class(creative_device):

    # ── Editable device references (drag-and-drop in UEFN Details panel) ──
    @editable
    DockButton : button_device = button_device{}

    @editable
    PlankTrigger : trigger_device = trigger_device{}

    @editable
    VaultUnlockTrigger : trigger_device = trigger_device{}

    @editable
    HudMessage : hud_message_device = hud_message_device{}

    # ── Localized text helpers ─────────────────────────────────────────────
    UnlockText<localizes>(S : string) : message = "{S}"
    HintText<localizes>(S : string) : message = "{S}"

    # ── Runtime state ──────────────────────────────────────────────────────
    var VaultOpen : logic = false

    # ── Entry point ────────────────────────────────────────────────────────
    OnBegin<override>()<suspends> : void =
        # Configure the button: 3-second hold, max 1 use (one-shot unlock)
        DockButton.SetInteractionText(HintText("Hold to Unlock the Vault"))
        DockButton.SetInteractionTime(3.0)
        DockButton.SetMaxTriggerCount(1)

        # Configure the trigger: allow only 1 activation, 2-second reset
        PlankTrigger.SetMaxTriggerCount(1)
        PlankTrigger.SetResetDelay(2.0)

        # Configure the HUD: show for 4 seconds
        HudMessage.SetDisplayTime(4.0)

        # Subscribe to both input sources
        DockButton.InteractedWithEvent.Subscribe(OnButtonPressed)
        PlankTrigger.TriggeredEvent.Subscribe(OnPlankTriggered)

    # ── Button handler ─────────────────────────────────────────────────────
    # InteractedWithEvent sends a plain `agent` (not ?agent)
    OnButtonPressed(Agent : agent) : void =
        # Build a button_activatable and call through the interface
        Source := button_activatable{Button := DockButton}
        HandleActivation(Agent, Source)

    # ── Trigger handler ────────────────────────────────────────────────────
    # TriggeredEvent sends `?agent` — unwrap before use
    OnPlankTriggered(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            Source := trigger_activatable{Trigger := PlankTrigger}
            HandleActivation(Agent, Source)

    # ── Shared logic driven by the interface ──────────────────────────────
    # This method doesn't know or care whether Source is a button or trigger.
    HandleActivation(Agent : agent, Source : activatable) : void =
        if (not VaultOpen):
            set VaultOpen = true

            # Call the interface method — works for any activatable
            Source.Activate(Agent)

            # Fire the vault unlock trigger so the door prop opens
            VaultUnlockTrigger.Trigger(Agent)

            # Show a personalised HUD message to the activating pirate
            HudMessage.Show(Agent, UnlockText("⚓ Vault Unlocked! Claim your treasure!"))

Line-by-line explanation

Common patterns

Pattern 1 — Query trigger state before firing

Before firing the vault trigger, check how many uses remain so you can show a different message on the last activation.

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

remaining_checker := class(creative_device):

    @editable
    ChestTrigger : trigger_device = trigger_device{}

    @editable
    HudMessage : hud_message_device = hud_message_device{}

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

    OnBegin<override>()<suspends> : void =
        # Allow exactly 3 activations, then the chest is empty
        ChestTrigger.SetMaxTriggerCount(3)
        ChestTrigger.SetResetDelay(1.0)
        ChestTrigger.TriggeredEvent.Subscribe(OnChestTriggered)

    OnChestTriggered(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            Remaining := ChestTrigger.GetTriggerCountRemaining()
            if (Remaining = 1):
                # Last loot drop — warn the crew!
                HudMessage.Show(Agent, LastChanceText("⚠ Last treasure in this chest!"))
            else:
                HudMessage.Show(Agent, NormalText("💰 Loot grabbed!"))
            # Fire the trigger so linked item-spawner devices react
            ChestTrigger.Trigger(Agent)

Pattern 2 — Button with dynamic interaction time and disable/enable cycle

A cannon-loading button on the pirate ship takes longer to "load" each round, and is temporarily disabled while the cannon fires.

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

cannon_loader := class(creative_device):

    @editable
    CannonButton : button_device = button_device{}

    @editable
    CannonTrigger : trigger_device = trigger_device{}

    @editable
    HudMessage : hud_message_device = hud_message_device{}

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

    var RoundNumber : int = 1

    OnBegin<override>()<suspends> : void =
        CannonButton.SetInteractionText(LoadingText("Hold to Load Cannon"))
        CannonButton.SetInteractionTime(2.0)
        # Unlimited uses — the cannon can fire all match
        CannonButton.SetMaxTriggerCount(0)
        CannonButton.InteractedWithEvent.Subscribe(OnCannonLoaded)

    OnCannonLoaded(Agent : agent) : void =
        # Disable button while cannon fires so crew can't double-load
        CannonButton.Disable()

        HudMessage.Show(Agent, FiringText("💥 FIRE!"))
        CannonTrigger.Trigger(Agent)

        # Increase load time each round (harder as game progresses)
        set RoundNumber = RoundNumber + 1
        NewTime := 2.0 + (RoundNumber * 0.5)
        CannonButton.SetInteractionTime(NewTime)

        # Re-enable after the cannon's transmit delay clears
        CurrentDelay := CannonTrigger.GetTransmitDelay()
        Sleep(CurrentDelay + 1.0)
        CannonButton.Enable()

    # Sleep requires a suspends context — spawn a task for the handler
    OnBegin<override>()<suspends> : void =
        CannonButton.SetInteractionText(LoadingText("Hold to Load Cannon"))
        CannonButton.SetInteractionTime(2.0)
        CannonButton.SetMaxTriggerCount(0)
        CannonButton.InteractedWithEvent.Subscribe(OnCannonLoadedSpawn)

    OnCannonLoadedSpawn(Agent : agent) : void =
        spawn { ReloadSequence(Agent) }

    ReloadSequence(Agent : agent)<suspends> : void =
        CannonButton.Disable()
        HudMessage.Show(Agent, FiringText("💥 FIRE!"))
        CannonTrigger.Trigger(Agent)
        set RoundNumber = RoundNumber + 1
        NewTime := 2.0 + (RoundNumber * 0.5)
        CannonButton.SetInteractionTime(NewTime)
        CurrentDelay := CannonTrigger.GetTransmitDelay()
        Sleep(CurrentDelay + 1.0)
        CannonButton.Enable()

Pattern 3 — HUD message lifecycle: Show, SetText, ClearAllMessages

A lighthouse beacon on the clifftop cycles through three announcements, then clears everything when the round ends.

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

lighthouse_announcer := class(creative_device):

    @editable
    RoundTrigger : trigger_device = trigger_device{}

    @editable
    Announcement : hud_message_device = hud_message_device{}

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

    OnBegin<override>()<suspends> : void =
        # Persist each message until we swap it
        Announcement.SetDisplayTime(0.0)
        RoundTrigger.TriggeredEvent.Subscribe(OnRoundEvent)

        # Kick off the announcement cycle
        spawn { AnnounceCycle() }

    OnRoundEvent(MaybeAgent : ?agent) : void =
        # When the round-end trigger fires, wipe all queued messages
        Announcement.ClearAllMessages()

    AnnounceCycle()<suspends> : void =
        # Phase 1 — boarding
        Announcement.SetText(Msg("🏴‍☠️ All pirates to the dock!"))
        Announcement.Show()
        Sleep(5.0)

        # Phase 2 — treasure hunt begins
        Announcement.SetText(Msg("⚓ The hunt for the Golden Anchor begins!"))
        Announcement.Show()
        Sleep(5.0)

        # Phase 3 — warning
        Announcement.SetText(Msg("⏳ 60 seconds remaining — find the vault!"))
        Announcement.Show()
        Sleep(60.0)

        # Round over — hide and clear
        Announcement.Hide()
        Announcement.ClearAllMessages()

Gotchas

1. message ≠ string — always use a <localizes> helper

Methods like SetInteractionText, SetText, and HudMessage.Show(Agent, Message, ...) take a message type, not a raw string. There is no StringToMessage function. Declare a localizes helper:

MyText<localizes>(S : string) : message = "{S}"
// then pass:
Button.SetInteractionText(MyText("Hold to Open"))

Passing a bare string literal will produce a compile error.

2. TriggeredEvent sends ?agent, InteractedWithEvent sends agent

trigger_device.TriggeredEvent is listenable(?agent) — the agent is optional because the trigger can fire from code with no player. Always unwrap:

OnTriggered(MaybeAgent : ?agent) : void =
    if (Agent := MaybeAgent?):
        # safe to use Agent here

button_device.InteractedWithEvent is listenable(agent) — a player must interact, so no unwrap needed.

3. Interface methods need no override keyword — wrapper class methods do

When you provide a default implementation in an interface and a class wants to replace it, use <override>:

GetLabel() : override string = "My Custom Label"

Forgetting <override> when a default exists, or adding it when there's no default, both cause compile errors.

4. SetMaxTriggerCount clamps differently per device

• button_device.SetMaxTriggerCount accepts 0–10000 (0 = unlimited).
• trigger_device.SetMaxTriggerCount clamps to [0, 20] (0 = unlimited).

Passing 50 to a trigger's SetMaxTriggerCount silently clamps to 20 — always check GetMaxTriggerCount() after setting if the exact value matters.

5. Handlers that need Sleep must be <suspends> — use spawn {}

Event handler callbacks (e.g. OnButtonPressed) are not <suspends> by default. If you need to Sleep inside a handler, spawn a separate async task:

OnButtonPressed(Agent : agent) : void =
    spawn { DelayedReset(Agent) }

DelayedReset(Agent : agent)<suspends> : void =
    Sleep(3.0)
    DockButton.Enable()

6. @editable fields must be declared inside the class(creative_device) body

You cannot reference a placed device from a bare variable or from inside an interface. Only creative_device subclasses support @editable fields that bind to UEFN-placed instances. Interface implementors that need device references must receive them as constructor fields (as shown in button_activatable{Button := DockButton}).