The "Press Start" Effect: Building a Pro Title Sequence in UEFN

You know that feeling when you jump off the Battle Bus and the screen fades to black before the match starts? That’s not just a loading screen; that’s polish. It’s the difference between a backyard skirmish and a curated experience. In this tutorial, we’re going to build a custom Title Sequence that plays before your island loads, using Verse to control the timing, Fixed Point Cameras to direct the "movie," and HUD Message devices to display your custom UI.

By the end, you’ll have a sequence that fades in, shows off your logo or backstory, and then hands control over to the player. No more staring at a blank loading screen wondering if your island crashed.

What You'll Learn

• The Scene Graph as a Movie Set: How to use the hierarchy of devices (like layers in Photoshop) to manage what the player sees.
• Verse Devices as Directors: Writing a script that acts like a film director, calling "Cut!" and "Action!" on specific devices.
• Widget Blueprints for UI: Designing a custom title screen that looks better than the default Fortnite lobby.
• Camera Control: Using Fixed Point Cameras to force the player’s view, just like a cinematic in a story mode.

How It Works

Think of a Title Sequence like a Pre-Match Lobby that you can’t skip. In Fortnite, you spawn in, wait for players to join, and then the match starts. A title sequence hijacks that waiting period.

Here’s the game mechanic analogy:

• The Fixed Point Camera is like the Director’s View in Creative mode. It locks the player’s eyes to a specific spot, ignoring their mouse or controller. It’s the "cutscene" camera.
• The HUD Message Device is like a Prop Mover but for text and images. It doesn’t move through the world; it floats on top of the screen (the HUD), overlaying your custom design.
• The Verse Device is the Gamepad Button that triggers everything. But instead of just pressing one button, it’s a smart button that waits 3 seconds, then triggers the camera change, then triggers the UI, all in a specific order.

We aren’t just displaying text; we are orchestrating a moment. We’ll use Verse to manage the timeline. If the camera moves too fast, it’s like a jump scare. If the text stays too long, it’s like a laggy ping. Verse keeps the rhythm tight.

Let's Build It

We need three things:

1. The Visuals: A Widget Blueprint (WBP) for the title screen.
2. The Stage: Fixed Point Cameras to show the background.
3. The Director: A Verse script to tie it all together.

Step 1: The Visuals (Widget Blueprint)

Before coding, we need the "skin." We’ll create a simple title screen using the Widget Editor.

1. In the Content Drawer, right-click and select Widget Blueprint. Name it WBP_Title.
2. Open it. You’ll see a blank canvas. This is your UI layer.
3. Add a Size Box to the canvas. This is your container. In the Details panel, set the Padding to 0, 0, 0, 200. This pushes everything up 200 pixels from the bottom, giving you space for a "Press Start" prompt later.
4. Inside the Size Box, add a Stack Box. This arranges widgets in a line (vertical or horizontal). Set it to Vertical.
5. Inside the Stack Box, add an Image widget. Load your logo or a cool background image here.
6. Below the Image, add a Text Block. Type your island name (e.g., "BRAINDEAD ISLAND"). Make the font big and bold.
7. Save and close. You now have a custom UI asset.

Step 2: The Stage (Cameras & HUDs)

1. Place two Fixed Point Camera devices in your level.
   • Name one SplashCamera (for the initial black screen or logo).
   • Name the other TitleCamera (for the main title screen).
   • Tip: Point these cameras at a nice view, or just have them look at a black wall if you want a pure black background.
2. Place a HUD Message device.
   • In its Details panel, under Widget, select WBP_Title.
   • Set Is Visible to False initially. We don’t want it showing until the Verse script tells it to.
3. Place a Pop-Up Dialog device (optional, for a "Press Start" button later, but we’ll keep it simple for now).

Step 3: The Director (Verse Code)

Now, we write the script. This Verse device will act as the conductor.

1. Create a new Verse file named TitleSequence.verse.
2. Paste the following code. I’ve annotated it heavily so you know exactly what’s happening.

# TitleSequence.verse
# This script acts as the Director, controlling the flow of the title sequence.

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Symbols }

# We define our "Director" device. 
# Think of this as the control room for our mini-movie.
Title_Sequence_Device := class(creative_device):

    # These are our "Actors" (the devices we control).
    # We use 'constant' for the splash camera because it never changes role.
    # We use 'editable' for the title camera so we can swap it out in the editor if needed.
    splash_camera: constant fixed_point_camera_device = create(fixed_point_camera_device)
    title_camera: editable fixed_point_camera_device = create(fixed_point_camera_device)
    
    # The UI element we designed earlier
    title_hud: editable hud_message_device = create(hud_message_device)
    
    # A timer to manage the flow. 
    # Think of this like the Storm Timer: it counts down, then triggers an event.
    sequence_timer: timer = create(timer)

    # This function runs when the island starts.
    # It’s like the "Match Start" event.
    OnBegin<override>()<suspends>: void := 
    begin
        # 1. Start with a black screen or splash.
        # We tell the splash camera to "Take Control" of the player's view.
        # This is like forcing the player to watch a cutscene.
        splash_camera.Set_Active(true)
        
        # 2. Wait for 3 seconds.
        # This is the "dramatic pause."
        sequence_timer.Wait(3.0)
        
        # 3. Switch the view to our Title Camera.
        splash_camera.Set_Active(false)
        title_camera.Set_Active(true)
        
        # 4. Show the HUD.
        # We set the HUD to visible. It’s like flipping a light switch.
        title_hud.Set_Is_Visible(true)
        
        # 5. Wait another 2 seconds, then...
        sequence_timer.Wait(2.0)
        
        # 6. End the sequence.
        # We deactivate the title camera. 
        # This returns control to the player (or the next game state).
        title_camera.Set_Active(false)
        
        # Optional: You could trigger a "Start Game" event here
        # by activating a trigger device or changing the game mode.
    end

Walkthrough: What Just Happened?

1. class(creative_device): This tells Verse, "I’m building a device that lives in the editor." It’s the base class for all UEFN devices.
2. splash_camera vs title_camera: We defined two cameras. One is constant (fixed at compile time), and one is editable (you can change it in the editor). This is like having a pre-set camera angle vs. one you can adjust on the fly.
3. OnBegin: This is the entry point. It runs once when the island loads. It’s the "Start Button" of your script.
4. sequence_timer.Wait(3.0): This pauses the script for 3 seconds. During this time, the game keeps running (animations play, sounds play), but your script is idle. It’s like a "Hold Position" command in a squad.
5. Set_Active(true/false): This toggles the camera. Only one camera should be active at a time to avoid confusion. It’s like switching channels on a TV.

Try It Yourself

You’ve got the basics! Now, make it your own.

Challenge: Add a "Press Start" prompt that only appears after the title screen has been visible for 5 seconds.

Hint:

1. Add a second Text Block to your WBP_Title widget called "Press_E".
2. Set its initial visibility to False in the widget editor (or via Verse).
3. In your Verse script, after the title camera becomes active, add another Wait(5.0).
4. Then, use a HUD Controller device or a Trigger to change the text visibility. (Hint: You might need to use a HUD Controller device to toggle the widget’s internal elements, or simply use a second HUD Message device for the prompt).

Don’t know how to toggle widget elements? Look up HUD Controller devices in the UEFN docs. They are the remote control for your UI!

Recap

• Title Sequences are like pre-match lobbies that you script.
• Fixed Point Cameras lock the player’s view, creating a cinematic feel.
• Widget Blueprints let you design custom UIs that float on top of the game.
• Verse acts as the director, using timers and device toggles to sequence the events.

You now have the tools to turn your blank loading screen into a polished, professional intro. Go make your island look like it has a budget.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/title-sequence-3-designing-the-title-screen-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/making-a-title-sequence-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/title-sequence-1-coding-the-verse-device-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/title-sequence-5-setting-up-the-devices-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/making-a-title-sequence-in-unreal-editor-for-fortnite