Build Your Own QTE: Custom Skilled Interactions in UEFN

Remember those sweaty palms during the final circle when you had to hit a specific timing bar to win? That’s a Quick Time Event (QTE), and for years, Fortnite Creative gave us basic versions. But if you want to make your island feel like a AAA title—where players are actually pressing buttons in rhythm or aiming at moving targets to unlock doors or trigger traps—you need Skilled Interactions.

In this tutorial, we’re ditching the boring "press E to open" logic. We’re going to build a Chaos Lock: a door that only opens if you can hit three moving targets in a row before the timer runs out. If you miss? You get knocked back. We’ll use the Skilled Interaction Device and tie it to a custom UI using View Models (the bridge between your code and what the player sees).

What You'll Learn

• The Skilled Interaction Device: How to set up a mechanic that requires active player input (like aiming or timing) rather than just standing still.
• View Models: The "remote control" that lets Verse talk to your custom User Widgets (UI).
• State Management: Tracking successes and failures to decide if the door opens or slams shut.
• Scene Graph Basics: Understanding how devices, widgets, and code entities connect in the editor.

How It Works

Think of a Skilled Interaction like a mini-game embedded in your map. In standard Fortnite, you might press "Interact" to pick up a shield. In a Skilled Interaction, you have to do something specific—like hold a button for 3 seconds, or shoot a moving target.

Here is the breakdown of the system we are building:

1. The Trigger: A player enters a zone or presses a button. This starts the "Interaction."
2. The UI (User Widget): A custom HUD appears. It shows a bar, a timer, or targets. This is drawn using UMG (Unreal Motion Graphics, which is just Epic’s fancy name for the UI designer in UEFN).
3. The Logic (Verse): Your code watches what the player does. Did they hit the target? Did they run out of time?
4. The Result: If they succeed, the door opens. If they fail, a trap triggers.

The Secret Sauce: View Models

You might wonder, "How does my Verse code know if the player hit the target?"

Imagine your UI is a TV screen. The User Widget is the screen itself. The View Model is the remote control. Your Verse code doesn't draw the pixels; it sends signals to the View Model ("Show green when success," "Show red when fail"), and the Widget displays it. This separation keeps your code clean and your graphics smooth.

Let's Build It

We are building a Chaos Lock.

• Goal: Hit 3 targets.
• Fail Condition: Miss 2 targets or time runs out.
• Reward: Door opens.
• Punishment: Player takes damage and gets knocked back.

Step 1: The Setup (Scene Graph)

In UEFN, everything is an Entity (a thing in the world). We need:

1. Skilled Interaction Device: Place this near your door. Set it to "Multiplayer" if you want friends to compete.
2. User Widget: Create a simple UI in the UI Designer. It needs:
   • A Text Block for "Successes: [X]/3"
   • A Progress Bar for the Timer.
   • A Panel for "Targets" (we'll use simple colored boxes for now).
3. Door: A Prop Mover set to open.
4. Verse Device: To run our code.

Step 2: The Verse Code

This code is simplified for clarity. It assumes you have linked the UI elements in the View Model.

# ChaosLock.ver
# A simple Verse script to manage a QTE door

# 1. DEFINE THE CONSTANTS (The Rules)
# Think of these as the "Patch Notes" for your island. They never change.
const MAX_SUCCESSES := 3
const MAX_FAILURES := 2
const TIMER_SECONDS := 10.0

# 2. DEFINE THE ENTITIES (The Props)
# These are references to devices you place in the editor.
# 'bind' means "connect this code variable to that device."
var door_prop_mover := bind<PropMover>("Door_Mover")
var skilled_interaction := bind<SkilledInteraction>("Chaos_Lock_Device")
var view_model := bind<ViewModel>("Chaos_UI_Controller")

# 3. DEFINE THE STATE (The Scoreboard)
# Variables that change during the game.
var current_successes := 0
var current_failures := 0
var is_active := false

# 4. THE MAIN FUNCTION (The Game Loop)
# This runs when the device starts.
start_interaction() := func():
    is_active = true
    current_successes = 0
    current_failures = 0
    
    # Update UI immediately
    update_ui()
    
    # Start the timer (simulated)
    wait(TIMER_SECONDS)
    
    # Check if time ran out
    if is_active:
        fail_interaction("Time's up! Try again.")

# 5. HANDLING SUCCESS
# Called when the player hits a target
on_success() := func():
    if not is_active:
        return
        
    current_successes += 1
    update_ui()
    
    # Check for win condition
    if current_successes >= MAX_SUCCESSES:
        win_interaction()

# 6. HANDLING FAILURE
# Called when the player misses or makes a mistake
on_failure():
    if not is_active:
        return
        
    current_failures += 1
    update_ui()
    
    # Check for lose condition
    if current_failures >= MAX_FAILURES:
        fail_interaction("Too many misses! You're locked out.")

# 7. WIN/LOSS LOGIC
win_interaction() := func():
    is_active = false
    # Open the door
    door_prop_mover.Set_Target_Position(1.0) # 1.0 is usually "open"
    view_model.Show_Message("SUCCESS! Door Open.")
    # Optional: Play a sound or particle effect here

fail_interaction(message: string) := func():
    is_active = false
    # Trigger a trap (e.g., knockback)
    view_model.Show_Message(message)
    # Note: In a full script, you'd trigger a damage event here

# 8. UI UPDATER
# This pushes data to the View Model
update_ui() := func():
    # This is pseudo-code for how you'd bind data to the UI
    # In real UEFN, you'd use specific View Model bindings
    view_model.Set_Text("Successes", string(current_successes) + "/" + string(MAX_SUCCESSES))
    
    # Calculate progress for timer bar
    # (Simplified: assumes timer is handled externally or via device settings)
    view_model.Set_Progress(current_failures / MAX_FAILURES)

Walkthrough: What Just Happened?

1. Constants: We set MAX_SUCCESSES to 3. This is like setting the "Max Health" in a game mode. It’s fixed.
2. Bindings: We used bind<...> to tell Verse, "Hey, when I say door_prop_mover, I mean that specific Prop Mover device in my scene." Without this, Verse doesn't know which door to open.
3. State: current_successes is a variable. It starts at 0. Every time the player hits a target, we add 1.
4. Functions: on_success() and on_failure() are functions (reusable blocks of code). Instead of writing the "win" logic twice, we just call the function.
5. View Model: The update_ui() function sends data to the UI. If current_successes is 1, the text says "1/3".

Try It Yourself

Challenge: Add a "Speed Run" mode.

Right now, the timer is fixed at 10 seconds. Can you add a Constant called SPEED_MODE_THRESHOLD? If the player has 2 successes and only 1 failure left, switch the timer to be 50% faster.

Hint: You’ll need to check the current_successes inside your on_success() function and adjust the TIMER_SECONDS variable or trigger a secondary timer device.

Don't know how to adjust the timer dynamically? Think about it like this: If you have a Storm Timer device, you can change its "Duration" property. In Verse, you might need to reference a Timer Device and call a function like Set_Duration(). Check the UEFN documentation for "Timer Device" to see how to change values on the fly.

Recap

You’ve just built the backbone of a skill-based mini-game. You learned how to:

1. Use Constants for unchanging rules.
2. Use Variables to track player performance.
3. Connect Verse to UI via View Models.
4. Create a loop of Input -> Logic -> Feedback.

Skilled Interactions are the difference between a static map and a dynamic experience. Now go make some players sweat (in a fun way).

References

• https://dev.epicgames.com/documentation/en-us/fortnite/creating-custom-skilled-interactions-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/squid-game-multiplayer-skill-checks-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/user-interface-devices-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/32-00-release-notes-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/sdg-sustainable-cities-lesson-plan-in-fortnite-creative