The "Oops, I Broke the Game" Guide to Verse Device Design

So, you've placed a few triggers, maybe wired up a trap that explodes when someone steps on it, and you're feeling pretty slick. But let's be honest: most Fortnite islands are just a bunch of devices staring at each other like awkward strangers at a party. You want them to talk. You want a switch that doesn't just turn on a light, but turns on a light and drops a shield potion and plays a dubstep drop.

That's where Device Design in Verse comes in.

In this tutorial, we aren't just connecting wires. We are teaching devices how to think. We're going to build a "Chaos Button." One press will launch you into the stratosphere, spawn a pile of loot, and then lock the door behind you. No more boring "press E to open door" mechanics. We're making things happen.

What You'll Learn

• The Scene Graph (The Cast List): How Verse sees your island as a family tree of objects.
• Components (The Superpowers): How to attach abilities (like launching or spawning) to simple objects.
• Events (The Trigger Finger): How to listen for player actions without writing a million lines of code.
• Chaining Effects: How to make one action cause three other things to happen, instantly.

How It Works

Before we write a single line of Verse, we need to understand how Unreal Engine 6 (and by extension, Verse) looks at your island.

The Scene Graph: It's All About Family Trees

Imagine your island is a massive family reunion. At the top is the Game Instance (the grandparent). Hanging off that are Levels (the parents), and hanging off those are Actors (the kids).

• Actor: Any object in the world—a player, a wall, a D-Launcher, a loot box.
• Component: The skills an Actor has. A Player Actor has a "Health" component. A D-Launcher has a "Launch" component. Think of Components as the inventory items your character equips. You can't launch people if you don't have the "Launcher" component equipped.

When you write Verse, you are essentially reaching into the family tree, grabbing an Actor, and saying, "Hey, you! Use your Launch Component to blast that player over there."

The Device Design Mindset

In standard Fortnite Creative, you drag a wire from a Trigger to a Device. In Verse, we do the same thing, but we do it in code so we can be precise.

1. The Input: A player steps on a Trigger Volume.
2. The Logic: Verse checks: "Did a player step here? Yes. Okay, find the D-Launcher nearby."
3. The Output: Verse tells the D-Launcher: "Launch that player upwards at 500 units/second."

We aren't just reacting; we are orchestrating.

Let's Build It

We are going to create a script that lives on a Trigger Volume. When a player enters, it finds a specific D-Launcher and fires it.

The Setup (In-Editor)

1. Place a Trigger Volume (set it to trigger on "Enter").
2. Place a D-Launcher somewhere in the air or on the ground.
3. Crucial Step: Give the D-Launcher a unique name in the device properties. Let's call it "ChaosLauncher". This is how our code finds it.

The Verse Code

Copy this into a new Verse Script device placed next to your Trigger Volume.

# We are defining a new Script. Think of this as the "Brain" for our trigger.
# It needs to know about the Trigger Volume (trigger_device) and the
# specific launcher (launch_pad_device).

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

chaos_trigger := class(creative_device):

    # This is our "Inventory" of tools.
    # 'MyLauncher' is a variable that will hold the D-Launcher (crash pad) device.
    # We mark it as '@editable' so we can drag-and-drop the actual device
    # from the world into this slot in the editor.
    @editable
    MyLauncher : crash_pad_device = crash_pad_device{}

    # 'MyTrigger' holds the Trigger Volume we want to listen to.
    @editable
    MyTrigger : trigger_device = trigger_device{}

    # This is the main function. It runs once when the island starts.
    OnBegin<override>()<suspends> : void =
        # 2. LISTEN FOR INPUT
        # We want to know when a player enters the Trigger Volume.
        # We call the Trigger's "TriggeredEvent" and subscribe to it.
        # This is like saying: "Hey Trigger, ring this bell every time someone walks in."
        # We connect that bell to our 'HandlePlayerEnter' function below.
        MyTrigger.TriggeredEvent.Subscribe(HandlePlayerEnter)

    # This function runs EVERY TIME a player activates the trigger.
    # trigger_device fires TriggeredEvent with an optional agent (?agent).
    HandlePlayerEnter(MaybeAgent : ?agent) : void =
        # 3. EXECUTE THE CHAOS
        # Unwrap the optional agent before using it.
        if (Agent := MaybeAgent?):
            # Cast the agent to a fort_character so we can interact with them.
            if (FortCharacter := Agent.GetFortCharacter[]):
                # Launch the player!
                # crash_pad_device has no direct Launch(agent) method;
                # we just enable/disable to trigger the pad's built-in launch for nearby players.
                MyLauncher.Enable()

                # Optional: print a message to the player's HUD.
                if (Player := player[Agent]):
                    Print("BOING! You've been launched!", ?Duration := 3.0)```

### Walkthrough: What Just Happened?

1.  **`chaos_trigger := class(creative_device):`**: We created a new script by extending `creative_device`. This is your custom rulebook.
2.  **`@editable MyLauncher : launch_pad_device = launch_pad_device{}`**: We declared an editable variable. Think of this as an empty slot in your inventory. We labeled it `MyLauncher`. We told Verse, "This slot expects a `launch_pad_device`." Drag your in-world D-Launcher into this slot in the UEFN details panel.
3.  **`@editable MyTrigger : trigger_device = trigger_device{}`**: Same idea — we hold a reference to the Trigger Volume so we can listen to it.
4.  **`OnBegin<override>()`**: This is the "Start Game" function. When the island loads, Verse runs this first.
    *   We subscribed to `MyTrigger.TriggeredEvent` so Verse calls our function whenever the trigger fires. This is like saying: "Hey Trigger, ring this bell every time someone walks in."
5.  **`MyTrigger.TriggeredEvent.Subscribe(HandlePlayerEnter)`**: This is the magic. We attached a listener. Whenever the Trigger Volume fires (someone walks in), it automatically calls our `HandlePlayerEnter` function.
6.  **`MyLauncher.Activate(Agent)`**: We reached into our `MyLauncher` slot and fired it. We told it *who* to launch by passing the `Agent` that activated the trigger.

## Try It Yourself

You've got the basic "Launch" mechanic down. Now, make it harder.

**The Challenge:**
Modify the script so that the launch only happens if the player is holding a **Shotgun**. If they are holding anything else (or nothing), send them a message: "Nice try, but you need a shotgun to activate the Chaos Button!"

**Hint:**
You'll need to check the player's inventory. Look up the `fort_character` interface's `GetEquippedWeapon` or similar method in the Verse documentation. You'll need to compare the weapon's template name to identify a shotgun.

## Recap

*   **Scene Graph:** Your island is a family tree. Actors are objects, Components are their skills.
*   **Variables:** These are your inventory slots. Use `@editable` to store references to devices (like our `MyLauncher` and `MyTrigger`) that you wire up in the UEFN editor.
*   **Events:** These are your triggers. Use `.Subscribe()` to attach functions that run when things happen (like `TriggeredEvent`).
*   **Chaining:** You can find a device, check its state, and then call its methods to change the game world.

Now go forth and break some physics. Or at least launch some players into the sky.

## References

- https://dev.epicgames.com/documentation/en-us/fortnite-creative/device-design-examples-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite/device-design-examples-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite/31-10-fortnite-ecosystem-updates-and-release-notes-in-creative-and-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/fortnite/34-10-fortnite-ecosystem-updates-and-release-notes
- https://dev.epicgames.com/documentation/en-us/uefn/31-10-release-notes-in-unreal-editor-for-fortnite