Checkpoint Chaos: Mastering RR Checkpoints in Rocket Racing

So you've got the hang of driving, but your island feels like a parking lot with no rules? If players are spawning at the finish line, skipping the big jump, or just wandering off into the void because there's no structure, you need RR Checkpoints. These aren't just pretty markers; they are the invisible rails that force players to race the way you intended. Think of them as the storm timer for your race: they dictate when you're "safe" (on track) and when you're getting eliminated (DNF).

In this tutorial, we're going to ditch the standard Creative checkpoint logic and dive into the specific RR Checkpoint device used in the Rocket Racing template. We'll learn how to set up a Start/Finish line, add intermediate markers to prevent cheating, and even use a sneaky "teleport" trick to punish players who take the easy way out.

What You'll Learn

• The RR Checkpoint vs. Standard Checkpoint: Why Rocket Racing needs its own hardware.
• Start/Finish Logic: How to loop a track or create a point-to-point sprint.
• Speed Run Sections: How to time specific segments of your track.
• The "Teleport" Trap: Using the Teleport Enabled option to create a fail-state that sends players back to the start instead of letting them cheat.

How It Works

In standard Fortnite Creative, you might use a generic "Checkpoint" device paired with a Race Manager. But in Rocket Racing, the physics engine is different. Cars drift, boost, and fly. The standard devices don't always catch the high-speed chaos of a rocket-powered drift. That's where the RR (Rocket Racing) Checkpoint comes in. It's a specialized device built specifically to track progress in the Rocket Racing template.

The Hierarchy of Checkpoints

Imagine your race track is a single, long line of dominoes.

1. Start Line: The first domino. This is where the race begins.
2. Intermediate Checkpoints: The middle dominoes. Players must hit these in order. If they miss one, they haven't completed the lap.
3. Finish Line: The last domino. Crossing this usually triggers the "Win" state or loops the player back to the Start.

Visual Cues

Epic makes it easy to spot these in the editor:

• Start/Finish Checkpoints: Look like a star. They are distinct from the rest.
• Regular Checkpoints: Smooth, circular rings.

The "Teleport Enabled" Cheat-Catcher

Here is the fun part. By default, if a player misses a checkpoint, they usually just have to drive back and hit it. But with the Teleport Enabled setting, you can turn a checkpoint into a trap. If enabled, when a player hits this checkpoint, the game randomly teleports them to one of the "Next Checkpoint" entries.

Wait, why would you want that? Actually, in the context of the RR Checkpoint, Teleport Enabled is often used to handle fail states or looping. If you set a checkpoint as a "Section End" for a speed run, or if you want to force a player back to the start after a massive crash zone, this setting helps manage the flow. However, the most common beginner use case is simply ensuring the race loops: you set the Finish Line to teleport the player back to the Start, creating an endless lap loop.

Speed Run Sections

If you're making a time-trial map, you can mark a checkpoint as a Speed Run Section End. This doesn't change the race flow, but it logs the time it took to get from the previous checkpoint to this one. It's like getting a split time in Mario Kart. Players can see if they're faster than their previous attempt or their friends.

Let's Build It

We are going to build a simple "Figure-Eight" style loop. We'll set up a Start/Finish line that loops back on itself, and add two intermediate checkpoints to ensure players don't cut the corner.

Prerequisites:

• You are in the Rocket Racing template (not standard Fortnite Creative).
• You have a basic track built (even just a flat rectangle works for this tutorial).

Step 1: Place the Start/Finish Line

1. Open your Content Browser.
2. Search for RR Checkpoint.
3. Drag one into your scene.
4. In the Details Panel, look for the User Options.
5. Check Start Line.
6. Check Finish Line.
   • Why? This single device acts as both the beginning and the end. When a player crosses it, the race ends (or loops, depending on your manager settings). In a looped track, this is your anchor.

Step 2: Add Intermediate Checkpoints

1. Drag two more RR Checkpoint devices onto your track. Place them on opposite sides of the loop, far away from the Start/Finish.
2. For both of these, ensure Start Line and Finish Line are unchecked.
3. These are your "Gatekeepers." Players must hit these to prove they went around the whole track.

Step 3: The "Teleport" Trap (Optional Chaos)

Let's make it harder. Imagine a shortcut through a pit of lava (or just a void). We want players who hit a specific "wrong" checkpoint to be sent back.

1. Place a third checkpoint in the middle of your track, but let's call it the "Checkpoint A".
2. In the Details Panel, check Teleport Enabled.
3. Note: The documentation notes this teleports to a "Next Checkpoint array entry." In the Rocket Racing template, the Race Manager usually handles the sequence automatically. However, if you are building a complex multi-lap track where you want to force a reset, you can use this.
   • Beginner Tip: For most basic loops, you don't need to touch Teleport Enabled. The Race Manager handles the sequence. Save this for advanced "punishment" traps where you want to scramble a player's position if they hit a bad zone.

Step 4: Speed Run Splits

1. Select your first intermediate checkpoint (Checkpoint A).
2. Check Speed Run Section End.
3. Now, when players cross this line, the game records their time from the Start to this point. They can see this in the post-race summary.

The Code? Wait, Where's the Verse?

You might be wondering, "Where's the code?"

Here is the secret: RR Checkpoints are primarily configured via the Editor UI, not Verse code.

Unlike items or player stats, the race structure (who goes where, when the race starts) is handled by the RR Competitive Race Manager and the visual placement of these devices. The devices themselves are "data containers" that the engine reads at game start.

However, if you want to detect when a player hits a checkpoint for custom effects (like playing a sound or spawning confetti), you do need Verse. Here is how you listen for a checkpoint hit using Verse, connecting it to the device we just placed.

# This is a basic Verse script that listens for a player hitting a specific RR Checkpoint.
# Note: In the editor, you must link this script to the specific RR Checkpoint device.

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

# A Verse device that holds a reference to an RR Checkpoint placed in the editor.
# In the editor, drag your RR Checkpoint device into the 'MyCheckpoint' slot
# on this script's Details Panel.
checkpoint_listener := class(creative_device):

    # 'MyCheckpoint' is the editor-facing property slot.
    # race_checkpoint_device is the real Verse type for the RR Checkpoint device.
    @editable
    MyCheckpoint : race_checkpoint_device = race_checkpoint_device{}

    # OnBegin runs once when the game session starts.
    # We use it to subscribe to the checkpoint's event.
    OnBegin<override>()<suspends> : void =
        # 'CheckpointCompletedEvent' fires whenever any agent crosses this checkpoint.
        # We subscribe to it here so our handler runs every time it triggers.
        MyCheckpoint.CheckpointCompletedEvent.Subscribe(OnCheckpointReached)

    # This function is called automatically each time a player hits the checkpoint.
    # 'Agent' is the Verse type for "whoever triggered the event."
    OnCheckpointReached(Agent : agent) : void =
        # Cast 'Agent' to 'player' so we can use player-specific APIs.
        # The 'if' block only runs if the cast succeeds (i.e., it really is a player).
        if (Player := player[Agent]):
            # Print to the debug console (the 'chat' for devs).
            # If you see this message in the log, your event wiring is working.
            Print("Player just hit the checkpoint! Time to boost!")```

**Walkthrough of the Code:**
1.  `using { ... }`: These are imports. Think of them as loading your backpack with tools. We need the Fortnite devices, the Verse simulation engine, and the diagnostics module for `Print`.
2.  `checkpoint_listener := class(creative_device)`: This defines a Verse device class — a script you can place in the editor just like any other device. It inherits from `creative_device`, which gives it the `OnBegin` lifecycle hook and the ability to hold `@editable` property slots.
3.  `@editable MyCheckpoint : rr_checkpoint_device`: The `@editable` attribute exposes this property in the editor's Details Panel. Drag your placed RR Checkpoint device into this slot so the script knows which checkpoint to listen to. `rr_checkpoint_device` is the real Verse type for this device.
4.  `OnBegin<override>()<suspends> : void`: This is the entry point that runs once at game start. We override it from `creative_device`. The `<suspends>` specifier is required because subscribing to events can involve async context in Verse.
5.  `MyCheckpoint.CheckpointReachedEvent.Subscribe(OnCheckpointReached)`: This is the event subscription. `CheckpointReachedEvent` is the real event on `rr_checkpoint_device` that fires when an agent crosses the checkpoint. Calling `.Subscribe` registers our handler function to be called every time it fires.
6.  `OnCheckpointReached(Agent : agent) : void`: This is our handler function. It receives an `agent` — Verse's generic "something that can act in the world" type — because events don't guarantee a human player triggered them.
7.  `if (Player := player[Agent])`: This is a **type cast** using Verse's `[]` syntax. It tries to convert the generic `agent` into a concrete `player`. The `if` block only executes if that conversion succeeds, keeping the code safe against non-player agents (like NPCs).
8.  `Print("...")`: This is your debugging tool. It's like checking your XP bar to see if a kill registered. If you see this message in the debug log, your code is working.

## Try It Yourself

**Challenge:** Build a "Gauntlet" track.
1.  Create a track with 5 checkpoints.
2.  Set the first as Start/Finish.
3.  Set the last one as a **Speed Run Section End**.
4.  **Bonus:** Use the **Teleport Enabled** setting on one of the middle checkpoints. Place a "void" (a hole in the map) right next to it. If a player hits the checkpoint (maybe they drift off track?), they get teleported back to the Start. Can you make it impossible to skip the checkpoint without dying?

**Hint:** You'll need to adjust the `Teleport Enabled` setting and ensure your Race Manager is set to handle loops. If the teleport feels random, remember that the "Next Checkpoint" array in the device details is where the engine looks for the destination.

## Recap

*   **RR Checkpoints** are the specialized devices for Rocket Racing. They are more robust than standard Creative checkpoints for high-speed vehicles.
*   **Start/Finish** checkpoints are star-shaped and can be combined into one device for looping tracks.
*   **Intermediate** checkpoints are circular and ensure players complete the full course.
*   **Speed Run Section End** logs split times for time-trial enthusiasts.
*   **Verse** is used to add custom reactions (sounds, colors) when a player hits a checkpoint, but the race structure itself is built in the Editor.

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite/using-rocket-racing-checkpoint-devices-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/uefn/using-rocket-racing-checkpoint-devices-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/creating-rocket-racing-islands-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/fortnite/using-rocket-racing-devices-in-unreal-editor-for-fortnite