Build Your Own Hero Shooter: Mastering the Class Designer

Remember how annoying it is when you pick a character in a hero shooter and they don't have the right gear for the job? Or how boring it is when everyone plays exactly the same way? That's because most default modes are "one size fits all." But you? You're about to break that mold.

In this tutorial, we're going to use the Class Designer to create custom player archetypes. Think of this as building the ultimate character creation screen, but instead of just changing hair color, you're defining their health pool, shield capacity, and starting loadout. By the end, you'll have a working system where players can switch between a "Tank" and a "Glass Cannon," each with completely different stats and weapons. No code required—just pure, unadulterated game design chaos.

What You'll Learn

• What a Class is: Why "classes" are basically pre-configured player profiles (like a preset loadout).
• The Class Designer Device: How to use this specific UEFN tool to define those profiles.
• Attributes & Loadouts: The difference between stats (health/shields) and gear (weapons/items).
• Linking It Up: How to connect your Class Designer to a Class Selector so players can actually switch roles.

How It Works

Before we touch any devices, let's talk about the concept of a Class.

In programming and game design, a Class is like a blueprint or a template for an object. Imagine you have a blueprint for a "House." You can build 100 houses from that one blueprint, and they'll all have the same basic structure (walls, roof, door). But you can tweak the details. One house might have a bigger yard; another might have a pool.

In Fortnite, a Player is the object. A Class is the blueprint for how that player behaves.

When you use the Class Designer, you are creating that blueprint. You aren't making a player; you are making the rules for a specific type of player.

The Two Main Parts of a Class

When you open the Class Designer, you're essentially filling out a character sheet for a video game character. There are two main categories of data you're setting:

1. Attributes (The Stats): These are the numbers that change during the game.

   • Game Analogy: Think of this like your Health Bar and Shield Bar.
   • What you set: Starting Health, Max Health, Starting Shields, Max Shields.
   • Why it matters: If you set Max Health to 500, that player is a tank. If you set it to 25, they're a squishy assassin. This is a Constant for the class definition—it's baked into the blueprint.

2. Inventory/Loadout (The Gear): These are the items the player spawns with or has access to.

   • Game Analogy: Think of this like your Backpack or the Loot Pool in a chest.
   • What you set: Which weapons, traps, or consumables they start with.
   • Why it matters: A sniper class needs a sniper. A builder class needs a pickaxe and wood.

The "Class Identifier": The Switch

Here is the tricky part that trips up beginners. You can have a "Tank" class and a "Sniper" class. How does the game know which one to give you?

Enter the Class Identifier.

Think of the Class Identifier as a Slot Number in a save file or a Lane Number in a multiplayer lobby.

• Class Designer #1 has an Identifier of 1.
• Class Designer #2 has an Identifier of 2.

When a player steps on a Class Selector (a trigger device), that device needs to know which slot to switch them to. If the selector is set to Identifier 1, it looks for the Class Designer that also has Identifier 1 and applies those stats.

The Golden Rule: The Class Designer's Identifier must match the Class Selector's Identifier for the switch to work. If they don't match, the player will switch to... nothing. Or the default class. It's like trying to open a locked door with the wrong key.

Scene Graph & Hierarchy Note

In Unreal Engine 6 (and Verse), we talk a lot about the Scene Graph—a tree structure of all objects in the world. The Class Designer is a specific Entity (a distinct object in the game world) with Components (its settings).

While you configure it via the UI, under the hood, the game engine stores this data as a structured object. When the Class Selector fires, it queries the scene graph, finds the Class Designer with the matching ID, and "applies" that component data to the player's character entity. You don't need to write code to do this; the devices handle the heavy lifting of the scene graph manipulation for you.

Let's Build It

We are going to build a "Boss Rush" arena. You'll have two classes:

1. The Juggernaut: High health, low shields, starts with a heavy shotgun.
2. The Phantom: Low health, high shields, starts with a sniper rifle.

Step 1: Place Your Devices

1. Go to the Devices menu.
2. Place a Class Selector in your spawn room. This is the button players will step on.
3. Place a Class Designer next to it. This is the blueprint we are editing.

Step 2: Configure the Class Designer

Click on the Class Designer and open its settings.

1. Class Name: Type Juggernaut. This is just for your reference in the editor, so you don't get confused later.
2. Class Identifier: Set this to 1. Write this down. This is the ID.
3. Starting Health / Max Health: Set both to 500. (This guy is tough).
4. Starting Shields / Max Shields: Set both to 0. (He relies on pure HP).
5. Inventory: Click the "Add Item" button (or drag items onto the device, depending on your UEFN version). Add a Heavy Shotgun and a Bandage Bazooka.

Click OK to save.

Step 3: Configure the Class Selector

Now, click on the Class Selector.

1. Class Identifier: Set this to 1. It must match the Designer.
2. Output: This device usually has an output that triggers when a player switches. You don't necessarily need to wire anything else for a simple switch, but if you want a sound effect when they switch, you can wire this to a Sound Emitter.

Step 4: Test It

Play your island. Walk up to the Class Selector. Step on it.

• Success: Your health bar should jump to 500, shields should be gone, and you should be holding a Heavy Shotgun.
• Failure: If nothing happens, check your IDs. Did you set the Designer to 1 and the Selector to 2? That's why it didn't work. The Selector was looking for ID 2, but the Designer was hiding at ID 1.

Step 5: Add a Second Class (The Phantom)

Now, let's add the second class.

1. Place a second Class Designer next to the first one.
2. Set Class Name to Phantom.
3. Set Class Identifier to 2.
4. Set Health to 100 and Shields to 200.
5. Add a Sniper Rifle and Slurp Juice to the inventory.
6. Save.

Now, place a second Class Selector somewhere else in the map (or just use the same one if you want a toggle, but separate buttons are easier for beginners).

1. If you added a new selector, set its Class Identifier to 2.
2. Play again. Step on the new selector. You should now be a squishy, shield-heavy sniper.

Let's Look at the Code (Verse)

Wait, didn't we just use devices? Yes! But in Verse, everything is code. The devices we just placed are actually shortcuts to Verse functions. If you were writing this in pure Verse, it would look something like this. This helps you understand what the devices are doing behind the scenes.

# This is a simplified representation of how the Class System works in Verse.
# In UEFN, the Class Designer device handles this automatically for you.

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

# 1. Define the Class Structure (The Blueprint)
# This is like the Class Designer device itself.
# Note: 'int' is used here for readability; Verse uses float for health/shield values
# via the fort_character health API.
player_class := struct:
    Health : float
    Shields : float

# 2. Create Instances of the Class (The Specific Configurations)
# This is what you do in the Class Designer settings.
# These are module-scoped constants representing each class definition.
# Using functions instead of module-scoped constants to avoid the 'transacts' effect error.
MakeJuggernautClass() : player_class = player_class{
    Health := 500.0,
    Shields := 0.0
}

MakePhantomClass() : player_class = player_class{
    Health := 100.0,
    Shields := 200.0
}

# 3. The Switch Function (The Class Selector Logic)
# When a player triggers the selector, the game calls this logic.
# The 'ClassId' is the Class Identifier we set in the device.
# Note: fort_character exposes SetMaxHealth/SetHealth/SetShield via
# the /Fortnite.com/Characters API. Item grants require an item_granter_device
# wired in the editor; there is no runtime "give item by name" API in public Verse.
ApplyClass(Player : player, ClassId : int) : void =
    if (FortChar := Player.GetFortCharacter[]):
        if (ClassId = 1):
            # Apply Juggernaut stats
            FortChar.SetMaxHealth(MakeJuggernautClass().Health)
            FortChar.SetHealth(MakeJuggernautClass().Health)
            FortChar.SetMaxShield(MakeJuggernautClass().Shields)
            FortChar.SetShield(MakeJuggernautClass().Shields)
            Print("Class applied: Juggernaut")
        else if (ClassId = 2):
            # Apply Phantom stats
            FortChar.SetMaxHealth(MakePhantomClass().Health)
            FortChar.SetHealth(MakePhantomClass().Health)
            FortChar.SetMaxShield(MakePhantomClass().Shields)
            FortChar.SetShield(MakePhantomClass().Shields)
            Print("Class applied: Phantom")```

**Why show this?** Because it proves that the Class Designer isn't magic. It's just a user-friendly way to define `structs` (data containers) and apply them. When you use the device, you are manually creating these structs and linking them to the selector logic.

## Try It Yourself

You've got the basics. Now, make it fun.

**Challenge:** Create a third class called "The Gambler."
*   **Health:** 10 (One hit kill).
*   **Shields:** 0.
*   **Loadout:** A single **RPG**.
*   **Twist:** Add a **Timer Device** that resets the game every 30 seconds so players can keep trying to get kills with this fragile loadout.

**Hint:** Don't forget to set the Class Identifier on your new Class Designer and the new Class Selector to match (e.g., `3`). And remember, if the player dies instantly, make sure the respawn timer is short!

## Recap

*   **Class Designer** is the device you use to create custom player blueprints (Classes).
*   **Attributes** (Health/Shields) define how tough the player is.
*   **Inventory** defines what gear the player starts with.
*   **Class Identifier** is the ID number that links the Class Designer to the Class Selector. They must match.
*   You can have multiple Class Designers and Selectors to let players switch between different playstyles.

Go forth and build the most unbalanced, chaotic, fun-filled hero shooter Fortnite has ever seen. And remember: if a class is too strong, nerf it. If it's too weak, buff it. That's the designer's job.

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/fortnite-creative-glossary
*   https://dev.epicgames.com/documentation/en-us/fortnite/class-designer
*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/create-a-dungeon-crawler-game-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite/fortnite-creative-glossary
*   https://dev.epicgames.com/documentation/en-us/fortnite/create-a-dungeon-crawler-game-in-fortnite-creative