---
title: "Creative Devices 101 — Learning Path"
date: "2026-06-21"
category: "education"
excerpt: "Welcome to Verse Device Communication! In this learning path, you'll discover how to make Fortnite Creative devices talk to each other using Verse code. You'll learn to listen for player actions like button presses, run code when events happen, and chain devices together to build amazing game logic—all the skills you need to create interactive islands that respond to what players do."
level: "grade4-6"
estimated_minutes: 45
author: "Verse Cortex"
status: "published"
---

# Creative Devices 101

Welcome to Verse Device Communication! In this learning path, you'll discover how to make Fortnite Creative devices talk to each other using Verse code. You'll learn to listen for player actions like button presses, run code when events happen, and chain devices together to build amazing game logic—all the skills you need to create interactive islands that respond to what players do.

**Reading level:** grade4-6  ·  **Estimated time:** 45 min  ·  **Lessons:** 2

## What You'll Learn

- Subscribe to device events and write handler functions that respond when players interact with buttons
- Understand how events, listeners, and handlers work in game development
- Trigger devices from Verse code and pass information between devices using channels
- Build connected game logic that chains multiple devices together into playable challenges

---

## Lesson 1: Subscribing to Device Events in Verse

**Objectives:**

- Explain what an event and a handler (listener function) are, using a real Fortnite button device as the example.
- Use Subscribe() to connect a Verse function to a button_device's InteractedWithEvent so something happens when a player presses the button.
- Write a simple handler function that receives an agent (the player who triggered the event) and runs game logic.
- Place a Button device and a Verse device in UEFN and link them together with the @editable tag.

### 🎮 What Is an Event?

Imagine you set a **tripwire trap** in your bedroom. The second someone walks through it — *ZAP!* — a buzzer goes off. The "someone walks through the wire" moment is called an **event**. An event is something that happens during the game that your code can *listen* for and react to.

In Fortnite Creative, devices already have built-in events. For example:
- A **Button** device has an event called **`InteractedWithEvent`** — it fires whenever a player walks up and presses the button.
- An **Input Trigger** device has **`PressedEvent`** and **`ReleasedEvent`** — they fire when a player presses or lets go of a certain key.

---

### 📻 What Is Subscribing?

Think of a **podcast subscription**. Once you subscribe, every new episode shows up automatically. You don't have to check manually!

**Subscribing to an event** works the same way. You tell Verse: *"Hey, whenever this button is pressed, automatically call MY function."* After that, your code runs itself every single time the event fires — no manual checking needed.

The word for doing this in Verse is **`Subscribe()`**.

---

### 🤚 What Is a Handler?

The function you connect to an event is called a **handler**. Think of a handler like a **catcher's mitt** in baseball. The event throws the ball (signals that something happened), and your handler catches it and decides what to do next.

In Verse, a handler is just a regular function — but it must follow one rule: **it must accept the right inputs**. For a `button_device`'s `InteractedWithEvent`, the handler must accept one input called an **`agent`**. An `agent` is Verse's word for *the player who triggered the event*.

---

### 🏗️ How Do You Set It All Up?

Here are the four steps you follow every time:

1. **Place your devices** — Drop a Button device and a Verse Device onto your island in UEFN.
2. **Add an `@editable` property** — This is a special tag that lets you *drag and drop* your Button device into your Verse script from the UEFN editor panel. Think of it like a slot on a LEGO brick where you plug another brick in.
3. **Subscribe in `OnBegin`** — `OnBegin` is the function that runs the instant your island starts. It's the perfect place to set up your subscriptions, so they're ready before any player touches anything.
4. **Write your handler function** — This is the code that actually runs when the button is pressed.

---

### 🔌 Quick Vocab Cheat Sheet

| Word | Plain Meaning |
|---|---|
| **Event** | Something that happens in the game (button pressed, player arrives, timer ends) |
| **Subscribe** | Sign up to be notified when an event happens |
| **Handler** | Your function that runs when the event fires |
| **`agent`** | The player who caused the event |
| **`@editable`** | A tag that lets you link a device to your script in the UEFN editor |

### Worked Example

### 🛠️ Worked Example: Glow-Up Button

**The Scenario:** A player walks up to a glowing button on your island and presses it. Your Verse code detects it and prints a celebration message. (Once you have the basics working, you can swap the Print for any cool game action!)

**Before you code:**
1. Open UEFN and create a new island.
2. From the **Content Browser**, drag a **Button Device** onto the island.
3. Drag a **Verse Device** onto the island too.
4. Open your Verse file (created when you added the Verse Device).

**Here's the complete code:**

```verse
# These two lines import the tools we need.
# Think of them like opening your toolbox before building.
using { /Fortnite.com/Devices }   # gives us button_device and other devices
using { /Verse.org/Simulation }    # gives us OnBegin and basic Verse tools

# This is our Verse device — the "brain" we placed on the island.
button_celebration_device := class(creative_device):

    # @editable means this slot shows up in the UEFN editor panel.
    # Drag your Button Device from the scene into this slot!
    @editable
    MyButton : button_device = button_device{}

    # OnBegin runs ONCE when the island starts — perfect for setup.
    OnBegin<override>()<suspends> : void =
        # Subscribe = "hey, call OnButtonPressed whenever MyButton is pressed"
        # OnButtonPressed is the name of our handler function below.
        MyButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    # This is our HANDLER — the catcher's mitt.
    # It runs automatically every time the button is pressed.
    # InAgent is the player who pressed the button.
    OnButtonPressed(InAgent : agent) : void =
        Print("🎉 A player pressed the button! Amazing!")
```

**Walkthrough — line by line:**

- **`using { /Fortnite.com/Devices }`** — Opens the toolbox that knows about `button_device`.
- **`@editable`** — Creates a visible slot in UEFN so you can plug in the real Button device.
- **`MyButton : button_device = button_device{}`** — Declares a variable named `MyButton` that holds a button device. The `= button_device{}` part is just a placeholder until you drag the real one in.
- **`OnBegin<override>()<suspends> : void =`** — This runs at game start. `override` means we're upgrading the default version. `suspends` means it can wait for things.
- **`MyButton.InteractedWithEvent.Subscribe(OnButtonPressed)`** — This is the magic line! It tells Verse: *"Watch MyButton. When InteractedWithEvent fires, call OnButtonPressed."*
- **`OnButtonPressed(InAgent : agent) : void =`** — Our handler. `InAgent` is who pressed it. `void` means it doesn't hand back a value — it just *does* something.
- **`Print("🎉 ...")`** — Shows a message in the UEFN output log. You'll see it when you test!

**To test it:**
1. In the UEFN editor, click your Verse Device in the scene.
2. In the **Details** panel, find the **MyButton** slot and drag your Button Device into it.
3. Click **Launch Session** and walk up to the button. Press it — check the output log! 🎉

### Try It Yourself

### 🏋️ Your Turn: Double-Button Detector

You're going to build an island with **two** Button devices. When a player presses **Button A**, print one message. When they press **Button B**, print a different message.

**Steps to follow:**
1. Place **two** Button devices on your island. Name them something helpful in UEFN (like "ButtonA" and "ButtonB").
2. In your Verse device class, add **two** `@editable` properties — one for each button.
3. In `OnBegin`, call `Subscribe()` on **both** buttons, each pointing to its own handler function.
4. Write **two** handler functions with different `Print` messages.

**Hint 🔍:** Your `OnBegin` should have two `Subscribe` lines that look like this:

```verse
MyButtonA.InteractedWithEvent.Subscribe(OnButtonAPressed)
MyButtonB.InteractedWithEvent.Subscribe(OnButtonBPressed)
```

Each handler still needs to accept `(InAgent : agent)` as its input — don't forget that part!

**Bonus Challenge ⭐:** Can you change the printed message to say something different depending on WHICH button was pressed? (Hint: you already are — one handler per button!)

**Check yourself:** Launch your session, press Button A, then Button B. Do you see two *different* messages in the output log? If yes — you did it! 🥳

### Quiz

1. In Verse, what does 'subscribing to an event' mean?
   - A. Deleting a device from the island
   - B. Signing up so your function runs automatically when the event fires
   - C. Downloading a new Fortnite update
   - D. Creating a new player character

2. What is the name of the event on a button_device that fires when a player presses it?
   - A. PressedEvent
   - B. ButtonClickedEvent
   - C. InteractedWithEvent
   - D. OnBeginEvent

3. What does the @editable tag do in a Verse class?
   - A. Makes the device invisible during gameplay
   - B. Causes the function to run at game start
   - C. Creates a slot in the UEFN editor so you can drag a real device into your script
   - D. Prints a message to the output log

4. A handler function for button_device's InteractedWithEvent must accept which type of input?
   - A. An int (a whole number)
   - B. A string (some text)
   - C. A float (a decimal number)
   - D. An agent (the player who triggered the event)

**Answer key:**

1. B — Subscribing means you register your handler function with an event. From that point on, every time the event fires (like a button being pressed), your function runs automatically — just like getting a podcast episode delivered to you!
2. C — The button_device uses InteractedWithEvent. It fires when a player successfully interacts with (presses) the button. PressedEvent belongs to the input_trigger_device, which is a different device!
3. C — @editable is like adding a port on the back of your gaming console. It creates a visible slot in the UEFN Details panel so you can plug in (drag and drop) the real device from your island into your Verse code.
4. D — The InteractedWithEvent sends along the agent — meaning the player who pressed the button. Your handler must accept (InAgent : agent) as its parameter, or Verse won't let you subscribe to it. Think of agent as Verse's word for 'a player in the game.'

### Recap

### 🌟 Great Work — Here's What You Learned!

An **event** is something that happens in the game — like a player pressing a button. **Subscribing** means telling Verse: *"Run my function every time that event fires."* The function you connect is called a **handler**, and for a `button_device`, it must accept an **`agent`** (the player who caused the event). You set up subscriptions in **`OnBegin`**, and you use **`@editable`** to link real devices from your island into your Verse code. Now your island can truly *react* to players! 🎮

**Sources:**

- /docs/documentation/en-us/fortnite/coding-device-interactions-in-verse
- /docs/documentation/en-us/uefn/verse-api/fortnitedotcom/devices/input_trigger_device
- /docs/documentation/en-us/uefn/verse-api/fortnitedotcom/devices/button_device
- /docs/documentation/en-us/uefn/coding-device-interactions-in-verse

---

## Lesson 2: Triggering Devices and Building Game Logic with Channels

**Objectives:**

- Connect a Button device to a Verse script using Subscribe() so your code runs when a player presses the button.
- Explain what an event, a handler function, and subscribing mean using everyday game analogies.
- Use a channel_device (Transmit and ReceivedTransmitEvent) to link multiple devices together in a game logic flow.
- Build a playable island challenge where pressing a button spawns an item and fires a channel signal to trigger a second device.

### 🎮 What Are We Building?

Imagine a locked treasure room. A player walks up, presses a glowing button, and — *boom* — a weapon appears AND a door swings open! That's what you'll make today. You'll write Verse code that listens for a button press and then kicks off a whole chain of cool things.

---

### 📣 What Is an Event?

An **event** is like a doorbell. When someone rings it, it tells your house "hey, something happened!" In Fortnite devices, events fire automatically when something occurs in the game — like a player pressing a button or stepping on a trigger pad.

Your Verse code can **listen** for those doorbells. When one rings, your code wakes up and does something.

---

### 🔔 What Is Subscribing?

**Subscribing** means telling the game: *"Hey, whenever THAT doorbell rings, call MY function."*

Think of it like signing up for a pizza delivery notification. When the pizza arrives (the event), you get a text (your function runs).

The function you attach is called a **handler**. It's the code that "handles" what happens when the event fires.

```
Subscribe(YourHandlerFunction)
```

---

### 🧩 The Button Device: `button_device`

A **Button device** is a physical glowing button you place on your island. Players walk up and press **E** to interact with it.

In Verse, the button has a built-in event called **`InteractedWithEvent`**. It fires every time a player presses the button.

Here's how you hook your code to it:

```verse
MyButton.InteractedWithEvent.Subscribe(OnButtonPressed)
```

That one line says: *"When the button is pressed, run my function called `OnButtonPressed`."*

---

### 📡 What Is a Channel Device?

A **channel device** (`channel_device`) is like a walkie-talkie for your devices. One device talks (transmits a signal), and any other device that's listening hears it and reacts.

- **`Transmit()`** — this is the "talk" button. It sends a signal out.
- **`ReceivedTransmitEvent`** — this is the "listen" side. Other code can subscribe to this to hear the signal.

You can chain devices together like dominoes! Button press → channel transmits → door opens. 🎉

---

### 🏗️ How to Set Up Your Devices in UEFN

Before writing code, you need to place these devices on your island:

1. 🟡 **Button device** — the thing the player presses.
2. 📦 **Item Spawner device** — drops a weapon or item when told to.
3. 📡 **Channel device** — the relay that sends signals to other devices.
4. 🔲 **Mutator Zone or Timer device** (optional, for extra challenge) — can react to the channel signal.

> **Tip:** Use `@editable` in your Verse code so you can drag-and-drop the real devices into the slots in the UEFN editor. This connects your code to the actual devices on the island!

---

### 🔑 Key Words Cheat Sheet

| Word | Plain Meaning |
|---|---|
| **Event** | A doorbell — something that happened in the game |
| **Subscribe** | Sign up to be notified when an event fires |
| **Handler** | The function that runs when the event fires |
| **channel_device** | A walkie-talkie relay that forwards signals |
| **Transmit()** | Sending a signal through the walkie-talkie |
| **@editable** | Lets you plug a real device into your code slot in the editor |

### Worked Example

### 🏆 Worked Example: Button Press → Spawn Item → Signal the Channel

**The goal:** A player presses a button. An item spawns. Then a channel signal fires so other devices (like a door or timer) can react too!

**In UEFN, place these devices on your island:**
- 1 Button device
- 1 Item Spawner device (set it to drop a weapon you like)
- 1 Channel device

Then create a Verse device file called `treasure_room_device` and write this code:

```verse
# These lines "import" the tools we need. Think of them as opening your toolbox.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# This is our custom Verse device. It's like creating a new remote control.
treasure_room_device := class(creative_device):

    # @editable means we can drag a real Button device into this slot in UEFN.
    @editable
    MyButton : button_device = button_device{}

    # Drag your Item Spawner device into this slot in UEFN.
    @editable
    MyItemSpawner : item_spawner_device = item_spawner_device{}

    # Drag your Channel device into this slot in UEFN.
    @editable
    MyChannel : channel_device = channel_device{}

    # OnBegin runs automatically when the game starts. It's like the START button.
    OnBegin<override>()<suspends> : void =
        # Subscribe means: "Hey button, when someone presses you, call OnButtonPressed!"
        MyButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    # This is the handler — the code that runs when the button is pressed.
    # InAgent is the player who pressed the button.
    OnButtonPressed(InAgent : agent) : void =
        # Tell the Item Spawner to drop its item right now!
        MyItemSpawner.SpawnItem()

        # Send a signal through the Channel device — like pressing the walkie-talkie button!
        # This lets OTHER devices react to the same button press.
        MyChannel.Transmit(InAgent)

        Print("Button pressed! Item spawned and channel signal sent! 🎉")
```

---

### 🚶 Walkthrough — What Happens Step by Step

1. **Game starts** → `OnBegin` runs. The button is now "listening" for a press.
2. **Player walks up to the button and presses E** → `InteractedWithEvent` fires (the doorbell rings!).
3. **`OnButtonPressed` runs** — this is our handler.
4. **`MyItemSpawner.SpawnItem()`** tells the Item Spawner to drop the weapon immediately.
5. **`MyChannel.Transmit(InAgent)`** sends a signal through the channel device. Any other device wired to this channel (like a door or a timer) will now react too!
6. The `Print` message shows up in the log so you know it worked. ✅

---

### 🔌 Wiring It in UEFN

After you write the code:
1. Go to **Verse > Build Verse Code** in the menu bar.
2. Drag your `treasure_room_device` from the Content Browser into your level.
3. Click your Verse device in the level, and in the **Details panel**, drag the real Button, Item Spawner, and Channel devices into the matching `@editable` slots.
4. Hit **Launch Session** and test it! Press the button and watch the magic. 🪄

### Try It Yourself

### 🛠️ Your Turn: Build a Two-Button Combo Lock!

**The challenge:** Create an island where the player must press **two separate buttons** to unlock a reward. Each button fires its own handler. When a player presses **both** buttons (in any order), an Item Spawner drops a legendary weapon!

**Here's how to think about it:**

- You'll need **two** `button_device` editable properties.
- You'll need a way to track whether each button has been pressed. Think about using a `var` variable that starts as `false` and becomes `true` when pressed.
- After each button press, check: are BOTH variables `true`? If yes, call `SpawnItem()`!

**Devices to place on your island:**
- 2 Button devices (label them Button 1 and Button 2)
- 1 Item Spawner device
- 1 Channel device (bonus: fire it when both buttons are pressed!)

**Hint — tracking state with variables:**
```verse
# A var variable can change during the game. false means "not pressed yet."
var Button1Pressed : logic = false
var Button2Pressed : logic = false
```

Inside your handler for Button 1, you can set it like this:
```verse
set Button1Pressed = true
```

Then check both with an `if`:
```verse
if (Button1Pressed? and Button2Pressed?):
    MyItemSpawner.SpawnItem()
```

> 💡 **Remember:** Use `Subscribe` in `OnBegin` for BOTH buttons! Each button needs its own handler function.

**Bonus challenge 🌟:** After the item spawns, use `MyChannel.Transmit(InAgent)` to send a signal so a door or barrier device also opens!

### Quiz

1. What does calling Subscribe() on a device event do?
   - A. It destroys the device when the game starts.
   - B. It tells your code to run a specific function whenever that event fires.
   - C. It makes the device invisible to players.
   - D. It creates a new button on the island automatically.

2. In the worked example, what is the role of MyChannel.Transmit(InAgent)?
   - A. It prints a message to the game log.
   - B. It stops the button from being pressed again.
   - C. It sends a signal through the channel device so other devices can react.
   - D. It spawns an item directly from the channel device.

3. What does the @editable tag do in your Verse code?
   - A. It makes the variable change every second during the game.
   - B. It lets you plug a real placed device into your code slot using the UEFN editor.
   - C. It makes the device glow in the dark on the island.
   - D. It automatically subscribes the device to all events.

4. What is a handler function?
   - A. A function that runs at the very end of the game.
   - B. The code that decides where to place devices on your island.
   - C. The function that runs automatically when a subscribed event fires.
   - D. A special button that only the game host can press.

**Answer key:**

1. B — Subscribe() is like signing up for a notification. It says: 'When this event fires (like a button press), run MY handler function.' The other options don't describe what Subscribe does at all!
2. C — Transmit() is the 'talk' button on a walkie-talkie. It sends a signal out through the channel_device so any other device listening on that channel can react — like a door opening or a timer starting!
3. B — @editable creates a slot you can see in the UEFN Details panel. You drag your real placed device (like a Button) into that slot, and your code can then talk to it. Without @editable, your code wouldn't know which device on the island to use!
4. C — A handler is the function you 'attach' to an event using Subscribe(). When the event fires (like a player pressing a button), the handler is what gets called and runs your game logic. Think of it as the code that 'handles' what happens next!

### Recap

### 🎉 Great Work — Here's What You Learned!

Today you learned that **events** are like doorbells — they fire when something happens in the game. You used **`Subscribe()`** to connect a handler function to a button press, so your code runs automatically when a player interacts. You also discovered that a **`channel_device`** acts like a walkie-talkie relay, letting one event trigger a whole chain of devices using **`Transmit()`**. Put it all together, and you can build real game logic flows — buttons, item spawners, and signals — all working as a team! 🏆

**Sources:**

- /docs/documentation/en-us/fortnite/coding-device-interactions-in-verse
- /docs/documentation/fortnite/verse-api/fortnitedotcom/devices/channel_device
- /docs/documentation/en-us/fortnite/verse-api/fortnitedotcom/devices/channel_device
- /docs/documentation/en-us/uefn/coding-device-interactions-in-verse
- /docs/documentation/en-us/fortnite/create-your-own-device-using-verse-in-unreal-editor-for-fortnite

---

*Verse code in this path was validated against the Verse Cortex knowledge base: 31 symbol(s) grounded, 9 unverified.*

*Generated by Verse Cortex on 2026-06-21.*