movement_modulator_device: Speed Up, Slow Down, Take Control

Overview

The movement_modulator_device is a Creative device that temporarily modifies the movement speed of agents and vehicles. You configure the speed multiplier (faster or slower than normal) in the device's UEFN Details panel, then control when and for whom the effect applies entirely from Verse.

Reach for this device when you need:

• A speed-pad that launches players forward when they step on a pressure plate.
• A slow-zone that drains movement speed inside a hazard area.
• A timed sprint buff granted to the first player to capture an objective.
• Any situation where you want per-agent speed control rather than a blanket island-wide setting.

The device exposes three methods (Enable, Disable, Activate) and one event (ActivationEvent), giving you both push-style control (you call Activate) and reactive observation (subscribe to ActivationEvent to know when it fires).

API Reference

movement_modulator_device

Used to temporarily modify the speed of agents and vehicles.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: Speed-Pad Trap — slow enemies, boost allies

Imagine a capture-the-flag map. You place a pressure plate (button_device) at the entrance to your base. When any player steps on it:

1. A slow modulator (configured in UEFN to 40 % speed) activates on that player.
2. The ActivationEvent fires, and your Verse code logs which agent got slowed.
3. A separate boost modulator (configured to 200 % speed) is kept disabled until a second button is pressed by a teammate, granting a sprint buff.

Place two movement_modulator_device instances and one button_device in your island, then wire them up:

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

# speed_pad_manager — slows any player who trips the trap plate,
# and lets a teammate activate a sprint boost via a second button.
speed_pad_manager := class(creative_device):

    # The movement modulator set to ~40% speed in UEFN (the slow trap)
    @editable
    SlowModulator : movement_modulator_device = movement_modulator_device{}

    # The movement modulator set to ~200% speed in UEFN (the sprint boost)
    @editable
    BoostModulator : movement_modulator_device = movement_modulator_device{}

    # A button_device placed at the trap entrance
    @editable
    TrapPlate : button_device = button_device{}

    # A button_device a teammate presses to grant the sprint buff
    @editable
    BoostButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Make sure both modulators are live at game start
        SlowModulator.Enable()
        BoostModulator.Enable()

        # Subscribe to the trap plate — when pressed, slow that agent
        TrapPlate.InteractedWithEvent.Subscribe(OnTrapTriggered)

        # Subscribe to the boost button — when pressed, boost that agent
        BoostButton.InteractedWithEvent.Subscribe(OnBoostTriggered)

        # Subscribe to SlowModulator's own ActivationEvent to react when it fires
        SlowModulator.ActivationEvent.Subscribe(OnSlowActivated)

    # Called when a player steps on the trap plate
    OnTrapTriggered(Agent : agent) : void =
        # Directly activate the slow effect on the triggering agent
        SlowModulator.Activate(Agent)

    # Called when a player presses the boost button
    OnBoostTriggered(Agent : agent) : void =
        # Directly activate the sprint boost on the pressing agent
        BoostModulator.Activate(Agent)

    # Reacts to SlowModulator's ActivationEvent — fires after Activate() is called
    OnSlowActivated(SlowedAgent : agent) : void =
        # You can drive further logic here, e.g. start a timer to re-enable
        # or notify other systems that this agent is slowed.
        # For now we simply disable the slow modulator briefly as a one-shot,
        # then re-enable it so the next player can be caught too.
        SlowModulator.Disable()
        SlowModulator.Enable()

Line-by-line explanation

UEFN setup reminder: Select each movement_modulator_device in the Outliner and set Speed Modifier in the Details panel. SlowModulator → 0.4, BoostModulator → 2.0. The Verse code controls when the effect fires; the Details panel controls how much.

Common patterns

Pattern 1 — Disable the modulator during a safe phase, re-enable for combat

In a wave-based game you might want movement to be normal during a build/prep phase and only allow the slow trap to work during the combat wave.

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

# wave_phase_controller — disables the slow trap during prep, enables it for combat.
wave_phase_controller := class(creative_device):

    @editable
    SlowTrap : movement_modulator_device = movement_modulator_device{}

    # A button the host presses to start the combat wave
    @editable
    StartCombatButton : button_device = button_device{}

    # A button the host presses to end the wave (return to prep)
    @editable
    EndWaveButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Prep phase: trap is OFF so players move freely
        SlowTrap.Disable()

        StartCombatButton.InteractedWithEvent.Subscribe(OnCombatStart)
        EndWaveButton.InteractedWithEvent.Subscribe(OnWaveEnd)

    OnCombatStart(Agent : agent) : void =
        # Combat phase: trap is ON — any Activate() call will now apply the slow
        SlowTrap.Enable()

    OnWaveEnd(Agent : agent) : void =
        # Back to prep: disable so no accidental slows during downtime
        SlowTrap.Disable()

Pattern 2 — React to ActivationEvent to chain a visual cue device

When the modulator fires, you often want a secondary effect — like triggering a VFX spawner or playing a sound. Subscribe to ActivationEvent to drive that chain.

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

# activation_chain_device — plays a VFX when the speed modulator activates.
activation_chain_device := class(creative_device):

    @editable
    SpeedMod : movement_modulator_device = movement_modulator_device{}

    # A VFX spawner device placed at the speed-pad location
    @editable
    VFXSpawner : vfx_spawner_device = vfx_spawner_device{}

    # The pressure plate that triggers the speed effect
    @editable
    SpeedPlate : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        SpeedMod.Enable()
        SpeedPlate.InteractedWithEvent.Subscribe(OnPlatePressed)
        # Listen for the modulator's own confirmation event
        SpeedMod.ActivationEvent.Subscribe(OnModActivated)

    OnPlatePressed(Agent : agent) : void =
        SpeedMod.Activate(Agent)

    # Fires after Activate() succeeds — trigger the VFX here
    OnModActivated(Agent : agent) : void =
        VFXSpawner.Play()

Pattern 3 — Per-agent boost from a class-select device

Some games grant a passive speed boost to a specific class at round start. Loop over all players and call Activate on each scout-class agent.

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

# scout_boost_device — activates a speed boost for every player at round start.
scout_boost_device := class(creative_device):

    @editable
    ScoutBoost : movement_modulator_device = movement_modulator_device{}

    OnBegin<override>()<suspends> : void =
        ScoutBoost.Enable()

        # Get all players currently in the experience
        AllPlayers := GetPlayspace().GetPlayers()

        for (Player : AllPlayers):
            # Activate the boost on every player at game start
            ScoutBoost.Activate(Player)

Gotchas

1. Activate silently does nothing on a disabled device

If you call Activate(Agent) while the device is in a Disabled state, no effect is applied and no error is thrown. Always call Enable() before Activate() if there is any chance the device was previously disabled. A common pattern is Enable() in OnBegin and only Disable() when you explicitly want to block the effect.

2. ActivationEvent fires after the effect is applied — not before

ActivationEvent is a confirmation signal, not a pre-activation hook. You cannot cancel the effect by handling this event; use it only to chain follow-up logic (VFX, sound, stat tracking).

3. The speed value is set in UEFN, not in Verse

There is no SetSpeedMultiplier() method. The actual speed change is configured in the device's Details panel in UEFN. Verse only controls whether the device is active and which agent it applies to. If you need different speed values at runtime, place multiple movement_modulator_device instances with different panel settings and Activate the right one.

4. ActivationEvent handler receives agent, not ?agent

Unlike some other device events that send listenable(?agent), ActivationEvent on movement_modulator_device sends listenable(agent) — a non-optional agent. You do not need to unwrap it with if (A := Agent?). Write your handler signature as OnActivated(Agent : agent) : void = directly.

5. Vehicles count as agents here

The device description says it affects "agents and vehicles." In practice, Activate(Agent) targets the agent interface; vehicle occupants are still agents. Test your speed values with both on-foot and in-vehicle scenarios since a 2× multiplier feels very different at vehicle base speed.

6. Device must be placed in the island — @editable is mandatory

You cannot construct a movement_modulator_device in Verse with movement_modulator_device{} and expect it to work at runtime. The device must be placed in the UEFN scene and referenced via an @editable field. A bare movement_modulator_device{} default is only a placeholder for the field declaration; the real instance is injected by the engine at runtime.