Stop Letting Players Wander Into the Storm: How to Build Clear Visual Aids

You’ve spent hours building the perfect Fortnite island. The traps are lethal, the loot is legendary, and the path to victory is… well, it’s a maze of confusion. You spawn players in, and suddenly they’re running in circles like headless chickens, trying to figure out if they’re the attacker, the defender, or just lost.

It’s not their fault. It’s your fault.

In game design, this is called "onboarding." In Verse, we handle onboarding with Visual Aids. Think of a Visual Aid like the little arrow pointing to the bus or the text that pops up when you pick up a healing item. It’s the difference between a player having fun and a player rage-quitting because they don’t know what button to press.

Today, we’re going to stop guessing games and start giving players the info they need. We’ll build a system that flashes a custom objective message on a player’s screen the moment they join the round. No more "What am I supposed to do?" Just clear, concise, Verse-powered direction.

What You'll Learn

• The HUD Message Device: How to use a pre-made UEFN tool to broadcast text to players.
• Event-Driven Logic: Triggering actions based on players joining the game (using the OnPlayerJoined event).
• Variable Basics: Storing a specific message for each player so everyone gets the right instructions.
• Scene Graph Hierarchy: Understanding where devices live in the world and how Verse connects to them.

How It Works

Imagine you’re the Battle Bus pilot. You don’t just drop players anywhere and hope for the best; you have a plan. In Verse, we need that same plan.

When a player joins your island, the game fires an Event. An event is like a trigger in the Creative UI—it’s a moment in time that something happens. Specifically, we care about the OnPlayerJoined event. This is the digital equivalent of the bus door opening.

Once we know a player has joined, we need to tell them something. We can’t just shout it into the void; we need a delivery system. That’s where the HUD Message device comes in.

The HUD Message Device

Think of the HUD Message device as a sticky note that only the player can see. It’s not a physical object in the world (like a wall or a box); it’s part of the HUD (Heads-Up Display), which is the overlay of buttons, health bars, and mini-maps on your screen.

In the Unreal Editor for Fortnite (UEFN), you drag this device into your level. It doesn’t matter where you put it visually—it’s invisible during gameplay—but it needs to be in the scene so Verse can "talk" to it.

The Logic Flow

1. Wait: The game starts.
2. Detect: Verse detects PlayerJoined.
3. Retrieve: Verse grabs the specific HUD Message device assigned to that player (or a global one).
4. Execute: Verse tells the device to show the text.

We aren’t writing complex math here. We are simply linking a trigger (player joins) to a result (show text). It’s as simple as setting a trap: Step on the pressure plate (join), trap activates (message appears).

Let's Build It

We’re going to create a simple "Objective System." When a player joins, they get a message telling them their role. To do this, we need two things in your UEFN editor:

1. A HUD Message device. Drag it from the Devices panel into your level. Name it ObjectiveMessage. In the Details panel, under User Options, set the Message to something like "Objective: Defend the Beacon!"
2. A Verse Script device.

Here is the code. Don’t panic—each line is explained below.

# Import the core Verse libraries we need
use: core
use: player
use: device

# Define our script. This is the brain of our island.
# 'concrete' means this is a real, active object in the scene.
ObjectiveGuide := class<concrete>:
    # This is a 'Variable'. Think of it as a backpack slot.
    # We are storing a reference to our HUD Message device.
    # 'device_handle' is like a remote control for the device.
    objective_message: device_handle<HUD_Message> = device_handle{}

    # This is a 'Function'. It’s a set of instructions we can run.
    # 'Activate' is a special function that runs when the device starts up.
    Activate(): void =
        # 'Get_Device()' looks in the scene for the device named 'objective_message'
        # and gives us control over it.
        hud := Get_Device(objective_message)

        # Now we check if we actually found the device.
        # If 'hud' is valid, we proceed.
        if (hud.IsValid()):
            # We want to show the message when a player joins.
            # We connect the 'OnPlayerJoined' event to a function we'll write next.
            hud.OnPlayerJoined.Bind(ShowObjective)

    # This is the function that actually shows the text.
    # 'p' stands for 'player'. Every time a player joins, Verse calls this.
    ShowObjective(p: player): void =
        # We get the device again (or use the stored one)
        hud := Get_Device(objective_message)
        
        if (hud.IsValid()):
            # 'Show_Message' is the command that flashes text on the screen.
            # We pass the player 'p' so only they see it (or everyone, depending on device settings).
            hud.Show_Message(p)

    # This is another special function. 'OnBeginPlay' runs once when the island starts.
    # We use it to set up our connections.
    OnBeginPlay(): void =
        # We call our Activate function to set everything up.
        Activate()

Walkthrough: What Just Happened?

1. class<concrete>: This defines our script as a physical entity in the scene graph. It’s like placing a prop. Without this, Verse doesn’t know where your code lives.
2. objective_message: device_handle: This is your Variable. It’s empty at first (device_handle{}), waiting for you to assign a device to it in the UEFN editor.
3. Activate(): This is the setup phase. It’s like loading your weapon before the match starts. We grab the device and tell it: "Hey, every time a player joins, run the ShowObjective function."
4. ShowObjective(p: player): This is the action. The p argument is the player who just joined. We tell the HUD device to display the message associated with it.

Crucial Step in UEFN: In the Verse Script device’s Details panel, you must link the variable objective_message to the actual HUD Message device you placed in the level. If you don’t do this, your variable is empty, and nothing will happen. It’s like having a remote control but no TV.

Try It Yourself

You’ve got the basics down, but let’s make it dynamic. Right now, every player sees the same message. That’s boring.

Challenge: Modify the code so that you have two different messages.

1. Create a second HUD Message device in your level named AttackerMessage with the text "Objective: Destroy the Beacon!".
2. Update your Verse script to have two variables: defender_message and attacker_message.
3. Hint: You can’t easily distinguish who is who in this simple example without more complex logic, but try to set up the structure. Can you make the script choose which message to show based on a simple condition? (Think about using an if statement to check a variable, or just try to get the second message to show up for everyone first as a test).

Hint: Look at how we stored objective_message. Create a second variable for attacker_message. In the Activate function, bind the OnPlayerJoined event to a function that checks which device to use. Or, simpler yet: just try to get the AttackerMessage to appear on screen when a player joins by duplicating the logic.

Recap

• Visual Aids are essential for player experience. They prevent confusion and keep the game flowing.
• The HUD Message device is your tool for displaying text overlays.
• Events like OnPlayerJoined are the triggers that start your logic.
• Variables store references to devices, allowing your code to control specific elements in the scene.

By mastering these small, visual interactions, you’re not just coding; you’re directing. You’re guiding your players through your world, ensuring they have the best possible experience. Now go make some islands that don’t leave players lost in the storm.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/triad-infiltration-9-creating-visual-aids-in-verse
• https://dev.epicgames.com/documentation/en-us/fortnite/triad-inflitration-09-creating-visual-aids-in-verse
• https://dev.epicgames.com/documentation/en-us/fortnite/triad-infiltration-in-verse
• https://dev.epicgames.com/documentation/en-us/uefn/verse-prop-hunt-template-2-playing-visual-effects-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/lesson-plan-theme-park-of-the-future-in-fortnite-creative