omega_synthesizer_device: Dynamic Audio Control in Patchwork

Overview

The omega_synthesizer_device lives inside the Patchwork audio system — a family of devices that work together to create in-game music and sound effects driven by note data. The Omega Synthesizer sits at the output end of that chain: it receives note signals from devices like the Note Sequencer or Note Progressor and turns them into actual synthesized sound.

From Verse you get two controls:

When should you reach for this device?

• You want music or sound effects that react to game state (boss phase changes, zone captures, round transitions).
• You need to mute a Patchwork instrument during a cinematic or dialogue moment.
• You're building a puzzle where solving it "unlocks" a new layer of the soundtrack.

Because omega_synthesizer_device inherits from patchwork_device, which itself inherits from creative_device_base, it integrates cleanly with any Verse creative_device.

API Reference

omega_synthesizer_device

Turn Patchwork note inputs into audio using customizable sound synthesis.

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

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

Methods (call these to make the device act):

Walkthrough

Scenario: A capture-point island where two teams fight over a central zone. When Team A captures the zone, the Omega Synthesizer plays a triumphant synth sting. When Team B recaptures it, the synth is silenced. Two button_device objects stand in for the capture events so you can test the logic without a full scoring system.

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

# Drop this Verse device into your level, then assign the three
# @editable fields in the UEFN Details panel.
capture_zone_audio_controller := class(creative_device):

    # The Omega Synthesizer placed in your level.
    @editable
    Synth : omega_synthesizer_device = omega_synthesizer_device{}

    # A button that fires when Team A captures the zone.
    @editable
    TeamACaptureButton : button_device = button_device{}

    # A button that fires when Team B captures the zone.
    @editable
    TeamBCaptureButton : button_device = button_device{}

    # Called automatically when the game session starts.
    OnBegin<override>()<suspends> : void =
        # Start with the synth silent — no team owns the zone yet.
        Synth.Disable()

        # Subscribe to both capture buttons.
        # InteractedWithEvent sends an `agent` (the player who pressed it).
        TeamACaptureButton.InteractedWithEvent.Subscribe(OnTeamACaptures)
        TeamBCaptureButton.InteractedWithEvent.Subscribe(OnTeamBCaptures)

    # Team A captures the zone — enable the synth so the sting plays.
    OnTeamACaptures(Capturer : agent) : void =
        # Enable lets the synthesizer respond to note inputs again.
        Synth.Enable()

    # Team B recaptures the zone — silence the synth.
    OnTeamBCaptures(Capturer : agent) : void =
        # Disable cuts the synthesizer's audio output immediately.
        Synth.Disable()

Line-by-line breakdown:

1. @editable fields — Every placed device you want to call from Verse must be declared as an @editable field. Assigning them in the Details panel is what connects your code to the actual objects in the level.
2. OnBegin<override>()<suspends> — The entry point for all Verse creative_device logic. The <suspends> effect is required because OnBegin can run async operations.
3. Synth.Disable() — Called immediately so the synth starts silent. Good practice: always set your audio devices to a known state at game start.
4. Subscribe(OnTeamACaptures) — Registers a class-scope method as the handler. The handler signature must match (agent) : void because InteractedWithEvent is a listenable(agent).
5. Synth.Enable() / Synth.Disable() — The two Verse-accessible methods on omega_synthesizer_device. Enable resumes audio output; Disable mutes it.

Common patterns

Pattern 1 — Timed synth burst (Enable then auto-Disable after a delay)

Use this when you want a short synth sting — for example, a fanfare when a player opens a vault door.

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

vault_fanfare_controller := class(creative_device):

    # The synthesizer that plays the fanfare sting.
    @editable
    FanareSynth : omega_synthesizer_device = omega_synthesizer_device{}

    # A button on the vault door the player interacts with.
    @editable
    VaultButton : button_device = button_device{}

    # How long (in seconds) the fanfare plays before silencing.
    @editable
    FanareDurationSeconds : float = 4.0

    OnBegin<override>()<suspends> : void =
        FanareSynth.Disable()
        VaultButton.InteractedWithEvent.Subscribe(OnVaultOpened)

    OnVaultOpened(Opener : agent) : void =
        # Spawn an async task so the timed mute doesn't block other logic.
        spawn { PlayFanfare() }

    PlayFanfare()<suspends> : void =
        # Enable the synth — the Patchwork note chain starts driving audio.
        FanareSynth.Enable()
        # Wait for the sting to finish, then silence it.
        Sleep(FanareDurationSeconds)
        FanareSynth.Disable()

Key idea: spawn { PlayFanfare() } runs the timed sequence concurrently so the button handler returns immediately. Sleep (a core Verse built-in) provides the delay between Enable and Disable.

Pattern 2 — Toggle synth on/off with a single button

Useful for a DJ booth prop or a player-controlled music switch.

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

dj_booth_controller := class(creative_device):

    @editable
    BoothSynth : omega_synthesizer_device = omega_synthesizer_device{}

    @editable
    ToggleButton : button_device = button_device{}

    # Track whether the synth is currently active.
    var SynthActive : logic = false

    OnBegin<override>()<suspends> : void =
        BoothSynth.Disable()
        ToggleButton.InteractedWithEvent.Subscribe(OnTogglePressed)

    OnTogglePressed(Presser : agent) : void =
        if (SynthActive?):
            # Synth is on — turn it off.
            BoothSynth.Disable()
            set SynthActive = false
        else:
            # Synth is off — turn it on.
            BoothSynth.Enable()
            set SynthActive = true

Key idea: A var logic field tracks state between handler calls. if (SynthActive?) uses Verse's failure-context syntax to test a logic value — true succeeds, false fails.

Gotchas

1. You MUST declare the device as an @editable field

A bare omega_synthesizer_device{} literal in OnBegin is just an unplaced default object — calling .Enable() on it does nothing in the game world. Always wire the real placed device through the Details panel via an @editable field.

2. Enable/Disable control Verse-side gating, not Patchwork wiring

Disable() stops the synthesizer from responding to note inputs and producing audio, but it does not disconnect the Patchwork cable graph you built in the editor. When you call Enable() again, the synthesizer resumes exactly where the note chain left off.

3. omega_synthesizer_device has no events

Unlike many Creative devices, the Omega Synthesizer exposes no events to Verse — you cannot subscribe to "note played" or "beat hit" callbacks. All reactive logic must come from other devices (buttons, triggers, zone devices) that you subscribe to separately.

4. InteractedWithEvent sends agent, not ?agent

The button_device.InteractedWithEvent is typed listenable(agent) — the agent is already unwrapped. Your handler signature is (Presser : agent) : void, not (Presser : ?agent). If you were subscribing to an event typed listenable(?agent), you would need if (A := Agent?): to unwrap it first.

5. Sleep requires a float, not an int

Verse does not auto-convert int to float. Write Sleep(4.0) not Sleep(4) — the latter is a compile error.

6. Patchwork context matters

The Omega Synthesizer only produces sound when it is connected to a valid Patchwork note source (e.g., a Note Sequencer) in the editor. Calling Enable() from Verse on a synthesizer with no Patchwork inputs wired up will not produce any audio — check your device graph first.