Parkour / Obby Challenge in UEFN: Build the Checkpoint-Run Mode

Parkour (or "Obby", from Roblox's obstacle course) is the movement-mastery genre: a course of jumps, gaps, and hazards you must clear from start to finish. Miss a jump and you fall - but a checkpoint catches you, so the punishment is small and the next attempt is instant. It's pure flow-state platforming, and it's one of the most accessible, most-played formats in all of UGC gaming. This Game Modes entry breaks the checkpoint-run loop down and builds a compile-verified Verse device that saves each player's last checkpoint and respawns them there when they fall.

1. What it is

<!-- section-art:1-what-it-is -->

The Gauntlet

A Parkour/Obby is a platforming challenge mode. The whole experience is a course - a sequence of jumps, narrow ledges, moving platforms, and hazards - that you traverse from a start to a finish line. The defining mechanic is the checkpoint: as you progress you touch save points, and if you fall (or die to a hazard) you respawn at your last checkpoint, not the very beginning.

There's no combat and usually no opponents - just you, the course, and your own mechanics. The difficulty comes entirely from the level design: tighter gaps, trickier timing, meaner hazards.

2. Type of game

3. The loop

The loop is attempt-fall-retry, with checkpoints keeping the cost of failure low.

Checkpoints are the genius of the genre: they turn a brutal 200-jump course into a series of small, survivable segments, so failure stings for a second instead of erasing ten minutes.

4. Why it's fun

• Flow state. A clean run through a tricky section is pure, rhythmic satisfaction - the closest games get to dancing.
• Low-stakes failure. Checkpoints mean a fall costs seconds, so you stay hungry to retry instead of rage-quitting.
• Self-measured mastery. You're competing against the course (and your own best time), which suits everyone from casual to speedrunner.
• Bite-sized progress. Every checkpoint is a little win, dangling the next one just ahead.
• Endless creator variety. A course is just geometry, so creators churn infinite themes and difficulties.

5. Who made the great ones

Parkour/Obby is one of Creative's largest and most accessible categories:

• Default Deathrun / parkour maps and the long-running 100-level Default Deathrun style courses are genre staples (deathrun is the hazard-heavy cousin - see that series entry).
• Themed parkour like Rainbow Parkour, Tower Parkour, and seasonal courses dominate the Parkour category on fortnite.gg.
• Only Up!-style vertical climbs (covered in its own series entry) are a parkour offshoot built around a single brutal ascent.
• Browse the Parkour and Obby categories on Fortnite Creative HQ or fortnite.gg for current top courses - the category is enormous and refreshed constantly.

6. Examples / variants

• Classic linear obby - start to finish, checkpoints along the way.
• Speedrun parkour - a timer rewards the fastest clean run; checkpoints optional or sparse.
• Co-op / race parkour - everyone runs the same course simultaneously, first to finish wins.
• Hazard parkour (deathrun) - traps and triggers added to the platforming for extra cruelty.

7. How to make it in UEFN / Verse

<!-- section-art:7-how-to-make-it-in-uefn-verse -->

Checkpoint Saved

The devices you'll place

• Race Checkpoint Device (race_checkpoint_device) - one at each checkpoint along the course; it natively sets a runner's respawn AND fires CheckpointCompletedEvent when they reach it.
• Race Manager Device (race_manager_device) - owns the course; fires RaceCompletedEvent when a runner crosses the finish.
• Player Spawn Pad at the start, and props/geometry forming the course (jumps, ledges, hazards).

The Verse mechanic that ties it together

The checkpoints handle respawn for you - that's the genius of the Race Checkpoint device, so you never reimplement falling-respawn logic in Verse. Verse owns the per-player progress count - how far each runner has gotten - which is what powers a leaderboard, a "checkpoint 7 of 20" HUD, and the finish announcement. The series staple returns - subscribe to an event, react - across the checkpoints and the manager.

# race_checkpoint_device fires CheckpointCompletedEvent : agent when reached;
# race_manager_device fires RaceCompletedEvent : agent on finish.
for (CP : Checkpoints):
    CP.CheckpointCompletedEvent.Subscribe(OnCheckpoint)
RaceManager.RaceCompletedEvent.Subscribe(OnFinish)

Per-player progress is the familiar [agent]int map: how many checkpoints each runner has cleared.

var Progress : [agent]int = map{}   # checkpoints cleared, per runner

The full, compile-verified objective device

Drop this parkour_device into your project, wire the @editable array of checkpoints and the race manager, and it counts each runner's progress and announces every finish - while the checkpoints handle respawn natively. It's a standalone creative_device, so it compiles on its own.

How it works, line by line

1. Checkpoints : []race_checkpoint_device is an ordered array - drag every checkpoint in, in course order, from the Details panel.
2. OnBegin loops the array and subscribes every checkpoint to one handler - one handler works because progress is keyed by the runner, not the checkpoint.
3. Progress : [agent]int stores each runner's cleared-checkpoint count - the per-player state the series uses everywhere.
4. Progress[Runner] or 0 reads the running count (default 0 for a fresh runner); the set ... = ... is wrapped in if (...) {} because map-set is failable.
5. RaceManager.RaceCompletedEvent fires on finish - where you'd stamp a time, award the win, or push to a leaderboard.

Gotchas

• Let the checkpoints handle respawn. The Race Checkpoint device natively sets a runner's respawn when they cross it - don't reimplement fall-respawn in Verse. Verse just counts progress.
• Order the array deliberately. The []race_checkpoint_device order is your authoring order; keep it matched to the course so "7 of 20" reads correctly.
• Map-set is failable. if (set Progress[Runner] = NewCount) {} is mandatory - the empty block satisfies the failure context, the same rule as every score map this series.
• Per-runner, not shared. Progress is [agent]int so each runner has independent progress - a single int would merge everyone's run. For times, read a clock at start and at RaceCompletedEvent.

Recap

• Parkour/Obby is a checkpoint-run platforming challenge: clear the course, save at checkpoints, respawn there on a fall.
• The fun is flow state, low-stakes failure, self-measured mastery, and endless creator variety.
• In UEFN Race Checkpoint devices mark checkpoints (and set respawns natively) and a Race Manager owns the finish; Verse owns the per-runner progress count.
• The Verse pattern is the series staple: subscribe each checkpoint's CheckpointCompletedEvent, count progress in an [agent]int map, announce the finish on RaceCompletedEvent.
• Checkpoints are the genre's genius - they make brutal courses survivable, so design the save points to keep failure cheap and the flow intact.