Student can assemble teams, classes, spawns, score, timer, and round logic into one playable CTF event.

📖 Reference & full walkthrough: Plaza Skirmish: a Capture-the-Flag Mini-Mode

🔁 Builds on: lessons 6-9 of this zone + south-shores Shell-Hunt project structure

🧩 Your capstone piece: The while-you-wait plaza minigame that runs between hub launches

Capture the Flag in UEFN: Build the Classic, the Right Way

Capture the Flag (CTF) is the game mode everybody already understands. Two bases, two flags, one rule: steal theirs, bring it home, don't lose yours. This guide is the first in the Game Modes series — we'll break down what makes CTF tick, who built the great ones, and then build a working, compile-clean CTF objective in Verse on top of Fortnite's creative devices.

1. What it is

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

Flag Strategy

Capture the Flag is a team objective mode. Each team guards a flag at its own base. To score, you raid the enemy base, grab their flag, and carry it back to yours. The twist that creates all the drama: in classic rules your own flag must be home for a capture to count, so the same players can't just blindly rush — somebody has to defend.

It's the oldest competitive format in multiplayer gaming for a reason: the rules fit in one sentence, but the decisions (push or defend? trade flags or stalemate?) run deep.

2. Type of game

3. The loop

The core loop is a tug-of-war between offense and defense. Every player is always choosing which side of it to be on.

The magic is in the feedback: a single grab flips the whole team from attack to escort, and the defenders from holding to hunting. Momentum swings fast.

4. Why it's fun

• Instant legibility. A new player gets the goal in five seconds — there's a glowing flag and an arrow pointing home. No tutorial needed.
• Role fluidity. You choose offense or defense moment to moment, so nobody is locked into a boring job.
• The escort hero moment. Carrying the flag while your whole team forms a wall around you is one of gaming's great cooperative highs.
• Built-in comebacks. Because your flag has to be home to score, a desperate defensive stand can deny a capture at the buzzer.
• Symmetry = fairness. Mirrored maps mean every loss is on the team, not the spawn — which is exactly what keeps people queuing again.

5. Who made the great ones

CTF is a staple, so the strongest Fortnite Creative versions tend to come from creators who nail feel and balance:

• ozycreates — the long-running 🚩CAPTURE THE FLAG🚩 (code 0678-0014-4695) is one of the most-played straight-rules CTF islands.
• boe — 2Fort: Capture The Flag (code 4051-8130-9275), a loving rebuild of the iconic Team Fortress map, proves how much theme carries CTF.
• Class-based designers keep CTF fresh with role kits — Crystal Keep Clash and Slumlord CTF hand each player a class (medic, assaulter, sniper) so the offense/defense choice also becomes a loadout choice.
• Epic / ESL ran an official EWC CAPTURE THE FLAG competitive build for the Esports World Cup, a good study in tournament-grade pacing.

6. Examples / variants

• Classic 4v4 — the purest form; mirrored map, one flag each.
• One-Flag CTF — a single neutral flag in the middle; both teams fight to deliver it to the enemy base. Removes turtling.
• Sniper-only / class CTF — restrict the loadout (e.g. Bullseye's sniper-only build) to change the whole rhythm.
• Multi-flag chaos — 3-4 teams, several flags, scoring by total captures — great for big public lobbies.

7. How to make it in UEFN / Verse

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

Flag Tether

The devices you'll place

• Capture Item Spawner (capture_item_spawner_device) — this is the flag. It spawns the carryable, tracks who's holding it, and fires events on pickup / capture / drop / return.
• Team Settings & Inventory (team_settings_and_inventory_device) — one per team, to define the two teams and each side's starting kit.
• Class Designer + Class & Team Selector (class_designer_device, class_and_team_selector_device) — optional but recommended: define role kits (assaulter, defender, medic) and let players pick one at their base.
• Player Spawn Pads (player_spawner_device) — several per base, each assigned to that base's team.
• Timer / Round Settings (timer_device, round_settings_device) — the match clock and round rules; set the match length so the game can end on time as well as on captures.
• End Game (end_game_device) — the round terminator: activate it when a team hits the capture target (or the clock expires) to show the victory screen and end the round.

Assembly order — from empty plaza to playable event

1. Teams — place two Team Settings & Inventory devices, set Team 1 / Team 2, and give each its starting loadout.
2. Classes (optional) — build 2–3 role kits in Class Designer devices, then place a Class & Team Selector at each base so players choose a job.
3. Spawns — drop several Player Spawn Pads per base and assign each pad to that base's team.
4. Flags — one Capture Item Spawner per base; set which team can capture it, and switch on the “own flag must be home” rule in its options.
5. Score — the Verse device below tallies captures per team (add a Score Manager if you also want the built-in scoreboard).
6. Timer — set the match length (8–15 minutes) in Island Settings, or place a Timer device for a visible countdown.
7. Round logic — wire the win: when CapturesToWin is reached — or time runs out — an End Game device ends the round and declares the winner.

That's the whole event — teams, classes, spawns, score, timer, round logic — and the Verse below is the glue for the score + round pieces.

The Verse mechanic that ties it together

You can build CTF with pure device settings, but Verse is where you add the polish: announce captures, keep a clean team score, and enforce the "flag must be home" rule. The pattern is the same one you'll reuse all series long — subscribe to a device's event, then react.

The flag fires four events you care about:

# capture_item_spawner_device exposes the flag lifecycle as events:
#   ItemPickedUpEvent : agent  - someone grabbed it
#   ItemCapturedEvent : agent  - someone scored it
#   ItemDroppedEvent  : agent  - carrier was eliminated / dropped it
#   ItemReturnedEvent : agent  - it reset to base
FlagSpawner.ItemCapturedEvent.Subscribe(OnFlagCaptured)

To answer "which team just scored?", ask the playspace's team collection for the scorer's team — the single most useful team-mode call in all of Verse:

TeamCollection := GetPlayspace().GetTeamCollection()
if (ScoringTeam := TeamCollection.GetTeam[ScoringAgent]):
    # ScoringTeam is the team to credit with the capture

The full, compile-verified objective device

Drop this capture_the_flag_device into your project, set its two @editable flag references in the Details panel, and it credits + announces every capture, per team. It is a standalone creative_device, so it compiles on its own.

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

# Capture the Flag — score + announce engine.
#
# Place two capture_item_spawner_devices (the flags), one per base, and wire
# them to the two @editable references below. This device listens for a capture
# on either flag, figures out which TEAM the carrier is on via the playspace
# team collection, and tallies it. Scoring/announcement live in Verse so the
# rules ("flag must be home", per-team totals) are yours to tune.
capture_the_flag_device := class(creative_device):

    # The flag that BLUE captures (the red base flag), and vice-versa.
    @editable
    var RedTeamFlag : capture_item_spawner_device = capture_item_spawner_device{}

    @editable
    var BlueTeamFlag : capture_item_spawner_device = capture_item_spawner_device{}

    # Captures needed to win the match.
    @editable
    var CapturesToWin : int = 3

    # Running totals, keyed by the team object handed back by GetTeam.
    var Scores : [team]int = map{}

    OnBegin<override>()<suspends> : void =
        # When EITHER flag is captured, credit the scoring agent's team.
        RedTeamFlag.ItemCapturedEvent.Subscribe(OnFlagCaptured)
        BlueTeamFlag.ItemCapturedEvent.Subscribe(OnFlagCaptured)

    OnFlagCaptured(Scorer : agent) : void =
        TeamCollection := GetPlayspace().GetTeamCollection()
        if (ScoringTeam := TeamCollection.GetTeam[Scorer]):
            # Read the current total (default 0) and add one.
            Current := Scores[ScoringTeam] or 0
            NewScore := Current + 1
            if (set Scores[ScoringTeam] = NewScore) {}
            Print("Flag captured! Team now has {NewScore} capture(s).")
            if (NewScore >= CapturesToWin):
                Print("Team reached {CapturesToWin} captures — match point!")
                AnnounceWinner(ScoringTeam)

    AnnounceWinner(WinningTeam : team) : void =
        # Hook your end-game here: end the round, play a sting, show a banner.
        # Kept as a Print so the device is self-contained and compiles clean.
        Print("We have a winner!")

How it works, line by line

1. Two @editable flag references let a designer drag the actual Capture Item Spawners onto this device in the editor — no hard-coded names.
2. OnBegin subscribes to ItemCapturedEvent on both flags. One handler covers both because we resolve the team from the agent, not the flag.
3. GetPlayspace().GetTeamCollection().GetTeam[Scorer] is the canonical "who is this player playing for?" lookup. It's a <decides> call, so it lives inside an if.
4. Scores : [team]int is a map keyed by the team object itself — clean, no magic numbers. Scores[ScoringTeam] or 0 reads a default for a team that hasn't scored yet.
5. set Scores[ScoringTeam] = NewScore mutates the map; it's wrapped in an if (...) {} because map-set is a failable expression.

Gotchas

• The carryable, not the carrier, is the flag. Use capture_item_spawner_device, not a generic item granter — only the spawner tracks pickup/return.
• GetTeam[] fails for spectators / unassigned agents. Always guard it with if, exactly as above, or your handler will silently do nothing.
• "Flag must be home" is a rules choice. The Capture Item Spawner has a setting for this; enforce it in the device options first, and only reach for extra Verse if you want custom messaging.
• Mirror your map. CTF balance is 90% level design. Equal cover, equal sightlines, equal travel time — build one half and copy-mirror it.

Recap

• CTF is the most legible team-objective mode: steal the enemy flag, bring it home, defend your own.
• The fun comes from fluid offense/defense roles, the escort hero moment, and symmetry-driven fairness.
• In UEFN the Capture Item Spawner is the flag; it fires pickup/capture/drop/return events.
• The Verse pattern is universal: subscribe to the event, resolve the team with GetTeamCollection().GetTeam[], tally, announce.
• Assembly order for a playable event: teams → classes → spawns → flags → score → timer → round end (End Game device).
• Balance is level design — mirror the map and equalize every lane.