The "Chaos Camera" Party Game: Build a Mini-Game Hub in Verse

Remember those chaotic mini-games in Fortnite Creative where you're all scrambling for a single item, or trying to hit a moving target while the camera locks onto the action? That's the magic of a Party Game. It's not just a battle royale; it's a collection of short, intense rounds that keep your friends laughing (or screaming) for minutes at a time.

In this tutorial, we're going to build the skeleton of a Party Game island. We'll set up a voting lobby so players pick the game, use a Fixed Point Camera to lock the view on the action (so no one can cheat by looking away), and write a reusable Verse Game Manager to handle the scorekeeping and round transitions. By the end, you'll have a working prototype where players vote, play a mini-game, and get their scores tallied.

What You'll Learn

• The Party Game Structure: How to separate your "Lobby" (where players hang out) from the "Game Area" (where the chaos happens).
• Fixed Point Cameras: How to override the player's default third-person view to create a cinematic or strategic camera angle that everyone shares.
• Reusable Verse Code: Writing a single script that can control multiple different mini-games, saving you from copy-pasting code every time you add a new round.
• Score Tracking: How to keep track of who is winning across different rounds.

How It Works

Think of a Party Game island like a board game night. You have a Hub (your living room) where everyone hangs out, votes on what to play, and waits for the game to start. Then, you move to the Board (the mini-game arena) to play. When the game ends, you return to the Hub to see who won.

1. The Voting Hub

Before any action happens, players need to decide what mini-game to play. We use devices to let players vote. This is handled by simple logic: if a player clicks a button, their vote is registered. Once enough votes are in, the "Game Start" signal fires.

2. The Fixed Point Camera

In standard Fortnite, you control your camera. In a Party Game mini-game, we often want to force everyone to look at the same thing. Imagine a mini-game where players are throwing balls at a target. If everyone has their own camera, they might miss because they're looking at their feet.

A Fixed Point Camera is a device that overrides the player's view. It acts like a security camera or a TV broadcast feed. It locks onto a specific spot in the world. We'll use this to keep the camera focused on the mini-game area, ensuring everyone sees the action clearly. We'll also use a Third Person Controls device to let players move their character, but the camera stays locked to our Fixed Point setup.

3. The Reusable Game Manager (Verse)

Here's where programming comes in. If you have five different mini-games, you don't want to write five separate scripts to handle starting, scoring, and ending the game. That's repetitive and boring.

Instead, we write a Game Manager. Think of this like a referee. The referee doesn't play the game; they just blow the whistle to start, keep score, and blow the whistle to end. In Verse, we'll create a script that:

1. Waits for the "Game Start" signal.
2. Enables the Fixed Point Camera and the mini-game devices.
3. Waits for the round to end.
4. Disables the game devices and teleports players back to the Hub.
5. Updates the global score.

Because this logic is generic (start, play, end, score), we can reuse this same script for any mini-game we build later.

Let's Build It

We're going to build a simple structure. You'll need:

1. Two Zones: A "Lobby Zone" and a "Game Zone."
2. Devices: Fixed Point Camera, Third Person Controls, and a Verse Device.
3. The Script: A Verse script to manage the flow.

Step 1: The Setup (Non-Verse)

1. Create Your Zones: Place a large floor for the Lobby and another for the Game Area. Use Trigger Volume devices to detect when players enter the Game Area.
2. Place the Camera: In the Game Area, place a Fixed Point Camera. Position it so it looks down at the center of the action (like a bird's eye view or a side-view). Set its Field of View (FOV) to something wide enough to see all players (e.g., 50-70 degrees).
3. Control Input: Place a Third Person Controls device in the Game Area. This allows players to move their characters even though the camera is fixed. Connect the Fixed Point Camera to the Third Person Controls so the camera follows the "target" or stays fixed as desired.
4. The Verse Device: Place a Verse Device in your Lobby. This is where our code will live.

Step 2: The Verse Code

We need a script that acts as the referee. This script will listen for when the game should start and then orchestrate the transition.

Here is the annotated code for our Party Game Manager.

# PartyGameManager.verse
# This script acts as the "Referee" for our mini-game.
# It handles starting the round, switching the camera, and ending the round.

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

# We define a "Game Manager" class. 
# Think of this as the blueprint for our Referee.
# creative_device is the base class for all Verse devices placed in the UEFN editor.
party_game_manager := class(creative_device):

    # These are "Editable Objects" - properties you can change in the editor
    # without touching the code. 
    # lobby_trigger: Detects when players are in the voting area.
    # game_trigger: Detects when players are in the game area.
    # fixed_camera: The camera device we want to activate.
    # start_signal: The signal that says "Vote is done, start the game!"
    # end_signal: The signal that says "Time's up, game over!"

    @editable
    lobby_trigger : trigger_device = trigger_device{}

    @editable
    game_trigger : trigger_device = trigger_device{}

    @editable
    fixed_camera : gameplay_camera_fixed_point_device = gameplay_camera_fixed_point_device{}

    @editable
    start_signal : signal_remote_manager_device = signal_remote_manager_device{}

    @editable
    end_signal : signal_remote_manager_device = signal_remote_manager_device{}

    # OnBegin is the entry point for creative_device subclasses.
    # It runs automatically when the game session starts.
    OnBegin<override>()<suspends> : void =
        # Wait for the start signal (e.g., from a voting button).
        # PrimarySignalEvent fires whenever the signal_remote_manager_device is triggered.
        start_signal.PrimarySignalEvent.Await()

        # 1. Activate the Fixed Point Camera.
        # This overrides the player's default camera view.
        fixed_camera.AddToAll()

        # 2. Wait for 60 seconds to simulate game duration.
        # In a real game this would be replaced by a win-condition or timer device.
        Sleep(60.0)

        # 3. Game Over — fire the end signal so any connected devices react too.
        end_signal.Enable()

        # 4. Deactivate the Fixed Point Camera.
        # This returns control to the player's normal camera.
        fixed_camera.RemoveFromAll()

        # Here you would normally:
        # - Calculate scores
        # - Teleport players back to lobby
        # - Reset positions
        # For now, we just log it.
        Print("Round Over! Returning to Hub.")```

### Walkthrough of the Code

*   **`party_game_manager := class(creative_device):`**: We are creating a new type of device called `party_game_manager`. `creative_device` is the real Verse base class for anything you place in the UEFN editor. In the editor, you'll assign this class to your Verse Device.
*   **`@editable`**: This attribute marks the variable below it as visible in the UEFN Details panel. You don't hardcode the camera device; you drag and drop it into the Verse Device's properties. This makes the script flexible.
*   **`OnBegin<override>()<suspends> : void =`**: This is the real entry point for `creative_device` subclasses. The `<suspends>` specifier means it can pause and wait for things (like signals or timers) without freezing the whole game.
*   **`start_signal.SignaledEvent.Await()`**: This **suspends** the coroutine here and resumes only when the `signal_remote_manager_device` fires. It's like saying, "Wait right here until the voting button is pressed."
*   **`fixed_camera.Activate()`**: This tells the Fixed Point Camera device to take over the player's view. `Deactivate()` reverses it.
*   **`Sleep(60.0)`**: This pauses the script for 60 seconds. In a real game, you might wait for a player to win or a timer to run out.

### Step 3: Connecting the Dots

1.  **Link the Devices:** In the editor, select your Verse Device. In the properties panel, drag and drop your **Trigger Volumes**, **Fixed Point Camera**, and **Signal Remote Manager Devices** into the corresponding slots (`lobby_trigger`, `game_trigger`, etc.).
2.  **Set Up Voting:** Create two **Button** devices in the lobby. Link them to a **Counter** or **Signal Remote Manager** device. When enough players press their button, that signal device should trigger the `start_signal` you linked to your Verse script.
3.  **Test It:** Play the island. Walk into the lobby, vote, and watch the camera switch to the Fixed Point view when the game starts.

## Try It Yourself

**Challenge:** Add a "Score Display" to your game.

**Hint:**
1.  Create a **Text Device** in your Lobby that says "Winner: [Name]".
2.  In your Verse script, when the `end_signal` fires, use a function to find the player with the highest score (you can use a simple variable to track points).
3.  Use the Text Device's `SetText()` function to update the display with the winner's name.
4.  *Bonus:* Can you make the camera pan to follow the leading player? (Look into `FixedPointCameraDevice.SetTarget()`).

## Recap

You've just built the foundation of a Party Game island. You learned how to separate your lobby from the game area, how to use a **Fixed Point Camera** to control the player's view, and how to write a **Reusable Verse Game Manager** to handle the flow of the game. This structure lets you add as many mini-games as you want, reusing the same manager script for each one. Now go make your friends beg for mercy in your next mini-game round.

## References

- https://dev.epicgames.com/documentation/en-us/uefn/party-game-0-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/fortnite/party-game-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/fortnite/learn-game-mechanics-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/party-game-2-targeted-camera-gameplay-in-unreal-editor-for-fortnite