advanced_storm_beacon_device: Sculpting Storm Phases in Verse

Overview

When you build a Battle Royale-style match, you usually want the playable area to shrink through several phases. The advanced_storm_controller_device generates those phases, and each advanced_storm_beacon_device you assign to it marks where a given phase should center.

The power of doing this in Verse is movement. The beacon exposes TeleportTo (instant) and MoveTo (over time) overrides inherited from the spatial device base. Because the API note says "existing storms will not target the new location, but newly generated storms will", you relocate beacons before the next phase generates — letting you randomize, react to player position, or sweep the safe zone across the map.

Reach for this device whenever you want more than a static circle: a moving eye of the storm, an arena that drifts toward an objective, or a final ring that snaps to wherever the action is.

Note: the sibling beacon_device (a visual/HUD marker, not the storm beacon) provides Enable, Disable, and the per-agent show-list methods (AddToShowList, RemoveFromShowList, RemoveAllFromShowList). We cover those in Common Patterns since they pair naturally — a HUD marker that points players toward where the storm beacon is heading.

API Reference

advanced_storm_beacon_device

Used in conjunction with advanced_storm_controller_device to customize individual storm phases.

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

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

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

Scenario: a survival round where the eye of the storm drifts toward a central objective. We have one advanced_storm_beacon_device placed on the map. When the round starts, we instantly snap it to a known position with TeleportTo, then smoothly slide it toward the objective with MoveTo so the next generated storm phase closes in on the new spot.

We also wire up a beacon_device (the visual marker) so players can see where the safe zone is heading, and a button_device to trigger the relocation.

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

storm_drift_device := class(creative_device):

    # The storm-phase beacon the advanced controller reads from.
    @editable
    StormBeacon : advanced_storm_beacon_device = advanced_storm_beacon_device{}

    # A visual/HUD marker so players can SEE where the eye is heading.
    @editable
    Marker : beacon_device = beacon_device{}

    # Button players press to start the drift.
    @editable
    StartButton : button_device = button_device{}

    # Where the drift ends (place an empty prop / second beacon here in-editor).
    @editable
    TargetPosition : vector3 = vector3{ X := 0.0, Y := 0.0, Z := 0.0 }

    OnBegin<override>()<suspends>:void =
        # Turn the HUD marker on at round start.
        Marker.Enable()
        # Run drift logic when the button is pressed.
        StartButton.InteractedWithEvent.Subscribe(OnStartPressed)

    OnStartPressed(Agent : agent) : void =
        # Make sure THIS agent can see the marker, even outside team visibility.
        Marker.AddToShowList(Agent)
        # Kick off the suspending drift in its own async context.
        spawn { DriftStorm() }

    DriftStorm()<suspends>:void =
        # 1. Snap the beacon to a known starting spot instantly.
        StartPos := vector3{ X := 2000.0, Y := 0.0, Z := 0.0 }
        Flat := IdentityRotation()
        if (StormBeacon.TeleportTo[StartPos, Flat]):
            # 2. Smoothly move it toward the objective over 8 seconds.
            #    The NEXT generated storm phase will target here.
            StormBeacon.MoveTo(TargetPosition, Flat, 8.0)

Line by line:

• StormBeacon : advanced_storm_beacon_device = advanced_storm_beacon_device{} — the @editable field you bind to the placed beacon in the Details panel. Without this field, you could not call its methods.
• Marker.Enable() — turns on the visual beacon_device marker at OnBegin. Enable/Disable are real beacon_device methods.
• StartButton.InteractedWithEvent.Subscribe(OnStartPressed) — standard button wiring; the handler receives the agent who pressed it.
• Marker.AddToShowList(Agent) — forces this specific player to see the marker, independent of Team Visibility settings.
• spawn { DriftStorm() } — MoveTo is <suspends>, so it must run in an async context; spawn gives it one without blocking the handler.
• StormBeacon.TeleportTo[StartPos, Flat] — TeleportTo is <decides>, so it's called in a failure context with square brackets inside an if. IdentityRotation() gives a no-op rotation.
• StormBeacon.MoveTo(TargetPosition, Flat, 8.0) — slides the beacon over 8 seconds. Newly generated storm phases will now close on TargetPosition.

Common patterns

Pattern 1 — Instantly relocate the beacon with the transform overload

TeleportTo also accepts a single transform (position + rotation + scale). Handy when you copy a target prop's transform.

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

snap_storm_device := class(creative_device):

    @editable
    StormBeacon : advanced_storm_beacon_device = advanced_storm_beacon_device{}

    # A prop whose transform marks the next storm center.
    @editable
    AnchorProp : creative_prop = creative_prop{}

    @editable
    Relocate : button_device = button_device{}

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

    OnPressed(Agent : agent) : void =
        # Read the anchor prop's transform and snap the beacon onto it.
        DestTransform := AnchorProp.GetTransform()
        if (StormBeacon.TeleportTo[DestTransform]):
            # Teleport succeeded; the next storm phase targets the anchor.
            return

Pattern 2 — A HUD marker only the leader can see

The beacon_device show-list lets you reveal a marker to a hand-picked set of players, then clear it. Great for objective hints.

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

leader_marker_device := class(creative_device):

    @editable
    LeaderMarker : beacon_device = beacon_device{}

    @editable
    ShowButton : button_device = button_device{}

    @editable
    HideButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        LeaderMarker.Enable()
        ShowButton.InteractedWithEvent.Subscribe(OnShow)
        HideButton.InteractedWithEvent.Subscribe(OnHide)

    OnShow(Agent : agent) : void =
        # Only this presser gets the marker added to their show list.
        LeaderMarker.AddToShowList(Agent)

    OnHide(Agent : agent) : void =
        # Remove just this agent...
        LeaderMarker.RemoveFromShowList(Agent)
        # ...or wipe everyone from the show list at once.
        LeaderMarker.RemoveAllFromShowList()

Pattern 3 — Disable the marker when the phase ends

Pair Disable with a trigger so the HUD marker disappears once players reach the zone.

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

marker_cleanup_device := class(creative_device):

    @editable
    Marker : beacon_device = beacon_device{}

    @editable
    ReachedZone : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        Marker.Enable()
        ReachedZone.TriggeredEvent.Subscribe(OnReached)

    OnReached(MaybeAgent : ?agent) : void =
        # Hide the marker for everyone once the zone is reached.
        Marker.RemoveAllFromShowList()
        Marker.Disable()

Gotchas

• Storms already in flight ignore the move. The beacon's own docs say existing storms keep their old target — only newly generated phases read the beacon's new position. Always relocate the beacon before the controller advances to the next phase.
• TeleportTo is <decides> — use brackets in a failure context. Call it as if (Beacon.TeleportTo[Pos, Rot]):, not Beacon.TeleportTo(Pos, Rot). Square brackets and an if/for context are mandatory.
• MoveTo is <suspends> — it needs async. You cannot call it directly from a plain event handler method. Wrap it in spawn { ... } or call it from within another <suspends> function like OnBegin.
• Two different beacons. advanced_storm_beacon_device (storm phase target) has NO Enable/AddToShowList. Those belong to beacon_device (the visual/HUD marker). Don't mix the field types up.
• Verse does not auto-convert int↔float. MoveTo's OverTime is a float; write 8.0, never 8.
• The show list is separate from Team Visibility. AddToShowList grants a marker to one agent on top of team rules; RemoveFromShowList only removes the manual grant — the agent may still see it via their team.
• Bind every @editable field in the Details panel. An unbound beacon field is an empty placeholder, and its method calls do nothing at runtime.