map_indicator_device: Custom Map Markers That React to Your Game

Overview

The map_indicator_device is a placeable Creative device that renders a custom point-of-interest icon on both the minimap and the full overview map. You position it in the level editor, configure its icon, color, and label in the Details panel, and then drive its visibility and pulse behavior entirely from Verse at runtime.

When to reach for it:

• Marking bomb sites, capture points, or VIP targets that should appear or disappear based on game state.
• Guiding players toward an objective with a directional pulse arrow (like a waypoint).
• Toggling map markers on/off as rounds progress (e.g., reveal the extraction zone only after a key event).

The device has no events — it is purely output. You react to other devices (triggers, capture areas, buttons) and call map_indicator_device methods to update the map accordingly.

API Reference

map_indicator_device

Used to create custom points of interest and markers on the minimap and overview map.

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

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

Methods (call these to make the device act):

Walkthrough

Scenario: A two-phase heist. Phase 1 — the vault marker is hidden. When a player steps on a pressure plate, the vault map_indicator_device enables and every player receives a directional objective pulse pointing toward it. Phase 2 — when the same player steps off (or a second plate is triggered), the pulse deactivates and the marker is disabled again.

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

# heist_map_controller — place this Verse device in your level,
# then wire up the editable fields in the Details panel.
heist_map_controller := class(creative_device):

    # The map indicator sitting above the vault door in the level.
    @editable
    VaultIndicator : map_indicator_device = map_indicator_device{}

    # A trigger plate the player steps on to "discover" the vault.
    @editable
    DiscoveryPlate : trigger_device = trigger_device{}

    # A second plate (or the same plate's exit) that resets the state.
    @editable
    ResetPlate : trigger_device = trigger_device{}

    # Track the agent who triggered the discovery so we can deactivate their pulse.
    var ActiveAgent : ?agent = false

    OnBegin<override>()<suspends> : void =
        # Start with the vault hidden — players don't know where it is yet.
        VaultIndicator.Disable()

        # Subscribe to both plates.
        DiscoveryPlate.TriggeredEvent.Subscribe(OnVaultDiscovered)
        ResetPlate.TriggeredEvent.Subscribe(OnVaultReset)

    # Called when a player steps on the discovery plate.
    # TriggeredEvent sends ?agent, so we unwrap it before use.
    OnVaultDiscovered(MaybeAgent : ?agent) : void =
        if (A := MaybeAgent?):
            # Show the vault icon on every player's map.
            VaultIndicator.Enable()

            # Fire a directional pulse FROM the triggering player TOWARD the vault.
            VaultIndicator.ActivateObjectivePulse(A)

            # Remember who triggered so we can clean up later.
            set ActiveAgent = option{A}

    # Called when the reset plate fires — hide the vault again.
    OnVaultReset(MaybeAgent : ?agent) : void =
        # Deactivate the pulse for whoever currently has it.
        if (A := ActiveAgent?):
            VaultIndicator.DeactivateObjectivePulse(A)

        # Hide the marker entirely.
        VaultIndicator.Disable()

        set ActiveAgent = false

Line-by-line explanation:

Common patterns

Pattern 1 — Round-based visibility toggle

Enable a capture-point marker at round start and disable it when the round ends. Uses Enable and Disable.

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

capture_point_marker_controller := class(creative_device):

    @editable
    CapturePointIndicator : map_indicator_device = map_indicator_device{}

    # A trigger that fires when the round starts (e.g., from a Class Designer or Game Manager).
    @editable
    RoundStartTrigger : trigger_device = trigger_device{}

    # A trigger that fires when the round ends.
    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Hidden until the round officially begins.
        CapturePointIndicator.Disable()
        RoundStartTrigger.TriggeredEvent.Subscribe(OnRoundStart)
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundStart(MaybeAgent : ?agent) : void =
        # Reveal the capture point on the map for everyone.
        CapturePointIndicator.Enable()

    OnRoundEnd(MaybeAgent : ?agent) : void =
        # Hide it once the round is over — clean slate for the next round.
        CapturePointIndicator.Disable()

Pattern 2 — Per-player objective pulse on item pickup

When a player picks up a flag (simulated here by a trigger), activate a pulse pointing them toward the drop-off zone. Uses ActivateObjectivePulse and DeactivateObjectivePulse.

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

flag_carrier_pulse_controller := class(creative_device):

    # Indicator placed at the drop-off zone.
    @editable
    DropOffIndicator : map_indicator_device = map_indicator_device{}

    # Fires when a player picks up the flag item.
    @editable
    FlagPickupTrigger : trigger_device = trigger_device{}

    # Fires when the flag is scored or dropped.
    @editable
    FlagScoredTrigger : trigger_device = trigger_device{}

    var CarryingAgent : ?agent = false

    OnBegin<override>()<suspends> : void =
        DropOffIndicator.Enable()  # Drop-off is always visible on the map.
        FlagPickupTrigger.TriggeredEvent.Subscribe(OnFlagPickedUp)
        FlagScoredTrigger.TriggeredEvent.Subscribe(OnFlagScored)

    OnFlagPickedUp(MaybeAgent : ?agent) : void =
        if (A := MaybeAgent?):
            # Show a directional pulse arrow on the carrier's screen toward the drop-off.
            DropOffIndicator.ActivateObjectivePulse(A)
            set CarryingAgent = option{A}

    OnFlagScored(MaybeAgent : ?agent) : void =
        if (A := CarryingAgent?):
            # Remove the pulse now that the flag has been scored or dropped.
            DropOffIndicator.DeactivateObjectivePulse(A)
        set CarryingAgent = false

Pattern 3 — Multi-site bomb markers (enable/disable independently)

Two bomb sites, each with its own map_indicator_device. Enable both at match start; disable a site's marker when it is defused. Demonstrates calling Enable and Disable on multiple independent indicators.

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

bomb_site_marker_controller := class(creative_device):

    @editable
    SiteAIndicator : map_indicator_device = map_indicator_device{}

    @editable
    SiteBIndicator : map_indicator_device = map_indicator_device{}

    # Triggers wired to defuse completion logic for each site.
    @editable
    SiteADefusedTrigger : trigger_device = trigger_device{}

    @editable
    SiteBDefusedTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Both sites visible from match start.
        SiteAIndicator.Enable()
        SiteBIndicator.Enable()

        SiteADefusedTrigger.TriggeredEvent.Subscribe(OnSiteADefused)
        SiteBDefusedTrigger.TriggeredEvent.Subscribe(OnSiteBDefused)

    OnSiteADefused(MaybeAgent : ?agent) : void =
        # Remove Site A from the map — it's no longer a threat.
        SiteAIndicator.Disable()

    OnSiteBDefused(MaybeAgent : ?agent) : void =
        SiteBIndicator.Disable()

Gotchas

1. Always declare the device as @editable

You cannot write map_indicator_device{} inline and call methods on it at runtime — the instance must be the one you placed in the UEFN level. Declare it as an @editable field and assign it in the Details panel. A bare map_indicator_device{} in code creates a detached, non-functional object.

2. TriggeredEvent delivers ?agent, not agent

trigger_device.TriggeredEvent is a listenable(?agent). Your handler signature must be (MaybeAgent : ?agent), and you must unwrap with if (A := MaybeAgent?): before passing A to ActivateObjectivePulse or DeactivateObjectivePulse. Passing the raw ?agent directly is a compile error.

3. ActivateObjectivePulse is per-agent

ActivateObjectivePulse(Agent) attaches the directional pulse to one specific player. If you want every player to see a pulse, you must iterate over all players and call it for each one. Similarly, DeactivateObjectivePulse only removes the pulse for the agent you pass — other players keep theirs.

4. Enable/Disable affect all players simultaneously

Unlike the pulse methods, Enable and Disable are global — they show or hide the marker on everyone's map at once. There is no per-player visibility toggle in the current API.

5. Devices start in the state you set in the Details panel

If you leave the device Enabled in the editor and call Disable() in OnBegin, there will be one frame where the marker is visible. For a clean hidden-at-start experience, also set the device to Disabled in the Details panel so it never flickers on.

6. No events on this device

map_indicator_device has zero events — it cannot tell you when a player looks at the marker or interacts with it. Combine it with trigger_device, capture_area_device, or button_device to react to player actions.