The Big Red Button: How to Actually End a Game in Fortnite

So, you've built the ultimate deathmatch arena. You've rigged the traps, balanced the loot, and even added a custom emote dance floor. But there's one problem: the game never stops. Players are still shooting each other at 3 AM because you forgot to tell the universe when to pack up and go home.

In Fortnite Creative, the game doesn't just "end" on its own (unless you want a battle royale-style last-man-standing). You have to be the director. You have to call "cut!"

In this tutorial, we're going to learn how to use Game End Conditions and Victory Conditions to control the flow of your island. We'll build a simple "Capture the Flag" style objective where the game ends when a team scores enough points, or when the timer runs out. No complex code required—just some smart settings and a tiny bit of Verse to handle the scoreboard.

What You'll Learn

• End Conditions vs. Victory Conditions: The difference between "The game is over" and "Team Blue wins."
• The Timer Trap: How to make the game end when time runs out, even if no one has won yet.
• Verse for Scoreboards: A tiny snippet of Verse to track points and trigger the end state.
• Post-Game Chaos: How to move players and announce the winner when the match finishes.

How It Works

Think of your island like a TV show. You need two things to wrap up the episode:

1. The End Condition (The "Cut!" Signal): This is the hard rule that stops the simulation. It doesn't care who won; it just says, "Okay, show's over." Common end conditions are:

   • Last Standing: Only one team/player left alive. (Classic BR style).
   • All Teams Must Finish: Everyone has to complete the objective. (Great for co-op or racing).
   • Match Point Win: A team reaches a specific score threshold (e.g., first to 5 points).

2. The Victory Condition (The "Winner" Announcement): Once the end condition is met, this decides who gets the trophy.

   • Most Round Wins: Best of 3, best of 5.
   • Most Score Wins: Highest score when time runs out.
   • Fastest Time: Who got there first?

The Problem with Default Settings: By default, Fortnite Creative might be set to "Last Standing Ends Game." If you're building a puzzle game or a capture-the-flag map, that setting is useless. If two teams are stuck in a stalemate, the game goes on forever. You need to change the settings to match your game mode.

The Verse Connection: While the settings tell the engine when to stop, Verse is the brain that keeps track of who is winning. In programming, we call this a Variable (a box that holds a changing value, like a player's health or score). We'll use Verse to increment a score variable, and the Island Settings will watch that score to know when to hit the end button.

Let's Build It

We are building a "First to 10 Points Wins" arena.

1. The Setup: Two teams (Red vs. Blue). A central zone.
2. The Logic: When a player touches the center zone, their team gets a point.
3. The End: When a team hits 10 points, the game ends.

Step 1: Configure Island Settings

Before writing a single line of code, let's tell the engine how the game should end.

1. Open your Island Settings (the gear icon in the top right).
2. Go to Game Mode > End Conditions.
3. Change End Game on Match Point Win to On.
4. Set Match Point Win Score to 10.
   • Translation: The game will automatically stop the moment any team reaches 10 points.

Step 2: The Verse Script

Now, we need to actually give the points. We'll use a simple Verse script attached to the central zone.

In UEFN, create a new Verse file. Let's call it ScoreManager.verse.

# ScoreManager.verse
# This script tracks team scores and updates the UI.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Game }

# Define our main device. This is the "Container" for our logic.
# Think of it like a Prop Mover device, but instead of moving props, it moves data.
ScoreDevice := class(creative_device):

    # A reference to the Score Manager device placed in the level.
    # Wire this up in the UEFN editor to the Score Manager device for Team 1.
    @editable
    RedScoreManager : score_manager_device = score_manager_device{}

    # Wire this up in the UEFN editor to the Score Manager device for Team 2.
    @editable
    BlueScoreManager : score_manager_device = score_manager_device{}

    # A reference to the two Trigger devices placed in the level.
    # Wire RedTrigger to the Team 1 capture zone trigger in the editor.
    @editable
    RedTrigger : trigger_device = trigger_device{}

    # Wire BlueTrigger to the Team 2 capture zone trigger in the editor.
    @editable
    BlueTrigger : trigger_device = trigger_device{}

    # VARIABLES: These are our "Scoreboards."
    # They start at 0 and change as players touch the zone.
    # In Verse, we use 'var' for things that change, and 'const' for things that stay the same.
    var RedScore : int = 0
    var BlueScore : int = 0

    # OnBegin runs once when the game session starts.
    # It's like the "On Game Start" event in a standard Creative device.
    OnBegin<override>()<suspends> : void =
        # Subscribe to each trigger's TriggeredEvent so we know when a player enters the zone.
        RedTrigger.TriggeredEvent.Subscribe(OnRedZoneEntered)
        BlueTrigger.TriggeredEvent.Subscribe(OnBlueZoneEntered)

    # Called whenever a player steps into the Red capture zone.
    OnRedZoneEntered(Player : ?agent) : void =
        set RedScore += 1
        # Award the point through the Score Manager device wired to Team 1.
        # score_manager_device.Activate() grants the score value configured on the device.
        if (LivePlayer := Player?):
            RedScoreManager.Activate(LivePlayer)

    # Called whenever a player steps into the Blue capture zone.
    OnBlueZoneEntered(Player : ?agent) : void =
        set BlueScore += 1
        # Award the point through the Score Manager device wired to Team 2.
        if (LivePlayer := Player?):
            BlueScoreManager.Activate(LivePlayer)

Wait, there's a catch! The code above is a conceptual skeleton. In real UEFN, updating the Team Score directly from a simple script can be tricky because the "Team Score" is a global state managed by the Game Manager.

Here is the real, working way to do it without fighting the engine:

1. Use a "Score Manager" Device: In UEFN, there is a built-in Score Manager device.
2. Link it to your Trigger:
   • Place a Trigger device.
   • Place a Score Manager device.
   • In the Trigger device's properties, set Triggered Event to Activate on the Score Manager device.
   • Set the Score Manager device to award points to Team 1 or Team 2.

Why are we learning Verse then? Because the built-in devices are limited. Verse allows you to do conditional scoring. For example: "Only give points if the player is holding a specific weapon," or "Double points if the storm is active."

Let's write a Verse script that checks a condition before awarding the point. This is where Verse shines.

Step 3: The Scene Graph (The "Parent-Child" Relationship)

You might notice we mentioned GetMeshComponent(). This is where the Scene Graph comes in.

In Fortnite, every object is part of a hierarchy.

• The Entity: The Trigger device itself.
• The Components: The Mesh (what you see), the Collision (what you touch), the Script (the brain).

When you write Mesh.SetMaterial(), you are reaching into the Scene Graph to grab the visual part of the device and change it. This is powerful. You can make the trigger glow when a player is holding the right item.

Key Concept:

• Entity: The logical object (the Trigger).
• Component: The data attached to it (Mesh, Script, Physics).
• Hierarchy: The Trigger might contain a Particle System that plays when the script runs.

Try It Yourself

Challenge: Build a "Time Bomb" mode.

1. Set the End Condition to Timer (set to 2 minutes).
2. Set the Victory Condition to Most Score Wins.
3. Create a Verse script that moves a Cinematic Sequence prop (the bomb) toward a target player every 10 seconds.
4. If the bomb touches a player, they are eliminated.
5. When the timer hits 0, the game ends. The team with the most eliminations (score) wins.

Hint: Use the Sleep() function in Verse to pause for 10 seconds between bomb movements. Use GetPlayspace().GetTeamCollection() to track which team a player belongs to.

Recap

• End Conditions stop the game. Victory Conditions decide the winner.
• Use Island Settings for simple rules (First to 10 points, Time limit).
• Use Verse for complex logic (Conditional scoring, dynamic events).
• Variables store changing data (scores, health). Constants store fixed data (max health, map size).
• The Scene Graph connects your logic (scripts) to your visuals (meshes, particles).

Now go end some games. And maybe let the other team win sometimes. Or don't. That's your island.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/island-settings-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/island-settings-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/party-game-4-reusable-game-manager-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/mode-settings-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/mode-settings-in-fortnite-creative