How to Build a Cinematic Title Sequence in UEFN

Forget the boring "Press Start" screen. If you want your island to feel like a AAA production, you need an intro sequence that sets the mood, tells the backstory, and lets players soak in the atmosphere before the chaos begins. We’re going to build a polished title sequence using Verse (Fortnite’s programming language) and Fixed Point Cameras to create a cinematic intro that fades from black, shows your logo, and then hands control over to the player.

What You'll Learn

• The Scene Graph: How devices live in the world and talk to each other.
• Variables vs. Constants: Storing camera references so your code knows where to look.
• Events: Triggering actions when the game starts (like the Battle Bus dropping).
• Timing: Using delays to create dramatic pauses between intro shots.

How It Works

Think of your island as a movie set. In Fortnite, you’re used to seeing the map instantly. But in movies, the director controls what you see and when you see it.

In UEFN, the Fixed Point Camera device is your director’s view. It’s a static camera that doesn’t move with the player; it’s locked in place, perfect for cutscenes or title screens.

Here’s the game mechanic analogy:

• The Scene Graph is like the Loot Pool. Just as the loot pool defines what items exist in your island, the Scene Graph defines all the devices (cameras, widgets, triggers) in your level. Your Verse script needs to reach into this pool to grab specific items.
• Variables are like your Health Bar. They hold a value that can change or be referenced. In our case, the variable holds the reference to a specific camera device.
• Constants are like Map Settings (e.g., Storm Damage). You set them once in the editor, and they don’t change during gameplay. We’ll use constants for things that never change, like the duration of a splash screen.
• Events are like the Overtime Timer. Something happens (the timer hits zero), and the game reacts. We’ll use the OnBegin event, which fires the moment the player spawns and the game starts—your "game on" signal.

We aren't just showing a static image. We’re creating a sequence:

1. Black Screen: The game starts, but the player sees nothing.
2. Splash Screen: A logo fades in.
3. Title Screen: The camera switches to a view of your island’s title, and a "Press Start" widget appears.

Let's Build It

First, you need two Fixed Point Camera devices in your level.

1. Place one camera facing a black wall or empty space (for the intro). Name it IntroCamera.
2. Place another camera facing your title screen or main hub. Name it TitleCamera.

Now, let’s write the Verse code to manage this.

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

# This is our Verse Device. Think of it as the "Director" script.
# It lives in the Scene Graph (the world) and controls the show.
TitleSequence := class(creative_device):
    # CONSTANTS: These are like Map Settings. Set once, never change.
    # How long does the black screen last? (In seconds)
    SplashDuration: float = 3.0
    
    # VARIABLES: These are like Loot Drops. We fill them in the editor.
    # We need to tell Verse *which* camera is the intro camera.
    # The 'edit:' keyword means you can drag-and-drop the camera device 
    # from your level into this field in the UEFN editor.
    @editable
    IntroCamera: cinematic_sequence_device = cinematic_sequence_device{}
    @editable
    TitleCamera: cinematic_sequence_device = cinematic_sequence_device{}

    # EVENTS: This is the trigger. Like the Battle Bus door opening.
    # This function runs automatically when the game begins.
    OnBegin<override>()<suspends>: void =
        # 1. Start with the Intro Camera active
        IntroCamera.Play()
        
        # 2. Wait for the splash duration
        # We use a timer to pause the script without freezing the game.
        # It's like waiting for the storm to shrink before moving.
        Sleep(SplashDuration)
        
        # 3. Switch to the Title Camera
        IntroCamera.Stop()
        TitleCamera.Play()
        
        # 4. Here is where you would trigger your "Press Start" UI
        # For now, we just log that the sequence is done.
        Print("Title Sequence Complete. Player is ready.")```

### Walkthrough

1.  **`import`**: Just like loading a specific loadout, we’re importing the tools we need. `fixed_point_camera_types` gives us the ability to turn cameras on and off.
2.  **`class(abstract)`**: This creates our device. It’s a container for our logic.
3.  **`SplashDuration: float = 3.0`**: This is a **Constant**. We set it to 3 seconds. If you want a longer, more dramatic pause, change this number.
4.  **`IntroCamera: ... = ...{}`**: This is a **Variable**. The `{}` means it’s empty by default. You *must* assign a camera to this in the UEFN editor, or the code won’t know which camera to look at. It’s like having an empty slot in your inventory; you have to put something in it.
5.  **`OnBegin()`**: This is the **Event**. It’s the "Game Start" button. When a player joins and loads into your island, this function fires.
6.  **`timers.After(...)`**: This is the **Storm Timer**. It doesn’t run the next line immediately. It waits for the specified time (3 seconds) before running the code inside the parentheses. This creates the pause between the black screen and the title screen.

## Try It Yourself

You’ve got the basics, but let’s make it feel like a real movie.

**Challenge:** Add a second delay. After the title camera appears, wait another 2 seconds before printing "Player is ready."

**Hint:** You can nest timers! Put a second `timers.After` inside the first one. It’s like a double elimination bracket—wait for the first event, then wait for the second.

## Recap

*   **Fixed Point Cameras** let you control what the player sees, independent of their movement.
*   **Variables** hold references to devices (like cameras) that you assign in the editor.
*   **Events** like `OnBegin` trigger your code when the game starts.
*   **Timers** allow you to sequence events over time, creating a cinematic intro.

## References

*   https://dev.epicgames.com/documentation/en-us/uefn/making-a-title-sequence-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/ingame-user-interfaces-in-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/uefn/title-sequence-5-setting-up-the-devices-in-unreal-editor-for-fortnite