How to Build a Secret Bunker with Verse: The Military Gallery Guide

Forget the standard grassy hills and random loot chests. If you want your island to feel like a high-stakes infiltration mission, you need a base that looks like it was carved out of a mountain by a paranoid government agency. We’re talking steel walls, heavy blast doors, and loot that feels earned, not just picked up from a bush.

In this tutorial, we’re going to build a functional Secret Bunker. We’ll use Verse to create a "Secure Entry" system where players can’t just walk in—they have to prove they belong there. We’ll cover the core Verse concepts of Variables (your health bar), Functions (your special ability), and Events (when the storm hits) by building a door that only opens for specific players.

What You'll Learn

• Variables: How to store and change data (like a player's "access level") during the game.
• Functions: How to package a set of actions into a reusable command (like "Open Door").
• Events: How to react to player actions (like "Player Touches Button").
• Scene Graph Basics: Understanding how your island is made of "Entities" (the door, the button, the player) that talk to each other.

How It Works

Imagine you’re building a secret lair. You don’t want just anyone wandering in. You need a security system. In Fortnite Creative, you might use a simple Switch to open a door. But with Verse, we can make it smarter. We can check who is trying to enter.

Here is the game mechanic analogy for the Verse concepts we’ll use:

1. Variable (The Player's Badge): Think of a variable like a Player Card or an ID Badge. It’s a slot that holds a value. If the value is 0, you’re a civilian. If it’s 1, you’re an agent. We create this slot once, and we can change what’s inside it during the game.
2. Function (The Security Protocol): Think of a function like a Special Ability or a Device Trigger. It’s a block of instructions. When you call the function, it runs all those steps in order. "Check badge -> If valid, open door -> If invalid, play alarm sound."
3. Event (The Trigger): Think of an event like a Proximity Trigger or a Button Press. It’s the moment something happens. "When Player A touches Button B, run Security Protocol."

The Scene Graph: Your Island’s Skeleton

Before we code, you need to understand the Scene Graph. In Unreal Engine (and Verse), your island isn’t just one big blob. It’s a hierarchy of Entities (objects) and Components (parts of those objects).

• Entity: The physical thing in the world. The Steel Door. The Red Button. The Player.
• Component: The behavior or data attached to that thing. The "Health" component on a player. The "Mesh" (visual model) on the door.
• Hierarchy: How they are parented. The Button might be a child of the Wall, meaning if you move the wall, the button moves with it.

In Verse, we write scripts that live on these Entities. Our script will tell the Door Entity: "Hey, when someone touches me, check their ID badge variable."

Let's Build It

We are going to build a Secure Bunker Door.

The Setup:

1. Place a Prop-Mover (set to move the door open/closed) or simply use a Gallery Piece that acts as a door (like the Military Gallery blast door) and use a Switch or Prop-Mover to animate it. For this Verse example, let's assume we have a Prop-Mover named BunkerDoor.
2. Place a Button (from the Devices panel) near the door.
3. Create a Verse Script and attach it to the Button.

The Logic:

• When the button is pressed, we check if the player who pressed it has the "Secret Key" item.
• If they do, we set a variable IsAuthorized to true.
• We call a function OpenBunker.
• If they don’t, we play a "Denied" sound and do nothing.

Here is the Verse code. Don’t worry if it looks alien; we’ll break it down line by line.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.comTemporary/Temporal }

# This is our main script, attached to the Button
# Think of this as the "Brain" of the button
security_console := class(VerseSpeaker):
    # VARIABLES: These are our "slots" for data.
    # AccessLevel is like a player's rank (0 = civilian, 1 = agent)
    AccessLevel : int = 0
    
    # The door we want to control. We'll link this in the editor.
    # Think of this as pointing to the specific door in the level.
    BunkerDoor : PropMoverDevice = PropMoverDevice{}
    
    # The sound to play if access is denied
    DeniedSound : AudioDevice = AudioDevice{}

    # FUNCTIONS: Reusable blocks of logic.
    # This function checks if the player is authorized.
    # It returns true or false, like a light switch being on or off.
    IsPlayerAuthorized := func(Player : Player): bool ->
        # In a real game, you'd check for a specific item or team.
        # For this demo, we'll pretend any player with > 0 access is okay.
        # Let's say if the player has a specific item "Keycard", we set their access to 1.
        # Since we can't easily check items in simple Verse without complex APIs,
        # we will simulate it: if the player is on Team 1, they are authorized.
        if Player.GetTeam() == 1:
            return true
        else:
            return false

    # This function actually opens the door.
    # It's like pressing the "Open" button on a remote.
    OpenBunker := func(): void ->
        # This tells the Prop-Mover to play its "Open" animation.
        # Think of it like telling a Prop-Mover to go to its "Open" state.
        BunkerDoor.PlayAnimation("Open")
        # You could also add a sound effect here for success.

    # EVENTS: This runs when the button is pressed.
    # Think of this as the "Trigger" that starts the sequence.
    OnButtonPressed := func(): void ->
        # Get the player who pressed the button.
        # Think of this as asking "Who touched me?"
        Presser := GetPlayer()
        
        if Presser != nil:
            # Check if they are authorized using our function.
            if IsPlayerAuthorized(Presser):
                # If yes, open the door!
                OpenBunker()
            else:
                # If no, play the denial sound.
                DeniedSound.Play()

Walkthrough: What Just Happened?

1. class(VerseSpeaker): This defines our script. It’s like creating a new Device type. We’re telling Verse, "I’m making a new kind of button brain."
2. AccessLevel : int = 0: This is our Variable. int means it holds a whole number. We set it to 0 by default. This is like setting a player’s starting health to 100. It’s a container.
3. BunkerDoor : PropMoverDevice: This is a reference to another object in the scene. In the UEFN editor, you’ll drag your actual Prop-Mover device into this slot in the Details panel. This is how the Button talks to the Door.
4. IsPlayerAuthorized: This is a Function. It takes a Player as input and returns a bool (true/false). It’s like a logic gate: "Is Team 1? Yes/No."
5. OpenBunker: Another Function. It doesn’t return anything (void), it just does something. It tells the door to animate.
6. OnButtonPressed: This is an Event. It automatically runs when the button is clicked. It’s the entry point. It calls our other functions to decide what happens next.

Try It Yourself

Challenge: Make the bunker even more secure.

Currently, anyone on Team 1 can open it. Modify the IsPlayerAuthorized function to require two conditions:

1. The player must be on Team 1.
2. The player must have a specific item (e.g., "Keycard").

Hint: You’ll need to look up how to check if a player has an item in Verse. Look for GetInventory() or similar methods on the Player object. If you can’t find the exact API, simulate it by using a second variable HasKeycard : bool that you set to true when the player picks up a specific prop.

Hint for the brave: If you’re stuck, try this logic:

(Note: HasItem is a conceptual example; check the real Verse API for the correct method name, likely involving GetEquippedItem() or GetInventory().Contains()).

Recap

You just built a smart security system using Verse. You learned that:

• Variables are containers for data (like health or rank) that can change.
• Functions are reusable commands (like "Open Door") that perform actions.
• Events are triggers (like "Button Pressed") that start your code.
• The Scene Graph connects your entities (Button, Door, Player) so they can interact.

With these basics, you can build anything from a simple trap to a complex loot distribution system. The scene is yours—now go build something that doesn’t look like a generic grassy hill.

References

• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-military-galleries-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-chest-and-ammo-gallery-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/sports-galleries-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-sports-galleries-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-chest-and-ammo-gallery-devices-in-fortnite-creative