note_sequencer_device: Melodies That Play on Cue

Overview

The note_sequencer_device is part of UEFN's Patchwork audio toolset. It stores a melodic note pattern (which notes, in which order, at the tempo set by a connected music_manager_device) and pushes those notes into the rest of your Patchwork signal chain — typically an instrument_player_device that turns the notes into sound, then a speaker_device that plays them for the player.

On its own, the sequencer just sits there. The game problem it solves is timing: you want a melody to start when something happens (the boss appears, the player wins, a puzzle is solved) and stop when that moment ends. That on/off control is exactly what its Verse API gives you.

Because note_sequencer_device derives from patchwork_device, the only methods it exposes to Verse are the two it inherits: Enable() (start producing notes) and Disable() (stop). It has no Verse-facing events of its own — you drive it from other devices' events (a trigger, a button, a timer). Reach for it whenever you want a Patchwork melody to be conditional on gameplay rather than always looping.

API Reference

note_sequencer_device

Create melodic note patterns for Patchwork devices.

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

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

Methods (call these to make the device act):

Walkthrough

Let's build a boss arena theme. We have a Patchwork chain already laid out in the editor: a music manager sets the tempo, our note sequencer holds a tense melody, an instrument player turns it into sound, and a speaker plays it. The melody should be silent until the player steps on the arena plate, then loop while they fight, and cut out when they leave the arena (a second trigger at the exit).

We start the device disabled so there's no music in the lobby, enable it on the entry trigger, and disable it on the exit trigger.

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

# Boss arena music controller.
boss_theme_device := class(creative_device):

    # The melody pattern we want to play. Place a note_sequencer_device in your
    # Patchwork chain and assign it here in the Details panel.
    @editable
    Melody : note_sequencer_device = note_sequencer_device{}

    # Player steps on this to enter the arena -> music starts.
    @editable
    EnterTrigger : trigger_device = trigger_device{}

    # Player steps on this to leave the arena -> music stops.
    @editable
    ExitTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Start silent: no boss theme in the lobby.
        Melody.Disable()

        # Wire the triggers to our handler methods.
        EnterTrigger.TriggeredEvent.Subscribe(OnEnterArena)
        ExitTrigger.TriggeredEvent.Subscribe(OnExitArena)

    # Called when a player steps on the entry plate.
    OnEnterArena(Agent : ?agent):void =
        # Turn the melody on. The Patchwork chain (instrument + speaker)
        # now produces audible notes.
        Melody.Enable()

    # Called when a player steps on the exit plate.
    OnExitArena(Agent : ?agent):void =
        # Stop the melody.
        Melody.Disable()

Line by line:

• boss_theme_device := class(creative_device) — our Verse device. Drop it into the level so its code runs.
• The three @editable fields let us point the script at real placed devices in the Details panel. Melody is our sequencer; the two triggers are arena boundaries.
• OnBegin<override>()<suspends>:void = is the entry point that runs when the game starts.
• Melody.Disable() — we call the sequencer's real Disable() method so the level opens in silence.
• EnterTrigger.TriggeredEvent.Subscribe(OnEnterArena) registers a method to run every time the trigger fires. TriggeredEvent is a listenable(?agent), so the handler receives (Agent : ?agent).
• In OnEnterArena we call Melody.Enable() — this is the device DOING something: it begins feeding notes into the Patchwork chain, so the player hears the theme.
• OnExitArena mirrors it with Melody.Disable() to silence the melody when the player leaves.

Common patterns

Toggle the melody with a button

A jukebox-style button: press once to start the tune, press again to stop. We track state in a var.

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

jukebox_device := class(creative_device):

    @editable
    Melody : note_sequencer_device = note_sequencer_device{}

    @editable
    PlayButton : button_device = button_device{}

    var Playing : logic = false

    OnBegin<override>()<suspends>:void =
        Melody.Disable()
        PlayButton.InteractedWithEvent.Subscribe(OnPressed)

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

Start the melody after a timed countdown

Use a timer_device so the theme kicks in exactly when the round begins rather than on a player action.

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

intro_music_device := class(creative_device):

    @editable
    Melody : note_sequencer_device = note_sequencer_device{}

    @editable
    CountdownTimer : timer_device = timer_device{}

    OnBegin<override>()<suspends>:void =
        # Hold the melody until the countdown finishes.
        Melody.Disable()
        CountdownTimer.SuccessEvent.Subscribe(OnCountdownDone)
        CountdownTimer.Start()

    OnCountdownDone(Agent : ?agent):void =
        # Countdown reached zero -> drop the beat.
        Melody.Enable()

Hand control to several melodies at once

You can drive multiple sequencers from one event — for example, layering a bass line and a lead. Enable both when the boss spawns.

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

layered_theme_device := class(creative_device):

    @editable
    LeadMelody : note_sequencer_device = note_sequencer_device{}

    @editable
    BassMelody : note_sequencer_device = note_sequencer_device{}

    @editable
    BossSpawnTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        LeadMelody.Disable()
        BassMelody.Disable()
        BossSpawnTrigger.TriggeredEvent.Subscribe(OnBossSpawned)

    OnBossSpawned(Agent : ?agent):void =
        LeadMelody.Enable()
        BassMelody.Enable()

Gotchas

• The sequencer makes no sound by itself. Enable() only starts the note pattern. You still need the full Patchwork chain — a music_manager_device for tempo, an instrument_player_device (or omega_synthesizer_device) to render the notes, and a speaker_device to play them — wired in the editor. If you hear nothing, check the chain, not the Verse code.
• No events on this device. note_sequencer_device exposes only Enable and Disable to Verse. You can't subscribe to a 'note played' event on it — drive it from another device's event (trigger, button, timer) as shown above.
• Always declare the device as an @editable field. Calling note_sequencer_device{} inline and using it gives you an unassigned device. You must place the real device in the level and assign it in the Details panel, otherwise Enable()/Disable() do nothing.
• TriggeredEvent hands you ?agent, but InteractedWithEvent (button) hands you a plain agent. Match your handler signature to the event — mixing them up is a common compile error. Unwrap an optional agent with if (A := Agent?): only when the type is ?agent.
• Enabling an already-enabled sequencer is harmless but redundant. If you toggle music on/off, track state yourself (the var Playing : logic pattern) so your logic stays correct even if the player spams the button.
• Don't Print to make the device react. Logging a message does nothing audible — the only way to start the melody is to actually call Melody.Enable().