1v1 Build Fights in UEFN: Build the Skill-Duel Mode

1v1 Build Fights are Fortnite distilled to its purest competitive form: two players, one arena, build and box until someone wins. No loot RNG, no third parties - just raw mechanical skill, editing speed, and game sense, head to head. It's how players warm up, settle scores, and climb the skill ladder, and it's one of the most-played Creative formats on the planet. This Game Modes entry breaks the skill-duel loop down and builds a compile-verified Verse device that tracks eliminations per player and crowns a first-to-N winner.

1. What it is

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

Head to Head

A 1v1 Build Fight is a competitive duel mode. Two players spawn in a small arena with building enabled and full mats, then fight - building walls and ramps for cover, editing through them to surprise the opponent, and trading shots until one is eliminated. First to a set number of eliminations wins the set.

The mode strips away everything random. There's no loot to find, no zone to rotate, no squad - just two equally-equipped players and pure mechanical skill. It's the gym of Fortnite.

2. Type of game

3. The loop

The loop is a fast, repeating duel - eliminate, respawn, repeat, until someone hits the target.

Because respawns are instant and the arena resets, the loop is tight and relentless - dozens of micro-duels back to back, each one a chance to read and out-build your opponent.

4. Why it's fun

• Pure, measurable skill. No excuses - no RNG, no team to blame. You win or lose on your own mechanics.
• The improvement curve. 1v1s are where you feel yourself getting better, fight after fight.
• Instant feedback. Win or lose, you're back in within seconds - high reps, fast learning.
• The rivalry. Nothing builds a Fortnite friendship (or grudge) like a long, close 1v1 set.
• Spectator-friendly. Two players, one arena - it's the most legible competitive format to watch.

5. Who made the great ones

1v1 and build-fight arenas are Creative's competitive backbone:

• Pandvil - the 📦 PANDVIL Box Fight 📦 and 1v1 maps (codes in the 1234-xxxx / 8064-xxxx families) are the de-facto practice arenas for serious players.
• GoBige - long-running 1v1 / 2v2 / 3v3 build-fight maps with clean, fair arenas and instant rematch flow.
• Clix / pro-branded arenas package a pro's preferred settings (mats, build limits, arena size) into a ready 1v1.
• Browse the 1v1 and Build Fights categories on fortnite.gg for current top arenas - they dominate the practice/warmup charts.

6. Examples / variants

• Classic 1v1 - one opponent, first to N, full builds.
• Realistic / no-build 1v1 - building off; pure aim and movement.
• Zone wars / box fights - the multiplayer cousins; many players, same build-battle core (see those series entries).
• 2v2 / 3v3 - the same loop scaled to small teams, where coordination joins the skill mix.

7. How to make it in UEFN / Verse

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

First to N

The devices you'll place

• Elimination Manager (elimination_manager_device) - fires an event whenever a qualifying elimination happens, sending the eliminator.
• Team Settings & Inventory - to give both players full mats and the same kit.
• Player Spawn Pads - one per side, instant respawn.
• HUD / Score - to show the running 1v1 score.

The Verse mechanic that ties it together

The arena and respawns are device-driven; Verse owns the score and the first-to-N win condition. The series staple returns - subscribe to an event, react - on the Elimination Manager's EliminationEvent, which sends the eliminator as an ?agent (optional, because a non-agent could be the cause).

# elimination_manager_device.EliminationEvent : ?agent sends the ELIMINATOR.
# It's optional (?agent) because the cause might not be a player.
ElimManager.EliminationEvent.Subscribe(OnElimination)

Per-player score is the familiar [agent]int map - one entry per duelist.

var Score : [agent]int = map{}   # eliminations per player

The full, compile-verified objective device

Drop this build_fight_device into your project, wire the @editable elimination manager, and it tallies each player's eliminations and declares a winner at first-to-N. It's a standalone creative_device, so it compiles on its own.

How it works, line by line

1. @editable ElimManager lets a designer drag the arena's Elimination Manager onto the device - no hard-coded references.
2. OnBegin subscribes to EliminationEvent, which delivers the eliminator (the player who got the kill), exactly who we want to credit.
3. MaybeEliminator? unwraps the optional ?agent. The event sends an optional because a non-player cause (fall, storm) has no agent - we only score real player eliminations.
4. Score : [agent]int banks each duelist's eliminations independently - the series' per-player pattern.
5. if (NewScore >= EliminationsToWin) fires the win the instant a player hits the target - first-to-N done.

Gotchas

• EliminationEvent is ?agent, not agent. You must unwrap it with Eliminator := MaybeEliminator? inside an if - a non-agent cause (storm, fall) sends false and should not score anyone. This trips people who copy a plain-agent handler.
• Use the eliminator, not the eliminated. EliminationEvent sends who got the kill; EliminatedEvent sends who died. Credit the eliminator for a build-fight score.
• Map-set is failable. if (set Score[Eliminator] = NewScore) {} is mandatory for the [agent]int map - same rule as every score map this series.
• Arena reset is your job. This declares the winner; wire OnSetWon to an end-round or arena-reset device for the rematch flow players expect.

Recap

• 1v1 Build Fights are the pure skill duel: two equally-equipped players, build and box, first to N eliminations.
• The fun is measurable skill, the improvement curve, instant rematch feedback, and the rivalry.
• In UEFN the Elimination Manager fires the kill event; Verse owns the score and win condition.
• The Verse pattern: subscribe to EliminationEvent (an ?agent you must unwrap), bank per-player kills in an [agent]int map, declare first-to-N.
• Credit the eliminator, unwrap the optional agent, and wire the win hook to an arena reset for the relentless rematch loop.