bouncer_device: Launch Pads With Brains

Overview

The bouncer_device solves a common creative problem: you want a launch pad that responds to game state rather than just sitting there forever. Maybe the bouncer should only activate after a player completes a challenge, or you want to award bonus points every time someone gets launched, or you need to disable all bouncers when the storm closes in. The Verse API gives you exactly that control.

Key capabilities:

• Enable / Disable — toggle the pad (and all its VFX/SFX) at runtime.
• BouncedEvent — fires whenever something is launched; sends the ?agent responsible (driver, projectile instigator, or false for driverless vehicles).
• HealStartEvent / HealStopEvent — fires when the bouncer's heal effect begins or ends for a specific agent.

Reach for bouncer_device whenever you need a launch pad that reacts to game logic rather than always being active.

API Reference

bouncer_device

Used to create a bouncer that can launch players, vehicles, and more into the air with optional effects.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A timed gauntlet arena. Three bouncers are disabled at the start. When the round begins (simulated here by OnBegin), the bouncers activate. Every time a player is launched, a bounce counter increments. When a player's heal effect starts or stops, we log it. After 30 seconds the bouncers shut off — the window is closed.

# bouncer_gauntlet_device.verse
# A timed gauntlet: bouncers activate on round start, track every launch,
# monitor heal events, then deactivate after 30 seconds.

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

bouncer_gauntlet_device := class(creative_device):

    # Wire up to three bouncer_device instances in the UEFN editor.
    @editable
    Bouncer1 : bouncer_device = bouncer_device{}

    @editable
    Bouncer2 : bouncer_device = bouncer_device{}

    @editable
    Bouncer3 : bouncer_device = bouncer_device{}

    # Shared bounce counter across all three pads.
    var TotalBounces : int = 0

    # Called when the game experience begins.
    OnBegin<override>()<suspends> : void =
        # All bouncers start disabled — players can't use them yet.
        Bouncer1.Disable()
        Bouncer2.Disable()
        Bouncer3.Disable()

        Print("Gauntlet: bouncers are offline. Round starting in 3 seconds...")
        Sleep(3.0)

        # Activate all three pads (VFX and audio come back too).
        Bouncer1.Enable()
        Bouncer2.Enable()
        Bouncer3.Enable()
        Print("Gauntlet: bouncers ONLINE — 30 seconds on the clock!")

        # Subscribe to bounce events on every pad.
        Bouncer1.BouncedEvent.Subscribe(OnBounced)
        Bouncer2.BouncedEvent.Subscribe(OnBounced)
        Bouncer3.BouncedEvent.Subscribe(OnBounced)

        # Subscribe to heal events on every pad.
        Bouncer1.HealStartEvent.Subscribe(OnHealStart)
        Bouncer2.HealStartEvent.Subscribe(OnHealStart)
        Bouncer3.HealStartEvent.Subscribe(OnHealStart)

        Bouncer1.HealStopEvent.Subscribe(OnHealStop)
        Bouncer2.HealStopEvent.Subscribe(OnHealStop)
        Bouncer3.HealStopEvent.Subscribe(OnHealStop)

        # Let the gauntlet window run for 30 seconds.
        Sleep(30.0)

        # Time's up — shut everything down.
        Bouncer1.Disable()
        Bouncer2.Disable()
        Bouncer3.Disable()
        Print("Gauntlet over! Total launches: {TotalBounces}")

    # Handler for BouncedEvent — note the ?agent (optional agent) parameter.
    # BouncedEvent sends ?agent: it's false if nothing driveable bounced.
    OnBounced(MaybeAgent : ?agent) : void =
        set TotalBounces += 1
        # Unwrap the optional agent before using it.
        if (A := MaybeAgent?):
            Print("A player was launched! Total launches so far: {TotalBounces}")
        else:
            Print("Something non-player bounced. Total launches: {TotalBounces}")

    # Handler for HealStartEvent — agent is non-optional here.
    OnHealStart(A : agent) : void =
        Print("Heal effect STARTED for an agent.")

    # Handler for HealStopEvent.
    OnHealStop(A : agent) : void =
        Print("Heal effect STOPPED for an agent.")

Line-by-line highlights

Common patterns

Pattern 1 — Gate a bouncer behind a button press

The bouncer starts disabled. A button_device enables it. This is the classic "unlock the launch pad" pattern.

# bouncer_gate_device.verse
# Press the button to unlock the bouncer.

using { /Fortnite.com/Devices }

bouncer_gate_device := class(creative_device):

    @editable
    LaunchPad : bouncer_device = bouncer_device{}

    @editable
    UnlockButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Bouncer is locked until the button is pressed.
        LaunchPad.Disable()
        # Subscribe to the button's interaction event.
        UnlockButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    OnButtonPressed(A : agent) : void =
        # Enable the bouncer — VFX and audio return automatically.
        LaunchPad.Enable()
        # Disable the button so it can only be pressed once.
        UnlockButton.Disable()
        Print("Launch pad unlocked!")

Pattern 2 — Count bounces and disable after a limit

Track BouncedEvent and shut the pad down after N launches — great for a limited-use power-up pad.

# limited_bouncer_device.verse
# The bouncer deactivates after 5 launches.

using { /Fortnite.com/Devices }

limited_bouncer_device := class(creative_device):

    @editable
    Pad : bouncer_device = bouncer_device{}

    # Maximum number of launches before the pad turns off.
    @editable
    MaxLaunches : int = 5

    var LaunchCount : int = 0

    OnBegin<override>()<suspends> : void =
        Pad.Enable()
        Pad.BouncedEvent.Subscribe(OnBounced)

    OnBounced(MaybeAgent : ?agent) : void =
        set LaunchCount += 1
        Print("Launch {LaunchCount} of {MaxLaunches}")
        if (LaunchCount >= MaxLaunches):
            # Limit reached — kill the pad.
            Pad.Disable()
            Print("Bouncer used up! Pad is now offline.")

Pattern 3 — React to heal events for a medic bouncer

A bouncer configured to heal players in the editor. Use HealStartEvent and HealStopEvent to play custom logic — e.g., track how many times healing was triggered.

# medic_bouncer_device.verse
# Tracks heal events from a healing bouncer.

using { /Fortnite.com/Devices }

medic_bouncer_device := class(creative_device):

    @editable
    HealPad : bouncer_device = bouncer_device{}

    var HealSessions : int = 0

    OnBegin<override>()<suspends> : void =
        HealPad.Enable()
        HealPad.HealStartEvent.Subscribe(OnHealStarted)
        HealPad.HealStopEvent.Subscribe(OnHealStopped)

    # HealStartEvent sends a plain agent — no optional unwrap needed.
    OnHealStarted(A : agent) : void =
        set HealSessions += 1
        Print("Heal session #{HealSessions} started.")

    OnHealStopped(A : agent) : void =
        Print("Heal session ended. Total sessions so far: {HealSessions}")

Gotchas

1. BouncedEvent sends ?agent, not agent — always unwrap

BouncedEvent is typed listenable(?agent). Your handler must accept ?agent and unwrap it:

# CORRECT
OnBounced(MaybeAgent : ?agent) : void =
    if (A := MaybeAgent?):
        # use A as agent

# WRONG — will not compile
OnBounced(A : agent) : void = ...

The event sends false (i.e., option is empty) when something without a driver bounces, such as an unoccupied vehicle or a non-agent projectile.

2. HealStartEvent / HealStopEvent send plain agent — no unwrap

Unlike BouncedEvent, these two events are typed listenable(agent). Your handlers take a plain agent parameter — wrapping it in ? will cause a type mismatch.

3. Enable / Disable also toggle VFX and audio

Calling Disable() doesn't just stop bouncing — it also kills the visual and audio effects. If you want a "silent" pad that's still visually present, you'll need a separate VFX device rather than relying on the bouncer's built-in effects.

4. @editable is mandatory for placed devices

You cannot write bouncer_device{} and expect it to reference a placed actor in your scene. You must declare the field with @editable and then assign the placed device in the UEFN Details panel. Forgetting @editable means the field holds a default (empty) instance that does nothing.

5. Subscribe in OnBegin, not at field initialization

Event subscriptions must happen inside OnBegin (or a function called from it). Subscribing at the class field level is not valid Verse syntax — the runtime infrastructure isn't ready until OnBegin executes.

6. Enable / Disable are fire-and-forget — no return value

Both methods return void. You cannot check whether the device is currently enabled from Verse; track that state yourself with a var boolean if your logic needs it.