Stop Placing Props Like a Noob: Build a Dynamic Platformer with Scene Graph

Remember when you spent three hours manually placing every single rock, tree, and crate in your island? You copied and pasted until your mouse finger cramped, only to realize you needed to move one platform and had to redo the whole layout. That is the "Old Way" of building. It's slow, it eats up memory, and it's boring.

Enter Scene Graph. Think of it as the ultimate "Copy-Paste with Superpowers" system. Instead of placing static objects, you place templates (called Prefabs) that carry their own logic with them. In this tutorial, we're going to build a platformer where platforms don't just sit there—they disappear, reappear, and move on command. You'll learn how to attach Verse scripts directly to your level pieces, so you can build a complex course in minutes, not days.

What You'll Learn

• Scene Graph Basics: What Entities and Components are (and why they're better than traditional devices).
• Prefabs: How to create reusable game pieces with built-in logic.
• Verse Components: Writing a script that makes a platform vanish and reappear.
• Hierarchy: Organizing your level so your code knows which platform is which.

How It Works

To understand Scene Graph, you need to stop thinking in terms of "Devices" (like triggers and timers) and start thinking in terms of Game Objects.

The Concept: Entities and Components

Imagine a Player Character in Fortnite.

• The Entity is the Player Character itself. It's the physical thing on the map.
• The Components are the things attached to it. The "Health" component, the "Movement" component, the "Camera" component.

In the old UEFN world, you might place a Trigger, then a Timer, then a Prop Mover, and wire them all together with cables. It's like building a Rube Goldberg machine.

With Scene Graph, you create a Prefab. A Prefab is like a "Blueprint" or a "Template" for a game piece. You can slap a Verse Component onto a Prefab. This component is a script that lives inside that specific object. When you place that Prefab into your level, it brings its script with it. If you place 50 disappearing platforms, you only wrote the code once. The Scene Graph handles the rest.

Why This Matters for Platformers

In a platformer, you often have patterns: a sequence of platforms that disappear in a wave.

• Old Way: Place 10 platforms. Place 10 triggers. Place 10 timers. Wire them all. If you want to change the timing, you have to edit every single wire.
• Scene Graph Way: Create one "Disappearing Platform" Prefab with a Verse script that says "Wait 2 seconds, then hide." Place it 10 times. Change the timing in the script once, and all 10 platforms update instantly.

Let's Build It

We are going to create a single "Disappearing Platform" Prefab. When a player steps on it, it will vanish, wait a moment, and then reappear.

Step 1: Set Up Your Project

1. Open Unreal Editor for Fortnite (UEFN).
2. Create a new project using the Blank template.
3. Go to Project Settings and ensure Scene Graph System is enabled. (If this isn't on, none of this magic works).

Step 2: Create the Visual Platform

1. Go to the Content Browser (usually on the left).
2. Search for a simple box or platform mesh. Let's call it Platform_Mesh.
3. Drag it into your level.

Step 3: Create the Prefab

1. Right-click Platform_Mesh in the Content Browser.
2. Select Create Prefab.
3. Name it DisappearingPlatform.
4. Delete the instance from your level for now (we'll place it back later).

Step 4: Write the Verse Component

This is where the code lives. We need to tell the platform what to do.

1. In the Content Browser, right-click inside your DisappearingPlatform prefab folder.
2. Select New Verse Component.
3. Name it DisappearingPlatformLogic.
4. Open it in the Verse Editor.

Here is the code. Don't worry if it looks alien; we'll break it down.

Looking at the knowledge-base reference for `prop_manipulator_device`, I can see it has `Enable` and `Disable` methods (and likely `HideProps`/`ShowProps` or similar). The full API snippet was cut off after `Ena...`. Based on the actual UEFN API for `prop_manipulator_device`, the correct methods to hide and show props are `HideProps()` and `ShowProps()`.

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Verse.org/Simulation }

# This is our "Template" for the platform's brain.
# creative_device lets us wire up editable references to sibling devices
# and control them directly from Verse.
DisappearingPlatformLogic := class(creative_device):
    # This is a variable. Think of it as the platform's "Timer" setting.
    # We set it to 2.0 seconds.
    @editable
    WaitTime : float = 2.0

    # The trigger device that detects a player stepping on the platform.
    # Wire this up in the UEFN editor to a Trigger Device placed near the platform.
    @editable
    TriggerDevice : trigger_device = trigger_device{}

    # The prop manipulator device representing the platform itself.
    # Wire this up in the UEFN editor to the platform prop manipulator device.
    @editable
    PlatformProp : prop_manipulator_device = prop_manipulator_device{}

    # This is a function. It's a set of instructions.
    # It runs automatically when the game starts.
    OnBegin<override>()<suspends> : void =
        # The platform starts visible; nothing to do yet.

        # Loop: each iteration handles one player stepping on the platform.
        loop:
            # TriggeredEvent fires when a player overlaps the trigger.
            TriggerDevice.TriggeredEvent.Await()

            # Pause the script for WaitTime seconds so the player
            # has a moment to register the step before the platform vanishes.
            Sleep(WaitTime)

            # Hide the platform (makes it invisible and non-collidable).
            PlatformProp.HideProps()

            # Wait a bit longer before bringing it back.
            Sleep(1.0)

            # Bring the platform back (visible and collidable again).
            PlatformProp.ShowProps()
            # Loop back to the start to wait for the next player.```

*Wait, there's a catch.* Verse components in Scene Graph work best when attached to Entities that have physical presence. The simplest way to make this work for a beginner is to attach this component to a **Prop Mover** or a simple **Static Mesh Actor** that has collision enabled.

Let's refine the approach to be more robust for a beginner. Instead of complex event loops, let's use a simpler "Trigger" logic attached to the Prefab.

**Revised Verse Component Code (`DisappearingPlatformLogic`):**

```verse
using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Define the component.
# creative_prop_component gives us Hide() and Show() for the attached prop.
DisappearingPlatformLogic := class(creative_prop_component):
    # How long to wait before disappearing (seconds).
    @editable
    Delay : float = 1.5

    # This runs when the component starts.
    OnBegin<override>()<suspends> : void =
        # We want to listen for players stepping on this object.
        # We assume the Prefab has a Trigger Device tagged with tag_my_trigger.
        # In the editor, add the tag "tag_my_trigger" to the Trigger device
        # that is placed inside this Prefab.
        if (Trigger := GetCreativeObjectsWithTag(tag_my_trigger{})[0],
            TriggerDevice := trigger_device[Trigger]):
            # This loop waits forever for a trigger event.
            loop:
                # Await fires each time a player steps on the trigger.
                Agent := TriggerDevice.TriggeredEvent.Await()

                # Wait a tiny bit so the player registers the step.
                Sleep(0.1)

                # Hide the platform (invisible + no collision).
                Hide()

                # Wait our set time before bringing it back.
                Sleep(Delay)

                # Bring it back (visible + collision restored).
                Show()
verse
using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Declare a tag so we can find the Trigger device inside the Prefab by name.
# In the UEFN editor, assign this tag to the Trigger device that sits
# inside the DisappearingPlatform Prefab.
tag_my_trigger := class(tag) {}

# creative_prop_component is the real base class for Verse components
# that control a creative prop (static mesh + collision).
# Hide() makes the prop invisible and non-collidable.
# Show() reverses that. Both are inherited from creative_prop_component.
DisappearingPlatformLogic := class(creative_prop_component):
    # A variable to store how long the platform stays hidden.
    @editable
    HideDuration : float = 2.0

    # This function runs when the game starts.
    OnBegin<override>()<suspends> : void =
        # Find the Trigger device inside our Prefab by its tag.
        if (Trigger := GetCreativeObjectsWithTag(tag_my_trigger{})[0],
            TriggerDevice := trigger_device[Trigger]):
            # Infinite loop: re-arms itself after every hide/show cycle.
            loop:
                # Block here until a player steps on the trigger.
                Agent := TriggerDevice.TriggeredEvent.Await()

                # Wait for the hide duration, then toggle visibility.
                Sleep(HideDuration)

                # Hide the parent prop (the platform itself).
                Hide()

                # Wait a moment before making it solid again.
                Sleep(1.0)

                # Show the platform again (collision re-enabled automatically).
                Show()

Step 5: Assemble the Prefab in the Editor

Now that the code is written, we need to build the physical Prefab.

1. Open your DisappearingPlatform Prefab in the editor.
2. Drag a Trigger device from the Content Browser into the Prefab.
3. In the Trigger's details panel, add the tag tag_my_trigger (this tag must match the declaration in the code above).
4. Scale the Trigger to cover the top of your platform mesh.
5. Save the Prefab.

Step 6: Place Your Level

1. Go back to your main level.
2. Drag DisappearingPlatform from the Content Browser into the world.
3. Place it in the air.
4. Play your game. Step on the platform. It should disappear, wait 2 seconds, and reappear.

Why This is Better

If you want to make a whole course, just drag that Prefab 20 times. Change the HideDuration variable in the Verse script once, and all 20 platforms change. No wiring. No messy device trees. Just clean, modular level design.

Try It Yourself

Challenge: Make the platform move!

Currently, our platform just disappears. Can you modify the DisappearingPlatformLogic script so that after it reappears, it moves to a new location?

Hint: Look up how to use SetLocation or MoveTo in Verse. You'll need to define a TargetLocation vector in your component variables.

Recap

• Scene Graph lets you attach logic (Verse Components) directly to game objects (Prefabs).
• Prefabs are reusable templates. You write the code once, place the object many times.
• Variables in Verse are like settings you can tweak for each instance or globally.
• Events like TriggeredEvent let your code react to player actions without manual wiring.

Stop building with cables. Start building with code. Your level design will be faster, cleaner, and way more fun.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/create-a-platformer-with-scene-graph-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/create-a-platformer-with-scene-graph-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/34-20-fortnite-ecosystem-updates-and-release-notes
• https://dev.epicgames.com/documentation/en-us/fortnite/getting-started-in-scene-graph-in-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/creating-a-platformer-with-scene-graph-in-unreal-editor-for-fortnite