The "Don't Touch the Floor" Protocol: Building Your Verse Play Space

So you’ve got the vision. You want to build the next big Battle Royale map, or maybe just a chaotic obstacle course where players bounce off roofs like ragdolls. But right now, your island looks like a developer’s sketch: empty grids, floating primitives, and zero soul.

In this tutorial, we aren’t just placing walls. We are constructing the Play Space—the physical container for your game logic. We’re going to use Verse’s Scene Graph (the hierarchy of everything in your game) to place floating platforms, set up obstacles, and ensure your players know exactly where they start and where they need to go. If your play space is boring, your Verse code will be bored. Let’s fix that.

What You'll Learn

• The Scene Graph: How to treat your island like a family tree of objects (Entities and Components).
• Spatial Logic: Using Verse to interact with physical objects (like floating platforms) without manually tweaking every pixel.
• Grid vs. Prop Mode: Why "snapping" matters for Verse compatibility.
• The "Reachability" Check: A simple logic flow to ensure your bouncy ATK awnings actually work.

How It Works

The Scene Graph: Your Island’s Family Tree

In Fortnite Creative, you drag and drop props. In Verse, everything you see is an Entity.

Think of an Entity like a Player Character. It’s a single, distinct thing in the world. It has a name, a location, and a set of stats.

Now, think of a Component. If the Player is the Entity, the Component is their Loadout. One player might have a shotgun (a "Weapon" component). Another might have a shield (a "Health" component). They are the same "Player" entity, but they behave differently because of their components.

When you build your play space, you are creating a hierarchy.

1. The World: The root of the tree.
2. The Play Space: A specific container Entity you define.
3. The Platforms: Child Entities attached to the Play Space.
4. The Obstacles: Other Child Entities.

Verse doesn’t just "see" a wall. It sees a specific Entity with a specific Transform (position/rotation/scale) and specific Components (physics, collision, visual mesh). When we write Verse, we aren't just placing blocks; we are querying this tree to say, "Find me the Entity named 'Platform_A' and tell me how high it is."

Building for Verse: The "Grid" Rule

Before we write a single line of code, we have to build correctly. Verse relies on predictability. If you place a wall at X: 10.5, Y: 10.5, Verse might get confused because floating-point math in code can be messy.

The Golden Rule: When building your Verse-triggered elements, keep Building as Prop set to Off (or ensure everything snaps to the grid). This is like setting your storm timer to exact minutes. If you’re chaotic in the editor, you’ll be chaotic in the code.

The "Bounce" Logic

We are building floating platforms that are too high to jump to normally. Players will use an ATK Awning (a bounce pad) to reach them.

In Verse, we don’t need to calculate the exact jump height. We just need to ensure the Entity for the platform exists and is positioned correctly. The "magic" happens when we link the ATK Awning’s bounce force to the platform’s height. But first, we need the platform to exist in the Scene Graph.

Let's Build It

We are going to create a simple Verse script that validates your play space. It checks if your floating platforms are in the right place. If they are, it prints a message. If not, it yells at you.

This is a "Read-Only" check. It doesn’t move things; it just looks at the Scene Graph and tells you if you built it right.

The Verse Code

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Symbols }

# This is our "Device" - the brain of our operation.
# Think of it like a Scoreboard Device, but smarter.
script MyPlaySpaceValidator: Device {

    # VARIABLES: The "Loot" we care about.
    # A "Handle" is like a remote control for an Entity.
    # We need handles to our floating platforms.
    Platform_A: Entity = ?
    Platform_B: Entity = ?

    # CONSTANTS: The rules of the universe.
    # Max jump height is roughly 100 units.
    # If a platform is higher than this, players can't reach it without help.
    const MAX_JUMP_HEIGHT: float = 100.0

    # FUNCTIONS: The "Actions" our device takes.
    # This function checks if a platform is reachable.
    .Is_Reachable(Platform: Entity) -> bool:
        # Get the Transform (Position/Rotation) of the platform.
        # Think of Transform as the platform's "GPS Coordinates".
        Transform: Transform = Platform.Get_Transform()

        # Get the Y (Height) value from the Transform.
        Height: float = Transform.Get_Location().Get_Y()

        # If the height is less than our max jump, it's reachable.
        return Height <= MAX_JUMP_HEIGHT

    # EVENTS: When does this code run?
    # "On Begin Play" is like when the match starts and the bus flies over.
    .On Begin Play() -> void:
        # Let's check Platform A.
        if Platform_A != ? and Platform_B != ?:
            # Call our function for Platform A.
            A_Reachable: bool = .Is_Reachable(Platform_A)
            B_Reachable: bool = .Is_Reachable(Platform_B)

            # Print results to the debug console.
            # This is like checking your elimination feed.
            if A_Reachable:
                Print("Platform A: Reachable by jump.")
            else:
                Print("Platform A: TOO HIGH! Need ATK Awning.")

            if B_Reachable:
                Print("Platform B: Reachable by jump.")
            else:
                Print("Platform B: TOO HIGH! Need ATK Awning.")
        else:
            Print("ERROR: Missing platforms in the Scene Graph!")
}

Walkthrough: What Just Happened?

1. script MyPlaySpaceValidator: Device: We created a new device. In UEFN, this shows up in your device library. It’s the "container" for our logic.
2. Platform_A: Entity = ?: We declared a variable. The ? means "I don't know yet which entity this is." Later, in the editor, you will drag your actual floating platform prop into this slot. This is how Verse connects to your physical build.
3. .Is_Reachable(Platform: Entity) -> bool: This is a Function. It’s a mini-machine. You feed it an Entity, and it spits out a bool (True/False).
   • Platform.Get_Transform(): This grabs the Entity’s GPS coordinates.
   • Get_Location().Get_Y(): This isolates the height. In Fortnite, Y is usually Up/Down (depending on your axis settings, but usually Z is up, Y is forward/back, X is left/right. Note: Verse uses standard UE4/5 axes, so check your specific transform. For this tutorial, let's assume we are checking the vertical component, often Z in UE, but let's stick to the concept: we are extracting one coordinate).
4. .On Begin Play(): This is the Event. It runs automatically when the game starts. It’s like the "Start Match" button on a device.
5. if Platform_A != ?: We check if the handle is filled. If you forgot to drag the platform into the device slot, Platform_A will be ? (null/empty). We don’t want our code to crash because we forgot to place a prop.

Try It Yourself

You’ve got the validator. Now, let’s make it dynamic.

Challenge: Add a third variable called Bounce_Pad: Device. Create a new function called .Check_Bounce_Pad. This function should check if the Bounce_Pad is within 500 units of Platform_A. If it is, print "Good Bounce Setup!". If not, print "ATK Awning too far away!".

Hint: Use .Get_Transform() on both the Bounce Pad and the Platform, then compare their X and Y (horizontal) distances. You can subtract the values to find the distance!

Recap

• Scene Graph: Your island is a tree of Entities (the things) and Components (the stats).
• Handles: Use Entity variables to link your Verse code to specific props in the editor.
• Transforms: Use Get_Transform() to read where things are in the world.
• Grid Building: Keep your builds snapped to the grid to avoid math headaches in Verse.

You now have a play space that Verse can "see." Next time, we’ll add the ATK Awning logic to make those platforms actually bouncy. Until then, keep snapping, and may your frame rates be high.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/create-a-free-for-all-game-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-atk-spawner-device-design-examples-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/create-a-free-for-all-game-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/boat-spawner-device-design-examples
• https://dev.epicgames.com/documentation/fortnite/verse-start-05-refactor-and-refine-in-fortnite