Level Up Your Island: The "Hello World" of Verse

Welcome to the big leagues. You’ve placed your Player Spawns, you’ve dragged in some props, and now you’re staring at a blank Verse file like it’s a fresh Battle Bus ride—full of potential, but slightly terrifying. Don’t worry. We aren’t writing a compiler today; we’re writing a script for your island.

In this tutorial, we’re going to set up the absolute foundation of any Verse-powered island: The Scene Graph and Device Binding. Think of this as teaching your props how to listen to commands. By the end, you’ll have a platform that doesn’t just sit there looking pretty—it’ll actually react to the game starting. No more static scenery. Let’s make things move.

What You'll Learn

• The Scene Graph: Understanding why your props aren’t just floating objects, but part of a family tree.
• Device Binding: How to connect a physical object (a prop) to a Verse script so they can talk to each other.
• The Setup Function: The "game start" trigger that initializes your island’s logic.
• Visibility Control: Using Verse to hide and show props, the digital equivalent of toggling a light switch.

How It Works

Before you write a single line of code, you need to understand where your code lives. In Fortnite Creative, you might be used to dragging a "Prop Mover" device and connecting wires. In Verse, we don’t use wires. We use References.

The Scene Graph: It’s All About Family

Imagine your island is a house. The Scene Graph is the floor plan. Every single thing on your map—a Player Spawn Pad, a wall, a floating platform, even the sky—is an Entity (a specific object in the game world). These entities are organized in a hierarchy. A platform might be "inside" a room, which is "inside" the island.

In Verse, you don’t just say "hide the platform." You have to point to the specific platform you placed in the editor. This is called Binding. It’s like naming your dog. If you have two dogs, you can’t just yell "Sit!" and expect the right one to obey. You have to say, "Buster, sit!" In Verse, binding is how you name your props so your code knows exactly which one to control.

The Setup Function: The Starting Whistle

In programming, we often have a "main" function that runs first. In Verse, for island scripts, this is usually the Setup function. Think of Setup as the moment the Battle Bus doors open. It’s the very first thing that happens when the match loads.

Inside Setup, we do our "housekeeping." We find our props, we check if they exist, and we set their initial state. If you want a platform to disappear when the game starts, you don’t do it in the editor. You do it in Setup. You’re telling the engine: "Hey, when the match starts, go find this specific platform and make it invisible."

Why No Wires?

You might miss the colorful wires of UEFN. But Verse is stronger. With wires, if you delete a device, the whole chain breaks. With Verse, you bind a reference once. If you move the prop, the code still works because it’s holding onto the identity of that prop, not a fragile wire connection. It’s the difference between a physical remote control and a smart-home app.

Let's Build It

We’re going to build a simple "Vanishing Platform." When the game starts, a specific hover platform will disappear. It’s the programming equivalent of a trapdoor opening.

Step 1: The Setup

1. Open UEFN and create a new Verse project (or use the Verse Starter Template).
2. In the Level Editor, place a Player Spawn Pad. This is where the player appears.
3. Place an Airborne Hoverplatform A (or any prop). Let’s call this our "Vanishing Platform."
4. Place a Verse Device somewhere in your map. This is the brain that will run our code.

Step 2: Writing the Code

Open the Verse file associated with your Verse Device. We need to bind our platform to a variable.

# This is our main script file. Think of it as the brain of the island.

# 1. Define the Script
# This tells Verse: "I am a script that runs on this island."
script VanishingPlatformScript: island script {
    # 2. The Binding: Our "Name Tag" for the Prop
    # We create a variable called `VanishingPlatform` that expects a Prop.
    # When you place the Verse Device in the editor, you will drag your 
    # Hoverplatform into this slot in the Details Panel.
    VanishingPlatform: prop = prop{}

    # 3. The Setup Function: The "Game Start" Trigger
    # This runs automatically when the match begins.
    Setup()<suspends>: void = {
        # Check if the platform was actually bound (dragged in)
        if (VanishingPlatform != prop{}) {
            # 4. The Action: Hide the platform
            # We call the Hide() method on our prop.
            # This makes it invisible AND removes its collision 
            # (so players can walk through it).
            VanishingPlatform.Hide()
            
            # Optional: Print a message to the console for debugging
            # This is like the "Elimination Feed" for code errors.
            print("Platform is now gone! Good luck!")
        } else {
            # If you forgot to bind the prop, tell us!
            print("Error: No platform bound to the script!")
        }
    }
}

Walkthrough: What Just Happened?

1. script VanishingPlatformScript: island script { ... }: This defines our script. It’s like creating a new custom device in the Creative Device tab.
2. VanishingPlatform: prop = prop{}: This is our Variable. We declared a slot for a prop. The = prop{} part is a placeholder. When you go back to the editor and select your Verse Device, you’ll see VanishingPlatform in the details panel. You drag your Hoverplatform into that slot. Now, the code knows which prop is which.
3. Setup()<suspends>: void = { ... }: This is our entry point. The <suspends> tag means this function can pause and wait for things (though we aren’t using that here). It runs once at the start.
4. if (VanishingPlatform != prop{}): This is a Conditional Check. It’s like asking, "Did the player actually drag a platform into the slot?" If the variable is still empty (equal to prop{}), we skip the code. This prevents crashes if you forget to bind something.
5. VanishingPlatform.Hide(): This is the Method Call. We’re telling the specific prop we bound to "Hide yourself." In Verse, props have built-in actions like Hide(), Show(), Enable(), and Disable().

Why This Matters

You might think, "I could just hide the prop in the editor." But what if you want it to reappear later? What if it disappears only when the storm hits? By binding it in Verse, you’ve unlocked its potential. You’ve given it a voice.

Try It Yourself

Now that you’ve got a platform vanishing at the start, let’s make it more interactive.

Challenge: Modify the script so that the platform reappears 5 seconds after the game starts.

Hint:

1. You’ll need to use the Show() method instead of (or in addition to) Hide().
2. To wait 5 seconds, you can use the Wait() function. It looks like this: Wait(5.0) (the .0 makes it a decimal number, which Verse prefers for time).
3. Order of operations matters! If you want it to hide then show, you need to sequence your commands.

Don’t peek at the solution yet! Try to figure out the order of the lines. If you get stuck, remember: Setup runs once, but you can put multiple lines of code inside it.

Recap

• Scene Graph: Your island is a hierarchy of entities. Verse lets you target specific entities.
• Binding: You connect a Verse variable to a physical prop in the editor. This is how your code talks to your map.
• Setup: The Setup function is your game-start trigger. Use it to initialize states.
• Methods: Props have built-in actions like Hide() and Show(). Call them to change the game world.

You’ve just written your first functional Verse script. It’s simple, but it’s the foundation for everything from complex traps to full-game modes. Now go make something that breaks (in a fun way).

References

• https://github.com/vz-creates/uefn
• https://dev.epicgames.com/documentation/en-us/fortnite/disappearing-platform-on-loop-using-verse-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/synchronized-disappearing-platforms-using-verse-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/using-stat-creator-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/fortnite/verse-starter-07-final-result-in-unreal-editor-for-fortnite