The Boss Battle of Verse: Mastering the Round Manager

So you want to build a Fortnite island that actually plays like a game? You know, with a start button, a countdown, a "Game Over" screen, and the ability to restart when everyone gets wiped?

That’s not magic. That’s the Round Manager.

Think of the Round Manager as the game’s referee, the director, and the scoreboard all rolled into one invisible entity. Without it, your island is just a playground where players run around forever. With it, you have structure. You have stakes. You have episodes.

In this tutorial, we’re going to stop building static props and start building systems. We’ll hook into the Round Manager to make a simple "Survive the Storm" mode where the game starts, counts down, ends, and lets players restart. No advanced coding degree required—just a little logic and a lot of Fortnite intuition.

What You'll Learn

• The Round Manager: What it is and why it’s the brain of your island.
• Game States: How to tell the difference between "Waiting," "Playing," and "Finished."
• Events: How to react when the round starts or ends (like a trigger, but smarter).
• Scene Graph Basics: How to attach this logic to a specific object in your world.

How It Works

The Referee Analogy

Imagine you’re playing a custom game mode. You spawn in, wait for the bus to land, then the storm starts. When the last player is eliminated, the screen goes gray, and a "Restart" button appears.

Who called the bus to land? Who started the storm? Who decided the game was over?

That’s the Round Manager. In Verse, the Round Manager isn’t just a piece of code; it’s an Interface.

Interface: Think of an interface as a job description or a contract. If an object "implements" an interface, it’s saying, "I promise to do these specific things." The Round Manager interface says, "I promise to handle starting rounds, ending rounds, and telling you who won."

The Scene Graph: Where the Referee Lives

In Unreal Engine 6 (and Verse), everything is part of the Scene Graph. This is just a fancy way of saying "the family tree of everything in your level."

• Entity: Any object in your world (a player, a wall, a prop, a device).
• Component: The skills or data attached to an Entity (like a mesh, a material, or—wait for it—logic).

The Round Manager lives on a special Simulation Entity. This is the "backend" of your game. It doesn’t have a model you can see; it’s the invisible engine room. To control it, we don’t click a button in the editor; we write Verse code that talks to that entity.

The Game Loop

A typical round looks like this:

1. Idle: Players are waiting. Nothing happens.
2. Start: The Round Manager says, "Go!" We trigger events (spawn enemies, start storm).
3. Play: The game is running.
4. End: The Round Manager says, "Stop!" We trigger events (show score, reset positions).

We’ll write code that listens for these transitions.

Let's Build It

We’re going to build a simple Round Controller. It will:

1. Detect when the round starts.
2. Print a message to the chat when the round begins.
3. Detect when the round ends.
4. Print a message when the round ends.

We’ll attach this logic to a Script Component in UEFN.

Step 1: Create the Script

1. In UEFN, open your level.
2. In the World Outliner, find your Simulation Entity (usually named Simulation or GameInstance). If you don’t have one, create a new Script Component and attach it to the Simulation Entity.
3. Open the Verse editor for that component.

Step 2: The Code

Copy and paste this code. Don’t worry about memorizing it yet; we’ll break it down line by line.

using /Fortnite.com/Game
using /Verse.org/Simulation

# This is our main script. It lives on the Simulation Entity.
# The 'interface' part tells Verse: "I am a Round Manager."
script RoundController implements IFortRoundManager:

    # This function runs once when the game starts.
    # Think of it as the "Pre-Game Lobby" setup.
    OnBegin<override>()<suspends>: void=
        # Wait for the round to actually start.
        # This pauses the script until the Round Manager says "Go!"
        await RoundStartedEvent

        # Now the round is live! Let's announce it.
        Print("Round Started! Good luck, survivors!")

    # This function runs when the round ends.
    OnEnd<override>()<suspends>: void=
        # Wait for the round to end.
        await RoundEndedEvent

        # Game over. Let's announce it.
        Print("Round Over! Time to respawn or restart.")

    # This is the event that fires when the round starts.
    # We don't call this; the Round Manager calls it for us.
    RoundStartedEvent: event()=
        # Just a placeholder. The system handles the timing.
        pass

    # This is the event that fires when the round ends.
    RoundEndedEvent: event()=
        # Just a placeholder. The system handles the timing.
        pass

Step 3: Breaking It Down

1. script RoundController implements IFortRoundManager:

   • Script: A block of code that runs on an Entity.
   • implements: This is the contract. We are telling Verse, "I am implementing the IFortRoundManager interface." This means our script can listen to round events.

2. OnBegin<override>()<suspends>: void=

   • OnBegin: A special function that runs when the Simulation Entity starts.
   • override: We’re replacing the default "do nothing" behavior with our own.
   • <suspends>: This is crucial. It means the script can pause and wait for something to happen (like the round starting) without freezing the whole game. Think of it like a timer that waits for a beep before continuing.

3. await RoundStartedEvent

   • await: "Pause here and wait for this event to fire." The script stops running until the Round Manager triggers RoundStartedEvent.

4. Print("Round Started! ...")

   • Print: Sends a message to the in-game chat. This is how we debug and announce things.

5. RoundStartedEvent: event()=

   • event: A signal that something happened. We define these so the Round Manager knows where to send the signal.

Step 4: Testing It

1. Save your script.
2. Press Play in UEFN.
3. Wait for the round to start (you may need to trigger a round start manually if your mode doesn’t do it automatically, or just wait for the default round to begin).
4. Look at your chat. You should see: Round Started! Good luck, survivors!
5. Let the round end (or end it manually via the debug menu).
6. You should see: Round Over! Time to respawn or restart.

Try It Yourself

You’ve got the basics! Now, let’s make it more interesting.

Challenge: Modify the script so that when the round ends, it prints a custom message based on whether the player is still alive or not.

Hint: You can use an if statement to check if the player’s health is greater than 0. If you don’t know how to get the player’s health, look up the Healthful interface in the Verse docs. It’s like checking if your health bar is empty!

Bonus Challenge: Add a RoundEndedEvent listener that prints the name of the winner. (This might require a bit more digging into the IFortRoundManager interface—look for a "Winner" property!)

Recap

• The Round Manager is the referee of your Fortnite island, controlling the flow of the game.
• Interfaces are contracts that let your code talk to specific systems (like the Round Manager).
• Events are signals that tell your code when something important happens (like a round starting).
• await lets your code pause and wait for those signals, keeping your island responsive and organized.

Now go build something epic. And remember: if the round doesn’t start, check your interface implementation. The referee might be on strike.

References

• https://dev.epicgames.com/documentation/fortnite/verse-api/fortnitedotcom/game
• https://dev.epicgames.com/documentation/en-us/fortnite/verse-api/fortnitedotcom/game
• https://dev.epicgames.com/community/snippets/558p/fortnite-fort-round-gameplay-interface-for-scene-graph-components
• https://dev.epicgames.com/documentation/fortnite/verse-api/fortnitedotcom/devices
• https://dev.epicgames.com/documentation/en-us/uefn/verse-prop-hunt-template-5-game-loop-and-round-management-in-unreal-editor-for-fortnite