The Ghost in the Machine: Mastering Verse Transmitters

Ever wonder how your island knows when someone steps on a pressure plate, picks up a legendary loot box, or gets launched into the stratosphere by a D-Launcher? It’s not magic. It’s Transmitters.

Think of Transmitters as the nervous system of your Fortnite island. Without them, your devices are just lonely statues waiting for a touch that never comes. With them, you can create complex chains of events: "If player enters zone, spawn car. If car is destroyed, play explosion sound and give XP."

In this tutorial, we’re going to demystify Transmitters in Verse. We’ll build a "Chaos Cart" system where picking up a boost not only speeds up your shopping cart but also triggers a secret alarm that lights up the arena in red. No coding experience? Perfect. You already know how this works; you just need to learn the language.

What You'll Learn

• What a Channel is (and why it’s not a TV station).
• How Transmitters act as messengers between devices.
• How to write Verse code to listen for these signals.
• How to build a working "Boost & Alarm" system on your island.

How It Works

The Concept: Channels as Walkie-Talkies

In Fortnite Creative, devices talk to each other using Channels. Imagine a channel is a specific walkie-talkie frequency.

• Transmitter: This is the person sending the message. When a trigger happens (like you entering a zone), the device shouts onto its assigned channel.
• Receiver: This is the person listening. When a device is set to listen to that same channel, it hears the shout and reacts (like turning on a light).

In Verse, we don’t just click settings in the editor. We write code that tells devices exactly when to transmit and when to listen. This gives you superpowers: you can make a transmitter only send a signal if a player has more than 50 shield, or if it’s raining in-game.

The Scene Graph: Who is Talking to Whom?

Before we code, let’s look at the Scene Graph. Think of the Scene Graph as the family tree of your island. Every device (a Prop Mover, a Skydive Volume, a Spawner) is a Node in this tree.

• Parent/Child: Some devices are children of others. If you parent a Light to a Vehicle, the light moves with the car.
• Independence: Most Transmitters and Receivers are siblings or cousins—they don’t need to be related. They just need to share a Channel.

In Verse, we access these nodes by their names. If you name a device "MyBoost" in the editor, your Verse code can find it by looking for MyBoost in the scene.

The "On Player Launched" Example

Let’s look at a common device: the D-Launcher. It has a transmitter option: "On Player Launched."

• Game Mechanic: You stand on the pad, press the button, and whoosh, you fly.
• Verse Translation: We write a function that waits for the "Launched" event. When it happens, the device sends a signal on Channel 1.
• The Receiver: Another device (maybe a Score Counter) is listening to Channel 1. When it hears the signal, it adds 1 point.

Simple, right? Now, let’s make it interesting.

Let's Build It

We are going to build a Shopping Cart Chaos System.

The Goal:

1. A player picks up a Rocket Boost power-up.
2. The Boost Transmits a signal on Channel 100.
3. A Prop Mover (set to change color) listens to Channel 100.
4. When the signal arrives, the Prop Mover turns the arena walls RED for 5 seconds, signaling "CHAOS MODE."

Step 1: Set Up Your Devices (Editor)

1. Place a Rocket Boost Power-Up anywhere. Name it ChaosBoost.
2. Place a Prop Mover (or a Light) that you want to change color. Name it ChaosLights.
   • Editor Tip: In the Prop Mover’s settings, go to the Transmitters tab. Set "When Boost Picked Up Transmit On" to Channel 100. (We’ll also do this in Verse, but setting it here helps you visualize the connection).
3. Place a Second Prop Mover (or Light) that will act as the Receiver. Name it AlarmLights.
   • Editor Tip: Go to the Receivers tab. Set "Receive On Channel" to Channel 100. Set the output to change the color to Red.

Step 2: The Verse Code

Now, let’s write the Verse script that ties this together. We’ll create a script that listens for the boost pickup and then triggers the alarm.

Create a new Verse file in your island project. Let’s call it ChaosSystem.verse.

// ChaosSystem.verse
// This script listens for a Rocket Boost pickup and triggers a chaos alarm.

// 1. Define the Script Structure
// Think of this as the "Brain" of your island. It holds all the logic.
ChaosSystem := script() {
    
    // 2. Declare the Devices (The "Nodes" in our Scene Graph)
    // We tell Verse to find these specific devices by name.
    // If the name in Verse doesn't match the editor, it won't work!
    ChaosBoost := object:RocketBoostPowerUpDevice
    ChaosLights := object:PropMoverDevice
    AlarmLights := object:PropMoverDevice

    // 3. Define the "On Start" Function
    // This runs once when the island starts.
    On Start () -> void {
        // We don't need to do much here, but we could set initial states.
        // For now, let's just log that we're alive.
        Print ("Chaos System Activated. Watch out!")
    }

    // 4. The Event Listener: "On Boost Picked Up"
    // This is the core magic. We subscribe to the Boost's event.
    // When the player picks up the boost, this function runs.
    On RocketBoostPickedUp () -> void {
        // A. Trigger the Alarm Lights immediately
        // We use the PropMover's "Set Color" function.
        // Imagine this as flipping a switch to turn the lights red.
        AlarmLights.Set Color (Color { R: 1.0, G: 0.0, B: 0.0 }) // Red!
        
        // B. Wait for 5 seconds
        // This pauses the script for 5 seconds so the chaos doesn't end instantly.
        Wait (5.0)
        
        // C. Reset the lights
        // Turn them back to normal (White)
        AlarmLights.Set Color (Color { R: 1.0, G: 1.0, B: 1.0 })
        
        // D. Optional: Play a sound or spawn particles here!
        Print ("Chaos Mode Over. Phew.")
    }
    
    // 5. Hooking it up: Connect the Event to the Function
    // We tell the ChaosBoost device: "When you get picked up, run On RocketBoostPickedUp."
    // This is how we link the Transmitter (Boost) to our Logic (Script).
    ChaosBoost.On Picked Up += On RocketBoostPickedUp
}

Walkthrough: What Just Happened?

1. ChaosSystem := script(): This creates our main script. It’s like creating a new folder for our logic.
2. ChaosBoost := object:RocketBoostPowerUpDevice: We’re grabbing the device from the scene. If you named it MyBoost in the editor, change this line to MyBoost := object:RocketBoostPowerUpDevice.
3. On RocketBoostPickedUp () -> void: This is a Function. A function is a reusable block of code that does a specific job. Here, the job is "handle the chaos."
4. AlarmLights.Set Color (...): This is a Method. It’s an action the device can perform. We’re telling the lights to turn red.
5. Wait (5.0): This pauses the script. Without this, the lights would turn red and then immediately turn white, and you’d miss the chaos.
6. ChaosBoost.On Picked Up += On RocketBoostPickedUp: This is the Event Binding. This is the most important line. It connects the Transmitter (the Boost’s "On Picked Up" event) to our Receiver (our On RocketBoostPickedUp function).

Try It Yourself

Now that you’ve built the basic Chaos System, try these challenges to level up:

1. The Multi-Color Party: Modify the code so that every time a boost is picked up, the AlarmLights cycle through different colors (Red, Blue, Green) instead of just staying red. Hint: Use multiple Set Color calls with different Wait times.
2. The Score Keeper: Add a Score Counter device to your island. Make it so that every time the chaos alarm goes off, the score increases by 10. Hint: Look for a Add Score method on the Score Counter device.
3. The Stealth Mode: Make the alarm lights only turn red if the player has less than 50 shield. Hint: You’ll need to check the player’s shield value before setting the color.

Hint for Challenge 3: You’ll need to get the player’s shield value. In Verse, you can often get stats from the player object. Look up Player.Get Shield or similar methods in the Verse documentation.

Recap

• Transmitters are devices that send signals on specific Channels when an event happens.
• Receivers are devices (or Verse scripts) that listen for those signals and react.
• In Verse, you use Events (like On Picked Up) to trigger functions.
• The Scene Graph helps you find and control devices by their names.
• You can build complex systems by chaining these events together.

Now go make your island chaotic. The Storm won’t wait for you, and neither should your code.

References

• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-d-launcher-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-skydive-volume-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-rocket-boost-powerup-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-shopping-cart-spawner-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/usingshoppingcartspawnerdevicesinfortnitecreative