player_marker_device: Tracking Targets on the Minimap

Overview

The player_marker_device puts a marker on an agent's position on the minimap and on-screen, and lets you configure what info that marker reveals: health/shield bars, distance to the marked player, a custom text label, and an icon/color. It's the device you reach for when your mode needs players to find or follow someone — a bounty target, a relic carrier, the last player standing, or a coach the rest of the team should rally to.

Beyond just showing the marker, the device can monitor up to two item types on the marked agents. It signals FirstItemValueChangedEvent / SecondItemValueChangedEvent whenever those item counts change, and FirstItemValueReachedEvent / SecondItemValueReachedEvent when a quantity condition you configured in the Details panel (Fewer Than / Equal To / More Than X) is met. That makes it doubly useful: it's both a visual tracker and a gameplay trigger.

From Verse you control it with five methods — Enable, Disable, Attach(Agent), Detach(Agent), and DetachFromAll() — and you react with the four item events listed above. Marker appearance (label text, icon, what bars to show, the quantity threshold) is set in the device's Details panel in UEFN; Verse decides who gets marked and when.

API Reference

player_marker_device

Used to mark an agent's position on the minimap and configure the information shown for marked agents. Example configuration options: * Health and shield bars for marked players. * Distance to a marked player. Example marker appearance options: * Customized text label displayed on marked players. * Alternative minimap icon and icon color.

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

player_marker_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 Bounty Mode: when a player steps on a trigger plate they 'accept the bounty' on the target, and a marker is attached to the chosen target so the hunter can see them on the minimap. We also watch the target's gold (the first monitored item, configured in the Details panel) and detach the marker once they hit the reached threshold — the bounty is 'cashed out'.

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

# Bounty Mode: mark a target so hunters can track them on the minimap.
bounty_mode_device := class(creative_device):

    # The player marker device placed in the level (configure its label,
    # icon, and the first monitored item type in the Details panel).
    @editable
    Marker : player_marker_device = player_marker_device{}

    # A plate a hunter steps on to accept the bounty.
    @editable
    AcceptPlate : trigger_device = trigger_device{}

    # A button the host presses to cancel all bounties.
    @editable
    CancelButton : button_device = button_device{}

    # Tracks who is currently the bounty target.
    var Target : ?agent = false

    OnBegin<override>()<suspends>:void =
        # Make sure the device is on so markers can show.
        Marker.Enable()

        # When someone steps on the plate, mark the first available player.
        AcceptPlate.TriggeredEvent.Subscribe(OnPlateStepped)

        # Host can wipe every marker at once.
        CancelButton.InteractedWithEvent.Subscribe(OnCancelPressed)

        # React when the target's monitored gold changes / hits the threshold.
        Marker.FirstItemValueChangedEvent.Subscribe(OnTargetGoldChanged)
        Marker.FirstItemValueReachedEvent.Subscribe(OnBountyCashedOut)

    # Pick a target to mark. For the demo we just mark the agent who stepped.
    OnPlateStepped(MaybeAgent : ?agent) : void =
        if (Stepper := MaybeAgent?):
            # Attach a minimap marker to the chosen target.
            Marker.Attach(Stepper)
            set Target = option{Stepper}
            Print("A bounty target has been marked!")

    # Fired every time the target's first monitored item count changes.
    OnTargetGoldChanged(MarkedAgent : agent) : void =
        Print("The marked target's gold count changed.")

    # Fired when the target meets the quantity condition set in the Details panel.
    OnBountyCashedOut(MarkedAgent : agent) : void =
        # Target reached the threshold — remove their marker.
        Marker.Detach(MarkedAgent)
        set Target = false
        Print("Bounty cashed out — marker removed.")

    # Host cancels everything.
    OnCancelPressed(Agent : agent) : void =
        Marker.DetachFromAll()
        set Target = false
        Print("All bounties cancelled.")

Line by line:

• The four @editable fields let you wire real placed devices in UEFN. Marker is the star; the plate, button are inputs that drive it.
• var Target : ?agent = false remembers who we marked. ?agent is an optional — false means 'no one'.
• In OnBegin, Marker.Enable() turns the device on. We then Subscribe four handlers — two to the input devices, two to the marker's own item events.
• OnPlateStepped receives ?agent (trigger events hand you an optional agent). We unwrap it with if (Stepper := MaybeAgent?) before calling Marker.Attach(Stepper) to pin a marker on them.
• OnTargetGoldChanged and OnBountyCashedOut are the device's own events — they hand you a plain agent (already unwrapped), the marked agent.
• OnBountyCashedOut calls Marker.Detach(MarkedAgent) to remove just that one marker.
• OnCancelPressed calls Marker.DetachFromAll() to clear every marker in one call.

Common patterns

Mark every player at round start (a 'reveal all' power-up)

When the round begins, mark all players so everyone can see everyone — good for a chaotic free-for-all finale.

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

reveal_all_device := class(creative_device):

    @editable
    Marker : player_marker_device = player_marker_device{}

    OnBegin<override>()<suspends>:void =
        Marker.Enable()
        Players := GetPlayspace().GetPlayers()
        for (Player : Players):
            Marker.Attach(Player)

React to a SECOND monitored item reaching its threshold

If you configure a second monitored item (say, 'wood'), the device fires SecondItemValueReachedEvent. Use it to flip the marker off once a builder is fully stocked.

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

stockpile_watch_device := class(creative_device):

    @editable
    Marker : player_marker_device = player_marker_device{}

    OnBegin<override>()<suspends>:void =
        Marker.Enable()
        Marker.SecondItemValueChangedEvent.Subscribe(OnWoodChanged)
        Marker.SecondItemValueReachedEvent.Subscribe(OnWoodFull)

    OnWoodChanged(MarkedAgent : agent) : void =
        Print("Marked agent's wood count changed.")

    OnWoodFull(MarkedAgent : agent) : void =
        # Stocked up — stop tracking them.
        Marker.Detach(MarkedAgent)

Toggle the whole device with a switch

Disable the device to hide all markers without losing your attach list; enable to restore tracking.

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

marker_toggle_device := class(creative_device):

    @editable
    Marker : player_marker_device = player_marker_device{}

    @editable
    HideSwitch : switch_device = switch_device{}

    OnBegin<override>()<suspends>:void =
        HideSwitch.TurnedOnEvent.Subscribe(OnHide)
        HideSwitch.TurnedOffEvent.Subscribe(OnShow)

    OnHide(Agent : agent) : void =
        Marker.Disable()

    OnShow(Agent : agent) : void =
        Marker.Enable()

Gotchas

• The device's own events hand you a plain agent, not ?agent. FirstItemValueChangedEvent and friends are listenable(agent), so your handler signature is (MarkedAgent : agent) — no ? unwrap needed. By contrast, trigger_device.TriggeredEvent and button_device.InteractedWithEvent hand you ?agent (or agent depending on device), so check the source event's type before deciding whether to unwrap with Maybe?.
• Marker appearance and the 'reached' threshold live in the Details panel, not in Verse. There's no Verse setter for the label text, icon color, health bars, or the Fewer/Equal/More-Than quantity. Configure those on the placed device; Verse only chooses who and when via Attach/Detach.
• Attach while the device is disabled does nothing visible. Call Enable() first (or ensure 'Enabled on Game Start' is set) before attaching, or markers won't appear.
• Detach only affects the one agent you pass. To clear everyone, use DetachFromAll() — it's a single call with no argument.
• Re-attaching an already-marked agent is fine but redundant. Track who you've marked (e.g. with a var Target : ?agent) if you need to avoid double work or want to reason about state.
• ?agent defaults need false, not option{} confusion. Declare var Target : ?agent = false for 'nobody', and set Target = option{SomeAgent} to store one. Read it back with if (A := Target?):.