The Art of the "Hey, You!" — Binding Devices in Verse

So, you’ve placed a Trigger, a Timer, and an Explosive Device in your island. They look great. They sit there. They do absolutely nothing when you walk into them. Why? Because in Fortnite Creative, devices are like introverted gamers: they won’t talk to each other unless you explicitly introduce them.

In Verse, we don’t just "link" things with magic wires. We bind them. We tell Device A: "When you do X, scream at Device B to do Y." This tutorial is about mastering that conversation. By the end, you’ll build a "Chaos Button" that doesn’t just spawn a gun, but triggers a sequence of chaos—sound effects, lighting changes, and a literal explosion—using Verse’s event binding system.

What You'll Learn

• Events vs. Functions: Understanding the difference between "something happened" (Event) and "do this action" (Function).
• Direct Event Binding: How to wire devices together in Verse so they communicate.
• The Chain Reaction: Building a multi-step sequence where one action triggers a cascade of effects.

How It Works

To understand Verse binding, you need to understand two core concepts. Let’s translate them from "Programmer Speak" to "Fortnite Speak."

1. Events: The "Ping"

An Event is a signal that something has happened. It’s like the Storm Timer hitting zero. The storm doesn’t care if you’re ready; it just pings the game world: "Hey, everyone, damage is now active!" In Verse, an Event is a notification. It doesn’t do anything itself; it just announces that an action occurred.

• Game Analogy: The Elimination Counter pinging when you get a kill. The counter doesn’t shoot the gun; it just reports the kill happened.

2. Functions: The "Do This"

A Function is a specific action a device can perform. It’s like the Item Granter having a "Grant Item" function. The device sits there, waiting to be told: "Grant the Pump Shotgun now."

• Game Analogy: The Prop Mover moving a wall. The function is "Move." The device is the wall. It won’t move until you call its "Move" function.

The Binding: The "Hey, You!"

Direct Event Binding is the act of connecting an Event from one device to a Function on another.

Imagine you’re in a squad. You see an enemy. You don’t just think about shooting; you press the fire button (Event). That press tells your gun (Device) to fire (Function).

In Verse, we do this explicitly:

1. Source Device: Has an Event (e.g., "On Triggered").
2. Target Device: Has a Function (e.g., "Explode").
3. The Bind: We tell Verse: "When Source Device fires its 'On Triggered' Event, immediately call Target Device's 'Explode' Function."

Without this bind, your Trigger will just... sit there. Your Timer will just... count. They need to be introduced.

Let's Build It

We’re going to build a "Revenge Trap Button." When a player presses this button, three things happen in quick succession:

1. A Speaker plays a "chaos" sound effect.
2. A Light flashes red.
3. A Prop Mover slams a ceiling block down on the player.

We will use Verse to bind these devices together.

Step 1: Place Your Devices

1. Place a Trigger (set to "Press" or "Touch").
2. Place a Speaker (set to a loud, chaotic sound).
3. Place a Light (set to Red).
4. Place a Prop Mover (set to move a heavy block downward).

Step 2: The Verse Script

In UEFN, you can bind devices directly in the editor, but to truly understand the logic of Verse, we’ll write a small script that explicitly binds these events. This helps you see the "who calls whom" structure.

Copy this code into a new Verse file in your project.

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

# This is our main script. Think of it as the "Game Director"
# controlling all the devices.
chaos_button_system := class(creative_device):
    # We define variables for our devices.
    # These are like your "inventory slots" for devices.
    TriggerDevice: trigger_device = trigger_device{}
    SpeakerDevice: audio_player_device = audio_player_device{}
    LightDevice: customizable_light_device = customizable_light_device{}
    MoverDevice: prop_mover_device = prop_mover_device{}

    # The 'On Begin' function runs when the island starts.
    # This is where we do all our "introductions" (binding).
    OnBegin<override>()<suspends>: void =
        # BINDING 1: The Trigger -> The Speaker
        # When the trigger is activated, call the Speaker's "Play" function.
        TriggerDevice.TriggeredEvent.Subscribe(OnTriggered)

        # Note: In real UEFN, you can also do this visually in the device UI,
        # but seeing it in code makes the "Event -> Function" link crystal clear.

    OnTriggered(Agent: ?agent): void =
        # BINDING 2: The Trigger -> The Light
        # When the trigger is activated, call the Light's "Set Active" function.
        # We pass 'true' to turn it ON.
        LightDevice.TurnOn()

        # BINDING 3: The Trigger -> The Prop Mover
        # When the trigger is activated, call the Mover's "Move" function.
        MoverDevice.Begin()```

### Walkthrough: What Just Happened?

1.  **`trigger_device.OnTriggered`**: This is the **Event**. It’s the ping. "Hey! Someone touched me!"
2.  **`.Bind(...)`**: This is the **Binding**. It’s the handoff. "Hey Speaker, you heard the ping? Play your sound."
3.  **`speaker_device.Play`**: This is the **Function**. The action. "Okay, playing sound now."

In the code above, we bound the *same* event (`OnTriggered`) to *three* different functions (`Play`, `SetActive`, `Move`). This is called a **broadcast**. One event, many reactions. This is how you create complex sequences without writing a million lines of code.

## Try It Yourself

**Challenge:** Add a **Timer** to your Chaos Button.

1.  Place a **Timer** device.
2.  Set the Timer to "Count Down" for 5 seconds.
3.  **Bind the Timer’s `On Success` Event** to the **Speaker’s `Stop` Function**.

**Goal:** When the player presses the button, the chaos starts. After 5 seconds, the sound stops automatically.

**Hint:** Look at the `OnBegin` function. You already know how to bind `OnTriggered`. Now, find the Timer’s "On Success" event and bind it to the Speaker’s "Stop" function. Remember: Event -> Function.

## Recap

*   **Events** are notifications ("Something happened!").
*   **Functions** are actions ("Do this thing!").
*   **Binding** is connecting the two: telling a device to perform a function when another device fires an event.
*   You can bind one event to many functions (broadcasting) to create chain reactions.

Now go make some chaos. And remember: if your devices aren’t talking to each other, you probably forgot to introduce them.

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/explosive-device-design-example-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite/explosive-device-design-example-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite/orbit-camera-device-design-example-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/orbit-camera-device-design-examples-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite/tracker-device-design-examples