step_modulator_device: Stepped Patchwork Modulation on Cue

Overview

The step_modulator_device is part of Fortnite's Patchwork music system. You wire it (in the UEFN editor) to a target Patchwork device — a synthesizer, a speaker, a distortion effect — and configure WHICH setting it modulates and the sequence of step values it walks through. The device then marches that setting through your steps, in time with the music manager's tempo.

What the step modulator does NOT expose to Verse is the step values themselves — those are authored in the editor's Details panel. What Verse DOES control is the simplest, most important thing: whether the modulator is running at all. Like every patchwork_device, it inherits exactly two methods — Enable() and Disable().

Reach for this device when you want a setting on another Patchwork device to evolve in stepped jumps (a stair-stepped filter, a pulsing volume, a sequenced pitch) and you want gameplay events to decide when that evolution starts and stops. A classic use: the arena music sounds flat and calm until a player steps on the boss-trigger plate — then you Enable() the step modulator and the synth filter starts climbing in dramatic steps.

Note: prior to the 28.00 release the Patchwork modulator zeroed its output when disabled while connected. That's fixed now — a disabled modulator simply leaves the target setting where it was.

API Reference

step_modulator_device

Modify a setting on another Patchwork device in steps over time.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from patchwork_device.

step_modulator_device<public> := class<concrete><final>(patchwork_device):

Methods (call these to make the device act):

Walkthrough

The scenario: A boss arena. The background music plays through a synth with a filter that the step modulator drives. While players are just milling about, the modulation is OFF (calm music). When a player steps on the boss trigger plate, we Enable() the step modulator so the filter starts stepping — tense, evolving music. When the boss is defeated (a second trigger fires), we Disable() it so the music settles back down.

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

# Drives a Patchwork step modulator on and off from gameplay triggers.
boss_music_director := class(creative_device):

    # The step modulator wired (in the editor) to the arena synth's filter setting.
    @editable
    FilterStepper : step_modulator_device = step_modulator_device{}

    # Player steps on this plate to start the fight.
    @editable
    BossStartPlate : trigger_device = trigger_device{}

    # Fires when the boss is defeated.
    @editable
    BossDefeatedTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Calm to start: make sure the stepped modulation is off.
        FilterStepper.Disable()

        # Wire gameplay triggers to our handler methods.
        BossStartPlate.TriggeredEvent.Subscribe(OnFightStarted)
        BossDefeatedTrigger.TriggeredEvent.Subscribe(OnBossDefeated)

    # When a player trips the start plate, kick the modulation into gear.
    OnFightStarted(Agent : ?agent):void =
        if (Player := Agent?):
            # A real player started the fight — ramp up the music.
            FilterStepper.Enable()

    # When the boss dies, settle the music back down.
    OnBossDefeated(Agent : ?agent):void =
        FilterStepper.Disable()

Line by line:

• boss_music_director := class(creative_device): — our custom device. It must extend creative_device so it can hold @editable references and run OnBegin.
• @editable FilterStepper : step_modulator_device = step_modulator_device{} — the editable field. In UEFN you drop a Step Modulator into the level and assign it here. Without an @editable field, calling FilterStepper.Enable() would fail with 'Unknown identifier'.
• The two trigger_device fields are the gameplay hooks. They're configured in the editor (the start plate, the boss-defeat event).
• OnBegin<override>()<suspends>:void = — runs once when the device starts. We call FilterStepper.Disable() immediately so the arena begins quiet, regardless of the device's editor default.
• .TriggeredEvent.Subscribe(OnFightStarted) — register our methods as handlers. TriggeredEvent is a listenable(?agent), so each handler receives (Agent : ?agent).
• In OnFightStarted we unwrap the optional agent with if (Player := Agent?): — confirming a real player triggered it — then call FilterStepper.Enable(). The modulator begins stepping the synth's filter.
• OnBossDefeated just calls FilterStepper.Disable(). The stepped modulation stops; the filter holds its last value (no nasty zero-snap thanks to the 28.00 fix).

Common patterns

Pattern 1 — Toggle modulation with a single button

A jam-session island where one button toggles the stepped filter sweep on and off. We track state and call the matching method.

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

stepper_toggle := class(creative_device):

    @editable
    Stepper : step_modulator_device = step_modulator_device{}

    @editable
    ToggleButton : button_device = button_device{}

    var IsRunning : logic = false

    OnBegin<override>()<suspends>:void =
        Stepper.Disable()
        ToggleButton.InteractedWithEvent.Subscribe(OnPressed)

    OnPressed(Agent : agent):void =
        if (IsRunning?):
            Stepper.Disable()
            set IsRunning = false
        else:
            Stepper.Enable()
            set IsRunning = true

Pattern 2 — Enable several Patchwork devices together for a music "drop"

A dance-floor moment: when the round begins, enable the step modulator AND its LFO sibling so the whole soundscape comes alive at once. Both are patchwork_devices, so both expose Enable().

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

music_drop := class(creative_device):

    @editable
    Stepper : step_modulator_device = step_modulator_device{}

    @editable
    StartDropTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Start silent, then drop on cue.
        Stepper.Disable()
        StartDropTrigger.TriggeredEvent.Subscribe(OnDrop)

    OnDrop(Agent : ?agent):void =
        # The beat drops: stepped modulation comes alive.
        Stepper.Enable()

Pattern 3 — Timed burst of modulation

Enable the step modulator for a 10-second adrenaline burst, then automatically disable it — useful for a power-up or a sudden-death finale. We use Sleep inside the suspending handler.

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

burst_modulator := class(creative_device):

    @editable
    Stepper : step_modulator_device = step_modulator_device{}

    @editable
    BurstTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        Stepper.Disable()
        BurstTrigger.TriggeredEvent.Subscribe(OnBurst)

    OnBurst(Agent : ?agent):void =
        spawn { RunBurst() }

    RunBurst()<suspends>:void =
        Stepper.Enable()
        Sleep(10.0)
        Stepper.Disable()

Gotchas

• You can't set the step values from Verse. The step modulator's surface is just Enable() and Disable(). The actual setting it targets, the step pattern, and the range are all configured in the editor's Details panel. Verse only gates WHEN it runs.
• It must be wired to a target Patchwork device in the editor. Enabling a step modulator that isn't connected to anything does nothing audible. Configure its output target before relying on it.
• Don't expect a snap to zero on Disable anymore. Since the 28.00 release a disabled connected modulator leaves the target setting at its last value instead of jumping to 0. If your old design depended on that zero-snap, you must reset the target setting yourself.
• Unwrap the optional agent. TriggeredEvent hands your handler (Agent : ?agent). If you only need to react to the event, you can ignore it — but if you want the specific player, you must unwrap with if (Player := Agent?): before using it.
• Declare the field as @editable and assign it in UEFN. A bare step_modulator_device{} default with no assignment in the editor points at nothing — calling Enable() on an unassigned device is a no-op. And without the @editable field on a creative_device class, the reference won't compile at all.
• Tempo comes from the music manager. The step modulator advances its steps in time with the shared Patchwork tempo provided by a music_manager_device. If steps aren't progressing as expected, check that a music manager exists and is running.