beacon_device: Guide Players to the Objective

Overview

The beacon_device shows an in-world visual effect and/or a HUD marker at a location in your map. Use it as a waypoint: "go here next", "the loot is this way", "defend this point". It solves the classic problem of players not knowing where to go.

What makes the beacon powerful from Verse is its show list. Beyond the device's Team Visibility settings, you can add specific agents to a private list — so a beacon can be shown to only one player (the carrier of a key, the chosen hunter, the next person in a relay) without affecting everyone else.

Reach for the beacon when you need a directional marker that you turn on/off or aim at individuals from code. Its whole API is four verbs: Enable, Disable, AddToShowList, RemoveFromShowList, plus RemoveAllFromShowList to clear everyone.

API Reference

beacon_device

Used to show an in world visual effect and/or a HUD marker at the desired location.

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

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

Methods (call these to make the device act):

Walkthrough

Let's build a "find the vault" beacon. The beacon at the vault stays hidden until a player steps on a trigger plate. When they do, we enable the beacon and add that player to the show list so only they get the waypoint. We also clear the list when the game starts so nobody sees a stale marker.

vault_beacon_device := class(creative_device):

    # The beacon placed at the vault location.
    @editable
    VaultBeacon : beacon_device = beacon_device{}

    # A button players interact with to "reveal" the vault.
    @editable
    RevealButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Start clean: the beacon is off and nobody is on the show list.
        VaultBeacon.Disable()
        VaultBeacon.RemoveAllFromShowList()

        # When a player interacts with the button, run OnReveal.
        RevealButton.InteractedWithEvent.Subscribe(OnReveal)

    # Event handler: a method at class scope, receives the interacting agent.
    OnReveal(Agent : agent) : void =
        # Turn the beacon on for the world/team-visibility rules...
        VaultBeacon.Enable()
        # ...and additionally show it to exactly this player.
        VaultBeacon.AddToShowList(Agent)

Line by line:

• @editable VaultBeacon : beacon_device = beacon_device{} — declares a field you wire to the placed beacon in UEFN's Details panel. You must declare the device as a field to call its methods; a bare beacon_device{}.Enable() won't reference your placed device.
• RevealButton : button_device — a second device field so we have something that fires an event with an agent.
• OnBegin<override>()<suspends> : void = — runs when the game starts. All setup goes here.
• VaultBeacon.Disable() — make sure the marker is off at round start.
• VaultBeacon.RemoveAllFromShowList() — wipe any leftover agents from the show list.
• RevealButton.InteractedWithEvent.Subscribe(OnReveal) — when a player uses the button, call OnReveal. InteractedWithEvent is listenable(agent), so the handler is handed a plain agent (already unwrapped, no ? needed here).
• OnReveal(Agent : agent) — a class method. VaultBeacon.Enable() turns the beacon on, and AddToShowList(Agent) shows it to that specific player.

Common patterns

Hide the beacon again with RemoveFromShowList

When the player reaches the objective (e.g. enters a capture area), stop showing them the waypoint so the HUD stays clean.

beacon_arrival_device := class(creative_device):

    @editable
    Beacon : beacon_device = beacon_device{}

    # When the player enters this zone, they've arrived.
    @editable
    Goal : capture_area_device = capture_area_device{}

    OnBegin<override>()<suspends> : void =
        Beacon.Enable()
        Goal.AgentEntersEvent.Subscribe(OnArrived)

    OnArrived(Agent : agent) : void =
        # This player no longer needs the marker.
        Beacon.RemoveFromShowList(Agent)

Toggle the beacon off for everyone with Disable

A phase-based mode might only want the beacon visible during a setup window. Disable it after a delay to retire the marker entirely.

timed_beacon_device := class(creative_device):

    @editable
    Beacon : beacon_device = beacon_device{}

    OnBegin<override>()<suspends> : void =
        # Beacon is visible for the first 30 seconds, then turns off.
        Beacon.Enable()
        Sleep(30.0)
        Beacon.Disable()

Clear all targeted players with RemoveAllFromShowList

Between relay rounds, reset who the beacon targets so the previous carrier doesn't keep their marker.

relay_reset_beacon_device := class(creative_device):

    @editable
    Beacon : beacon_device = beacon_device{}

    # A button the game host presses to start a fresh round.
    @editable
    NewRoundButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        NewRoundButton.InteractedWithEvent.Subscribe(OnNewRound)

    OnNewRound(Agent : agent) : void =
        # Wipe everyone off the private show list for a clean round.
        Beacon.RemoveAllFromShowList()
        Beacon.Enable()

Gotchas

• Show list vs. Team Visibility are separate. RemoveFromShowList only removes the agent from your private list — if that player still passes the beacon's Team/Class visibility settings, they keep seeing it. To fully hide for everyone, use Disable().
• The beacon has no events. Unlike buttons or capture areas, beacon_device exposes no listenables. You drive it entirely from other devices' events (button, trigger, capture area) — that's why the examples subscribe to a button or zone.
• You must declare an @editable field and wire it in UEFN. Calling beacon_device{}.Enable() on a freshly constructed value does nothing useful — only a field bound to a placed device controls a real beacon.
• Enable() doesn't add anyone to the show list. Enabling makes the device active under its visibility rules; if you want a specific player to see it regardless, you still need AddToShowList(Agent).
• Reset state in OnBegin. The show list can persist across rounds in some modes — call RemoveAllFromShowList() (and Disable() if appropriate) at start to avoid stale markers.
• Handlers are methods, not nested functions. Define OnReveal/OnArrived at class scope (4-space indent) and Subscribe to them inside OnBegin.