The Vanishing Act: Making Platforms Disappear with Verse

Stop building static bridges that everyone walks across without thinking. If you want your island to feel like a high-skill creative map, you need platforms that vanish the moment someone lands on them. It’s the difference between a boring parkour course and a heart-stopping test of reflexes. In this tutorial, we’re going to use Verse to turn a regular platform into a "ghost" that only exists when it’s safe to step on. We’ll teach you how to control visibility using the scene graph, so you can build traps, timed jumps, or just mess with your friends' heads.

What You'll Learn

• Entities vs. Components: Understanding the hierarchy of objects in your island (the Scene Graph).
• Methods: How to give an object specific actions (like "Hide" or "Show").
• The creative_prop Class: The specific "type" of object that lets you control props in Verse.
• Execution Order: Why doing things too fast makes your code look broken, and how to fix it.

How It Works

In Fortnite Creative, everything you place in the world is part of the Scene Graph. Think of the Scene Graph as the master list of every single item in your game, from the Battle Bus to the dirt under your feet. Each item on this list is called an Entity.

An Entity is like a character in a game. It has a name, a position, and a type. But an Entity isn't just a floating name; it has Components. Components are the specific jobs or traits that Entity performs. A platform Entity might have a "Physics" component (so it can fall) and a "Visuals" component (so you can see it).

In Verse, we talk about Classes. A Class is like a blueprint or a template. If you have a creative_prop Class, that’s the blueprint for any prop you place in the editor (like a ramp, a box, or a platform). When you place that prop in UEFN, you create an Instance of that Class. You can have ten creative_prop instances (ten different boxes), but they all follow the rules of the creative_prop blueprint.

Here is the secret sauce: The creative_prop Class comes with built-in tools called Methods. A Method is a function attached to a specific object that tells that object to do something. Think of it like a remote control. The TV is the Object. The "Power" button is the Method. You don't need to build the electricity inside the TV; you just press the button.

For our platform, we want to use two specific methods: Hide() and Show().

• Hide(): Makes the object invisible to players (but it still exists in the code, so physics still work if you’re clever).
• Show(): Makes the object visible again.

We are going to write a script that runs when the game starts (OnBegin), hides the platform, waits a split second, and then shows it. This creates the illusion that the platform is "readying" itself for you to jump.

Let's Build It

First, set up your level. Place a Prop Platform (or any static mesh) in your world. Let's call it DisappearingPlatform. Make sure you can see it.

Now, open Verse. We are going to create a device that controls this platform.

# This line defines our custom device.
# 'Device' is the base class for all interactive Verse scripts.
# We are creating a new blueprint called 'VanishingPlatformDevice'.
VanishingPlatformDevice: device =
    # This is our 'Component' that links to the actual prop in the editor.
    # We assign it to a variable named 'DisappearingPlatform'.
    # The type 'creative_prop' tells Verse this object is a prop we can manipulate.
    DisappearingPlatform: creative_prop = component()

    # This is the 'Event' that triggers when the game starts.
    # 'OnBegin' is a special event built into the Device class.
    # '<override>' means we are defining how THIS specific device handles that event.
    # '<suspends>' allows our code to pause (wait) without freezing the whole game.
    OnBegin<override>()<suspends>: void =
        # STEP 1: Hide the platform.
        # We call the 'Hide()' method on our DisappearingPlatform object.
        # It's like pressing the 'Invisible' button on the remote.
        DisappearingPlatform.Hide()

        # STEP 2: Wait.
        # If we don't wait, the platform will hide and show instantly.
        # Humans can't see that happen. It just looks like it was always there.
        # 'Wait()' pauses this specific script for 0.5 seconds.
        Wait(0.5)

        # STEP 3: Show the platform.
        # We call the 'Show()' method to make it visible again.
        # Now the player sees the platform appear out of thin air!
        DisappearingPlatform.Show()

Walkthrough

1. DisappearingPlatform: creative_prop = component(): This is the most important line. We are grabbing the prop from the editor and giving it a handle in Verse. Without this, Verse doesn't know which platform you're talking about.
2. OnBegin<override>()<suspends>: void =: This is the starting gun. When the island launches, this block of code runs. The <suspends> tag is crucial because it allows us to use Wait() later. Without it, Verse would crash or complain because you can't pause inside a standard function.
3. DisappearingPlatform.Hide(): We access the object (DisappearingPlatform) and call its method (Hide()). It’s dot notation. Object.Method().
4. Wait(0.5): This is the magic ingredient. It gives the player’s eye time to register that the platform wasn't there a moment ago.
5. DisappearingPlatform.Show(): The reveal.

Try It Yourself

You’ve got the platform appearing. Now, make it disappear when someone touches it.

Challenge: Modify the code so that the platform stays hidden after it appears. Then, add a new event: OnBeginOverlap. This event triggers when a player steps on the prop. Inside OnBeginOverlap, call Hide() again.

Hint: You’ll need to define a second event in your device:

Remember, other is the entity (player) that touched the platform. You want to call Hide() on DisappearingPlatform, not other.

Recap

You just learned how to control the visibility of objects in Fortnite using Verse. You connected an editor prop to a Verse script using a component, used the creative_prop class to access built-in methods like Hide() and Show(), and understood why timing (Wait) is essential for visual effects. You’re no longer just placing static objects; you’re directing the stage.

References

• 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/uefn/synchronized-disappearing-platforms-using-verse-in-unreal-editor-for-fortnite
• 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/uefn/disappearing-platform-on-loop-using-verse-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/disappearing-platform-on-touch-using-verse-in-unreal-editor-for-fortnite