The Ultimate 1v1 Round Manager: Stop Breaking Your Island, Start Coding It

Ever tried to build a competitive 1v1 arena in Fortnite Creative, only to have the game break because Player A left the match, or the score stayed at 5-5 after the match ended? It’s like trying to play a ranked match where the scoreboard is broken and the storm doesn’t close. It’s frustrating.

We’re going to fix that. We’re building a Round Manager in Verse. Think of this as the referee of your island. It handles the chaos: it counts the rounds, resets the players, updates the scoreboard, and knows exactly when the match is over so you can teleport everyone back to the lobby. No more manual resetting. No more broken logic. Just pure, clean, automated competitive gameplay.

What You'll Learn

• Variables vs. Constants: Why some things change mid-game (like health) and others stay fixed (like the map layout).
• The Scene Graph: How your Verse device "talks" to the props and devices in your level.
• Events: How to make things happen automatically when a player enters a zone or a timer ticks.
• Game State Management: How to track rounds, scores, and reset everything for the next fight.

How It Works

Before we touch any code, let’s translate programming concepts into Fortnite mechanics you already know.

Variables vs. Constants

Imagine you’re holding a shield potion. Your current shield amount is a Variable. It changes constantly: you drink it (+50), you get shot (-10), you heal it back up. It’s dynamic data.

Now imagine the Island Settings you picked when you created your island (e.g., "Battle Royale" or "Creative"). You can’t change that mid-game. That’s a Constant. In Verse, we use constants for things like the total number of rounds in a match (e.g., 10 rounds) or the time limit per round. These are set once, at the start, and don’t change.

The Scene Graph

In Fortnite Creative, you have a hierarchy of objects. You have the Island, which contains Devices (like Player Spawners, Score Managers), which contain Props (walls, floors). This structure is called the Scene Graph.

Your Verse script is like a remote control. It doesn’t build the walls; it controls them. To do that, your script needs to know which wall or device to talk to. In Verse, we do this by creating Editable Properties. Think of these as labeled slots in your device’s settings panel. You drag a "Player Spawner" from the world into the "Spawn Point" slot in your Verse device. Now, your code knows exactly which spawner to use.

Events

You know how a Trigger Volume fires when you step on it? That’s an Event. In Verse, we don’t manually check "is the player here?" every frame. Instead, we write a function that says, "When this event happens, do this."

• On Begin Round: When the round starts.
• On Player Eliminated: When someone gets knocked out.
• On Timer Tick: When the countdown hits zero.

The Logic Loop

Our Round Manager will follow this simple loop:

1. Start: Reset scores, pick spawn points.
2. Play: Wait for a player to get eliminated or the timer to run out.
3. End Round: Update the score, show the winner, wait a few seconds.
4. Repeat: If rounds < Max Rounds, go back to Step 1.
5. Game Over: Teleport players to the hub.

Let's Build It

We are going to create a Verse device called RoundManager. This device will sit in your level and control the flow.

Prerequisites

1. Devices Needed:
   • Player Spawner: Where players start.
   • Score Manager: To keep track of points.
   • Timer: To limit round time.
   • Damage Volume: To register eliminations.
   • Teleporter: To send players back to the hub when the game ends.
2. Verse Device: Create a new Verse device in the Verse Explorer.

The Code

Copy this into your Verse device. I’ve added comments to explain what’s happening.

# This is our Round Manager. It controls the flow of a 1v1 match.
# Think of this as the referee device.

# --- EDITABLE PROPERTIES ---
# These are the "slots" you fill in the editor. 
# They are Constants because they don't change during the game logic, 
# but you set them once in the device settings.

RoundTime: float = 60.0 # How many seconds per round. Like a storm timer.
MaxRounds: int = 10     # Total rounds in the match.

# We need to connect our Verse script to the devices in the world.
# This is like plugging a controller into the console.
SpawnPad: PlayerSpawnerDevice = ? # Drag your Player Spawner here.
ScoreMgr: ScoreManagerDevice = ?  # Drag your Score Manager here.
RoundTimer: TimerDevice = ?       # Drag your Timer here.
TeleportToHub: TeleporterDevice = ? # Drag your Teleporter here.

# --- GAME STATE ---
# These are Variables. They change as the game plays.
CurrentRound: int = 0
GameActive: bool = false

# --- FUNCTIONS ---

# This function starts a new round.
# It's like pressing the "Start Match" button.
StartRound := func(): void =
    # Increment the round counter (1, 2, 3...)
    CurrentRound += 1
    
    # Reset player positions
    SpawnPad.Reset()
    
    # Start the timer for this round
    RoundTimer.Start(RoundTime)
    
    # Log to chat so players know what's happening
    print("Round {CurrentRound} started!")

# This function ends the round.
# It handles the "Game Over" for this specific round.
EndRound := func(): void =
    # Stop the timer
    RoundTimer.Stop()
    
    # Check if the game is still active
    if GameActive:
        # Determine the winner based on scores
        # (Simplified: we assume Score Manager handles the logic)
        # You could add logic here to check who has more points.
        
        # If we've played all rounds, end the game
        if CurrentRound >= MaxRounds:
            EndGame()
        else:
            # Wait a bit, then start the next round
            # For simplicity, we'll just call StartRound immediately
            # In a real build, you'd add a delay here.
            StartRound()

# This function ends the entire match.
EndGame := func(): void =
    GameActive = false
    print("Match Over! Teleporting to Hub.")
    
    # Teleport all players to the hub
    # We assume the Teleporter is set up to go to your hub map
    TeleportToHub.Activate()

# --- EVENTS ---

# This event fires when the device is placed in the level and the game starts.
# It's like the "On Begin Play" in Unreal.
OnBegin := func(): void =
    GameActive = true
    CurrentRound = 0
    StartRound()

# This event fires when the Timer finishes.
# It's like the storm closing: time's up!
OnTimerFinish := func(): void =
    EndRound()

# This event fires when a player is eliminated.
# We can hook this up to a Damage Volume or use the Score Manager events.
# For this simple example, we'll assume the Timer dictates the round end.
# In a more complex system, you'd check if a player reached 0 health.
OnPlayerEliminated := func(player: Player): void =
    # You could add logic here, like "Instant Round Win"
    # For now, we let the timer decide.
    pass

# Optional: Hook up Score Manager events if you want to track points
# OnScoreChanged := func(player: Player, score: int): void =
#     pass

Walkthrough

1. Editable Properties: Notice SpawnPad: PlayerSpawnerDevice = ?. The ? means "I don't know yet." In the UEFN editor, you drag your actual Player Spawner device onto this slot. This links your code to the physical object in the world.
2. OnBegin: This runs once when the island starts. It sets GameActive = true and calls StartRound().
3. StartRound: This increments CurrentRound (so it goes 1, 2, 3...) and starts the RoundTimer.
4. OnTimerFinish: When the timer hits 0, this function runs. It calls EndRound().
5. EndRound: It checks if we’ve hit MaxRounds. If yes, it calls EndGame(). If no, it calls StartRound() again, creating the loop.
6. EndGame: It sets GameActive = false and activates the Teleporter to send players back to your hub.

Try It Yourself

The code above is a basic loop. Here’s a challenge to make it more robust:

Challenge: Add a "Round Delay." Right now, when a round ends, the next one starts immediately. That’s too fast!

Hint:

1. Create a second TimerDevice in your level called RoundDelayTimer.
2. In EndRound(), instead of calling StartRound() immediately, call a new function WaitForNextRound().
3. In WaitForNextRound(), start the RoundDelayTimer for 5 seconds.
4. Create an event OnRoundDelayFinish that calls StartRound().

This mimics how real competitive matches have a brief pause between rounds to let players breathe (and reset their loadouts).

Recap

You just built the brain of a competitive Fortnite island. You learned how to use Editable Properties to connect your code to devices, how Variables track the state of the game (rounds, active status), and how Events trigger actions (timer finishing, game starting). This Round Manager is the foundation for any serious Creative project. From here, you can add custom loadouts, vote systems, or even mini-games. The sky’s the limit—literally, if you want to add a storm.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/party-game-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/triad-infiltration-01-setting-up-the-level-in-verse
• 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/custom-round-logic-using-verse
• https://dev.epicgames.com/documentation/fortnite/verse-parkour-template-in-unreal-editor-for-fortnite