The "Don't Leave Me Behind" Device: Building a DBNO Mountain Climb

So you've built a mountain. It's steep. It's dangerous. And if a player falls off, they're done. Game over. Boring.

Let's change that. In this tutorial, we're building a Down But Not Out (DBNO) system. Think of DBNO like the "revive" mechanic in Fortnite Zero Build or Apex Legends—when your health hits zero, you don't vanish. You drop to the ground, vulnerable, waiting for a teammate to save you. If they don't? Then you're out.

We're going to create a cooperative mountain-climbing challenge where players must stick together. If your buddy gets knocked down by a rolling boulder, you have to drag them to safety before the timer runs out. No more solo queue rage; this is all about teamwork.

What You'll Learn

• The DBNO State: Understanding the "zombie mode" between healthy and eliminated.
• Event-Driven Logic: How devices talk to each other without you writing complex code from scratch.
• Scene Graph Basics: How to group devices (like a "Revive Zone") so they act as one unit.
• Co-op Design: Building mechanics that force players to help each other.

How It Works

In standard Fortnite Creative, when your health hits 0, you're eliminated. The screen goes gray, and you wait in the lobby. That's the Elimination State.

The Down But Not Out (DBNO) device changes the rules. It inserts a new state: Downed.

1. Healthy: You have health. You can move, shoot, build.
2. Downed: You have 0 health, but you're still on the map. You can't move much (or at all, depending on settings), and you're an easy target.
3. Eliminated: If you stay downed too long, or if an enemy finishes you off, you're out.

The magic happens in the Revive action. A teammate can interact with a downed player to restore their health. This creates tension: Do I save my buddy and risk getting killed myself? Or do I run for the summit?

The Scene Graph: Grouping Your Devices

Before we touch any code, let's talk about the Scene Graph. In Unreal Engine (and UEFN), everything on your island is an "Entity" (like a player, a wall, or a device). Entities can have "Components" (like a Mesh, a Physics Body, or a Script).

Think of the Scene Graph like a Lobby Party.

• The Party Leader is the parent entity.
• The Friends are child entities.
• If you kick the Party Leader, everyone leaves. If you mute the Party Leader, everyone hears less.

In our build, we'll create a parent device (let's call it the "Mountain Base") that contains our DBNO logic. This keeps our island organized. Instead of having 50 loose wires connecting devices, we group them. If we want to move the spawn point, we move the parent, and all the children move with it.

Let's Build It

We are building a simple "Boulder Dodge" zone.

1. The Danger: A Physics Boulder rolls down a ramp.
2. The Consequence: If the boulder hits a player, they get Downed (DBNO).
3. The Rescue: A teammate must use a "Revive" device (like a Med Kit or a custom button) to bring them back to full health.

Note: In modern UEFN, many of these behaviors are handled by device settings rather than raw Verse code for simple setups. However, to teach you how Verse controls these interactions, we will look at the logic flow.

Step 1: The Setup (No Code Yet)

1. Place a Player Spawner for Player 1 and Player 2 at the bottom of a hill.
2. Place a Capture Zone at the top of the hill. Set it to "Occupied" to win.
3. Place a Physics Boulder device at the top. Set its "Initial Velocity" to push it down the hill.
4. Place a Down But Not Out device near the spawn.
   • Settings: Enable "Enable Down But Not Out."
   • Revive Time: Set this to 10 seconds (this is your "timer" before they are eliminated).

Step 2: The Verse Logic (The "Brain")

Now, we need to make sure that when the boulder hits the player, the DBNO device actually triggers. In older UEFN, you might have used wires. In Verse, we use Events and Functions.

• Event: Something that happens (e.g., "Boulder Hit Player").
• Function: A block of code that does something (e.g., "Make Player Downed").

Here is how we write that logic in Verse. This script attaches to the Physics Boulder.

# This script makes the boulder trigger a DBNO state on hit

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

# A creative_device subclass that holds a reference to the
# down_but_not_out_device placed in the editor and a
# damage_volume_device that surrounds the boulder's collision area.
# Because Verse creative devices cannot directly subscribe to
# physics-body collision events, we use a damage_volume_device
# to detect when the boulder's area overlaps a player, then
# apply the DBNO effect through the down_but_not_out_device.
boulder_manager_device := class(creative_device):

    # This is a 'Constant' - a value that never changes.
    # Think of it like the 'Game Mode' setting in the island settings.
    # Wire this to your Down But Not Out device in the editor.
    @editable
    DownButNotOutDevice : down_but_not_out_device = down_but_not_out_device{}

    # Wire this damage_volume_device so it surrounds the rolling boulder.
    # Set its damage to 100 in the editor so it knocks players to 0 HP,
    # which the DBNO device intercepts before elimination.
    @editable
    BoulderDamageVolume : damage_volume_device = damage_volume_device{}

    # This is the 'Main' function. It runs once when the island starts.
    # Think of it like the 'Start Button' on the battle bus.
    OnBegin<override>()<suspends> : void =
        # We need to listen for when the boulder area overlaps a player.
        # In Verse, we 'subscribe' a function to an event.
        # Event: 'AgentEntersEvent' -> Function: 'HandleBoulderHit'
        BoulderDamageVolume.AgentEntersEvent.Subscribe(HandleBoulderHit)

    # This is a 'Function' - a reusable block of code.
    # Think of it like a 'Trap' that activates when triggered.
    # AgentEntersEvent always delivers an agent, so we know it is a player.
    HandleBoulderHit(HitAgent : agent) : void =
        # Cast the agent to fort_character so we can check game state.
        # 'GetFortCharacter[]' fails if the agent has no living character,
        # which guards us from acting on already-eliminated players.
        if (Character := HitAgent.GetFortCharacter[]):
            # If the character is already in a downed state, do nothing.
            # We don't want to double-down them.
            # IsActive[] fails (returns false) when the character is downed
            # or eliminated, so we only proceed when they are fully active.
            if (Character.IsActive[]):
                # Here is the magic: Trigger the DBNO state.
                # Down() tells the down_but_not_out_device to immediately
                # set this agent into the downed state instead of a full
                # elimination. This is like pressing the 'Revive' button,
                # but backwards.
                DownButNotOutDevice.Down(HitAgent)
                # note: down_but_not_out_device.Down() directly places the
                # agent into the Downed state. Pair this with the damage
                # from BoulderDamageVolume (set to 100 in editor settings)
                # to immediately trigger the transition.```

### Walkthrough: What Just Happened?

1.  `using { ... }`: These are **Libraries**. Think of them as your **Loadout**. You can't use a rocket launcher if you didn't bring it in the bus. We're bringing in the Device, Character, Simulation, and Diagnostics libraries.
2.  `boulder_manager_device := class(creative_device)`: This defines our **Entity**. It's the "container" for our logic.
3.  `@editable DownButNotOutDevice : down_but_not_out_device`: This is a **Reference**. Think of it like a **Tether**. It connects our boulder manager to the DBNO device we placed in the editor. When we change the DBNO device settings in the editor, this script sees it.
4.  `OnBegin<override>()<suspends> : void`: This is the **Start Screen**. It runs once when the game begins. Its job is to set up the triggers.
5.  `BoulderDamageVolume.AgentEntersEvent.Subscribe(HandleBoulderHit)`: This is the **Event Listener**. It's like setting a **Pressure Plate**. When a player enters the damage volume around the boulder, the `HandleBoulderHit` function is called.
6.  `if (Character := HitAgent.GetFortCharacter[])`: This is a **Conditional**. It's like the **Storm Timer** checking if you're outside. If the agent has no living character (e.g., already eliminated), we ignore it.
7.  `DownButNotOutDevice.Activate(HitAgent)`: This is the **Action**. It tells the DBNO device: "Hey, make this player downed the next time they would be eliminated." Combined with the damage volume's 100-damage hit, that transition happens immediately.

## Try It Yourself

You've got the basics. Now, let's add some chaos.

**Challenge:** Add a "Loot Goblin" twist.
If a player is downed, they drop a random item (like a shield potion or a rocket launcher) on the ground. The teammate who revives them gets the item *back*, but anyone else who picks it up gets a "debuff" (slows them down).

**Hint:**
1.  Look up the **Item Granter** device.
2.  You'll need to modify the `HandleBoulderHit` function. Instead of just calling `Activate`, you'll want to call a function on the Item Granter to spawn an item at the player's location (`Character.GetTransform().Translation`).
3.  Use the **Timer** device to reset the item after 30 seconds.

Don't overcomplicate it! Start by just spawning the item. Then, worry about the debuff.

## Recap

*   **DBNO (Down But Not Out)** is a state between healthy and eliminated. It allows for revives.
*   **Events** (like `AgentEntersEvent`) are triggers that start actions.
*   **Functions** (like `HandleBoulderHit`) are the logic you write to respond to events.
*   **References** (`@editable` device fields) connect your script to devices in the editor, like a tether connecting two players.
*   **Scene Graph** helps you organize devices so your island doesn't become a spaghetti bowl of wires.

Now go make your friends earn their revives.

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/down-but-not-out-device-design-example
*   https://dev.epicgames.com/documentation/en-us/fortnite/down-but-not-out-device-design-examples-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite-creative/device-design-examples-in-fortnite-creative
*   https://dev.epicgames.com/documentation/en-us/fortnite/31-10-fortnite-ecosystem-updates-and-release-notes-in-creative-and-unreal-editor-for-fortnite
*   https://dev.epicgames.com/documentation/en-us/fortnite/using-down-but-not-out-devices-in-fortnite-creative