How to Build a Rocket Racing Island (Without Crashing Your First Lap)

So, you want to build a track where cars fly, drift, and defy physics? Welcome to Rocket Racing. This isn't your average Fortnitemares maze or a creative tower defense; it's high-speed vehicular chaos. In this tutorial, we're skipping the boring "how to place a wall" stuff and jumping straight into the specialized toolset for Rocket Racing islands. We'll take the pre-made "Competitive Race Track" template, extend the track so it's actually a loop, and set up the checkpoints so the game knows when you've actually finished and not just crashed into a tree. By the end, you'll have a playable, multi-lap race that doesn't end the second you leave the starting line.

What You'll Learn

• The Template Trap: Why starting with a blank slate is a bad idea for Rocket Racing.
• Splines are Strings: How to think about track paths like a leash you're dragging around.
• The Checkpoint Chain: Setting up the logic (without coding) that tracks your lap progress.
• Playtesting Like a Pro: Why you need to jump into the actual game client while you build.

How It Works

Rocket Racing islands are special snowflakes. They don't use the standard "place a floor, put a wall" logic you use for building a base. Instead, they rely on a Template system. Think of a template like a pre-built Battle Bus drop spot—it has the core mechanics already installed (the cars, the physics, the starting grid), but it's your job to build the arena.

The Primary Track and Splines

In standard Fortnite, you build with blocks. In Rocket Racing, you build with Splines. A spline is just a fancy word for a continuous line that defines a path. Imagine a leash attached to the front bumper of a car; the spline is the path that leash follows. If the leash goes in a straight line, the car drives straight. If you curve the leash, the car turns. To make a race, you need to connect the end of that leash back to the beginning to make a closed loop.

Devices: The Brains of the Operation

You've probably seen devices like "Trigger Volume" or "Prop Mover." Rocket Racing has its own specific devices:

• RR Start/Finish: The big flag. It tells the game "You started here" and "You finished here."
• RR Checkpoint: These are the mid-race markers. If you miss a checkpoint, the game might reset your lap or penalize you. They act like the rings in Sonic the Hedgehog—if you don't hit them, you don't get the points.

The Scene Graph (Briefly)

In Unreal Engine, everything exists in a hierarchy called the Scene Graph. Think of this like your inventory screen in Fortnite. You have your backpack (the world), your weapon slot (the track), and your ammo (the cars). If you delete your backpack, everything disappears. If you move the "Track" object, the whole race moves. In Rocket Racing, the Primary Track is the parent object. When you edit the spline points on that parent, you're editing the entire race path.

Let's Build It

We aren't writing Verse code here because Rocket Racing's core loop is handled by the engine's built-in devices. However, understanding how to arrange these devices is the "programming" of this island. We are configuring the logic through placement.

Step 1: The Template Drop

1. Open Unreal Editor for Fortnite (UEFN).
2. Go to the Island Templates tab.
3. Select Rocket Racing > Competitive Race Track.
4. Name your project (e.g., "My_Super_Duper_Race") and click Create.

Why this matters: You now have a project with a Primary Track object already in the world. It's a simple oval. It's boring, but it works.

Step 2: Extending the Spline (The "Leash")

1. In the World Outliner (the list of all objects on the left), find the object named PrimaryTrack.
2. Click on it. You should see the track in your viewport.
3. Look for the Spline Editor tool (usually appears when the spline is selected). You'll see small yellow cubes along the track. These are Spline Points.
4. Click and drag these points to stretch the track out. Make it longer, add curves, create a hairpin turn.
5. Crucial Step: Ensure the start and end of the spline connect perfectly. If there's a gap, the cars will fly into the void. Use the "Close Spline" option if available, or manually snap the last point to the first.

Step 3: Placing the Checkpoints

The template usually has one Start/Finish line. For a competitive race, you need to ensure players don't cheat by cutting corners.

1. Open the Devices panel (the brick icon).
2. Search for RR Checkpoint.
3. Drag one into the world. Place it in a tricky spot—maybe right after a sharp turn or a jump.
4. Duplicate this device (Ctrl+D) and place more checkpoints around the track.
5. Game Mechanic Analogy: Think of these like XP Boosts. If you pass through, you're "safe" and your progress is saved. If you skip one, the game assumes you took a shortcut and might reset your lap.

Step 4: The "Verse" of Placement

While we aren't writing code, the logic of the race is defined by the order of these devices. The engine reads the spline from Start to Finish. The checkpoints act as intermediate "save points."

Here is a pseudo-logic breakdown of what's happening under the hood (no actual code, just the concept):

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

# Represents simplified race-progress logic for illustration purposes.
# RR devices handle this automatically in UEFN; this shows the concept in real Verse syntax.
race_progress_manager := class(creative_device):

    # Bind these in the UEFN Details panel to your placed RR devices.
    @editable StartFinishLine : trigger_device = trigger_device{}
    @editable Checkpoints : []trigger_device = array{}

    # Per-agent state tracked in parallel maps.
    var AgentLap : [agent]int = map{}
    var AgentLastCheckpoint : [agent]int = map{}
    var AgentLapStartTime : [agent]float = map{}

    OnBegin<override>()<suspends> : void =
        # Wire the start/finish trigger.
        StartFinishLine.TriggeredEvent.Subscribe(OnStartFinishCrossed)

        # Wire every checkpoint trigger, capturing its index.
        for (Index -> CP : Checkpoints):
            CP.TriggeredEvent.Subscribe(
                # note: spawn a task per checkpoint to handle the subscription with the captured index.
                agent => { spawn { OnCheckpointCrossedAsync(agent, Index) } }
            )

    OnCheckpointCrossedAsync(Agent : agent, Index : int)<suspends> : void =
        OnCheckpointCrossed(Agent, Index)

    OnStartFinishCrossed(Agent : ?agent) : void =
        if (Agent2 := Agent?):
            if (LastCP := AgentLastCheckpoint[Agent2]):
                # Player completed a valid lap only when all checkpoints were hit.
                if (LastCP = Checkpoints.Length - 1):
                    if (StartTime := AgentLapStartTime[Agent2]):
                        LapTime := GetSimulationElapsedTime() - StartTime
                        Print("Lap complete for agent. Time: {LapTime}")
                else:
                    Print("Lap invalid — missed a checkpoint. Resetting.")
            # Reset state for the next lap regardless of outcome.
            if (set AgentLap[Agent2] = 0) {}
            if (set AgentLastCheckpoint[Agent2] = -1) {}
            if (set AgentLapStartTime[Agent2] = GetSimulationElapsedTime()) {}

    OnCheckpointCrossed(Agent : agent, Index : int) : void =
        Expected := if (Last := AgentLastCheckpoint[Agent]) then Last + 1 else 0
        if (Index = Expected):
            if (set AgentLastCheckpoint[Agent] = Index) {}
            Print("Checkpoint {Index} validated.")
        else:
            Print("Checkpoint {Index} hit out of order — ignored.")```

### Step 5: Playtesting
1.  Click **Play** in UEFN. This launches Fortnite.
2.  Join your island.
3.  Drive around. If the car flies off the track, check your spline points. If the car stops at the finish line and doesn't count the lap, check if your checkpoints are properly aligned with the track direction.

## Try It Yourself

**Challenge:** The current track is a boring oval. Your mission is to create a "Figure-8" track or a track with a massive jump.

**Hint:** To make a Figure-8, you'll need to manipulate the spline points in the center of the track so the path crosses itself. Be careful—cars might clip through the ground if the spline dips too low. Use the **Spline Height** tool (usually a vertical arrow on the spline points) to raise the crossing section so the cars don't crash into the earth.

## Recap

Building a Rocket Racing island isn't about placing individual bricks; it's about sculpting a path with splines and validating that path with checkpoints. Start with the **Competitive Race Track** template to get the physics right, extend the **Primary Track** spline to make your course, and scatter **RR Checkpoints** to prevent cheating. Test frequently in the actual game client, because what looks good in UEFN might look like a death trap in Fortnite.

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite/building-rocket-racing-islands-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/fortnite/creating-rocket-racing-islands-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/uefn/building-rocket-racing-islands-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/fortnite/accessing-brand-content-in-fortnite
*   https://dev.epicgames.com/documentation/en-us/uefn/creating-rocket-racing-islands-in-unreal-editor-for-fortnite