The Loot Goblin’s Nightmare: Building an Item Remover Trap

Imagine this: You just pulled off the ultimate clutch. You have a full loadout, three shield potions, and a stack of gold bars. You sprint into the final circle, feeling like a god. Then, you step on a rug. Poof. Your inventory is empty. You’re holding a rock. And the enemy? They’re laughing.

Welcome to the world of Item Remover devices in Fortnite Creative. This isn’t just a mechanic; it’s psychological warfare. It’s the difference between a satisfying comeback and a rage-quit. In this tutorial, we’re going to build a "Down But Not Out" loot trap. It’s a classic for a reason: it forces players to risk their gear to survive, turning every firefight into a high-stakes gamble.

By the end of this guide, you won’t just know what an Item Remover is; you’ll have built a device that strips players of their weapons when they go down, creating chaos, teamwork, and plenty of funny moments.

What You'll Learn

• The Concept of "Events": How to make one thing happen (getting downed) trigger another (losing loot).
• Inventory Management: How to control what a player carries using devices.
• Device Linking: Connecting two separate devices to work as a single system.
• The Scene Graph Basics: Understanding how devices "talk" to each other through the game’s hierarchy.

How It Works

To understand the Item Remover, you have to think about your inventory like a backpack. Normally, when you pick up an item, it goes in. When you drop it, it comes out. But in Creative, we can force the backpack to empty itself without the player touching a button.

Here is the programming concept we are using, translated into Fortnite terms:

1. The Event (The Trigger)

In programming, an Event is something that happens. It’s not an action you take; it’s a moment in time. Think of it like the Storm Timer. You don’t "do" the storm timer closing; it just happens at a specific second. When that second hits, the storm moves.

In our case, the event is: Player Goes Down But Not Out (DBNO). This is the moment a player’s health hits zero, but they are still alive in the chair. It’s a specific moment in time that the game detects.

2. The Action (The Effect)

An Action is what happens because the event occurred. Think of it like a Prop Mover. When the Prop Mover receives a signal, it moves. It doesn’t ask questions; it just executes.

The Item Remover is the device that performs this action. It doesn’t care why the signal was sent. It just knows: "Signal received? Okay, empty the player’s inventory."

3. The Connection (The Wire)

In UEFN (Unreal Editor for Fortnite), devices don’t talk to each other with magic. They use Events and Actions like wires.

• The Down But Not Out device sends an event when a player goes down.
• The Item Remover device listens for that event to perform its action.

You connect them by linking the output of one to the input of the other. It’s like plugging a speaker into an amplifier. The amplifier (Item Remover) only makes sound when the speaker (DBNO Device) sends it a signal.

Why This Matters for the Scene Graph

In Unreal Engine 6 (and Verse), everything is part of a Scene Graph. This is just a fancy term for the family tree of your game world.

• Entities are the players, props, and devices.
• Components are the traits those entities have (like "Health," "Inventory," or "Is a Trigger").

When you place an Item Remover and a DBNO device, they are separate entities in this graph. But by linking their events, you are creating a logical connection between two different parts of the scene. The Item Remover doesn’t need to know where the player is; it just needs to know which player sent the signal. This is powerful because it means you can have one Item Remover strip loot from any player who triggers any DBNO event on the map.

Let's Build It

We are going to build a simple loop:

1. Player gets shot.
2. Player goes DBNO.
3. Player drops all loot.
4. Player has to crawl to a loot box to survive.

Step 1: Place Your Devices

Go to your Creative inventory and place two devices:

1. Down But Not Out (Found in the "Game" category).
2. Item Remover (Found in the "Game" category).

Pro Tip: Rename them! Right-click the DBNO device and name it "DBNO_Trigger." Right-click the Item Remover and name it "Loot_Strapper." This makes your life infinitely easier when you’re debugging later.

Step 2: Configure the DBNO Device

Select your DBNO_Trigger. In the details panel, make sure DBNO Enabled is set to Yes. This is crucial. If this is off, no one goes down, and no events fire.

Step 3: Configure the Item Remover

Select your Loot_Strapper. Look for the Actions section. You’ll see a list of things it can do. We want it to Remove Items.

Step 4: The Wiring (Connecting the Dots)

This is where the magic happens. We need to tell the Item Remover when to act.

1. Click on the DBNO_Trigger device.
2. Look at the Events section. You should see an event called On Player Downed (or similar, depending on your version).
3. Click the + button next to that event.
4. A connection line will appear. Drag it over to the Loot_Strapper device.
5. A menu will pop up asking what action to perform. Select Remove Items.

Wait, what just happened? You just wrote code. You just told the game: "When the DBNO_Trigger detects a player going down, tell the Loot_Strapper to remove their items."

Step 5: Test It

Hit Play. Find a friend or use a bot. Shoot yourself until you go DBNO. Watch your inventory. If you did it right, your weapons and items will vanish from your screen the moment you hit the chair.

The Verse Way: Under the Hood

You might be wondering, "Can I do this with Verse?" Yes! And it’s actually simpler than you think. In Verse, we don’t drag wires; we write functions that listen for events.

Here is how that same logic looks in Verse. This code is real, usable Verse that you can drop into a Verse Script device.

# This script makes players drop loot when they go down.
# It's like a digital Item Remover, but written in code.

using { /Fortnite.com/Devices }
using { /Verse.org/Sim }

# We create a new "Actor" (a game object) that holds our logic.
# Think of an Actor as a container for devices and code.
actor LootDropTrap is Device()
{
    # This is a "Variable." 
    # In Fortnite terms, it's like a prop that changes state.
    # Here, we store a reference to the DBNO device.
    dbno_device: DBNODevice = DBNODevice{}

    # This is a "Function." 
    # A function is a reusable block of code that does something.
    # Think of it like a "Play Animation" action on a device.
    # We will call this function when the player goes down.
    OnPlayerDowned(player: Player) -> void
    {
        # This line is the "Action."
        # We are telling the player to drop their inventory.
        # It's the same as clicking "Remove Items" on the Item Remover device.
        player.RemoveItems()
        
        # Optional: Let's add some flavor!
        # We can print a message to the debug log.
        # This is like seeing a "Kill Feed" message, but for code.
        print("Loot stripped from ", player.GetName())
    }

    # This is the "Event Binding."
    # In the device editor, this is the wire.
    # We are saying: "When the DBNO device fires 'OnPlayerDowned', run my function."
    event OnBegin<override>()
    {
        # We connect the DBNO device's event to our function.
        # It's like plugging the wire from DBNO_Trigger to Loot_Strapper.
        dbno_device.OnPlayerDowned += OnPlayerDowned
    }
}

Breaking Down the Code

1. actor LootDropTrap is Device(): This creates a new device. You can place this in your world just like any other device.
2. dbno_device: DBNODevice: This is a variable. It’s a slot that holds a reference to a specific DBNO device.
3. OnPlayerDowned(player: Player) -> void: This is a function. It’s a set of instructions. void means it doesn’t return a value (like a one-way street).
4. player.RemoveItems(): This is the action. It’s the Verse equivalent of the Item Remover’s "Remove Items" setting.
5. dbno_device.OnPlayerDowned += OnPlayerDowned: This is the event binding. It’s the wire. It says, "When the DBNO device sends an 'OnPlayerDowned' signal, execute the OnPlayerDowned function."

Try It Yourself

Now that you have the basics, try to upgrade your trap.

Challenge: Make the player respawn with no items after they are eliminated (not just downed).

Hint: You’ll need to use the On Player Eliminated event from the DBNO device (or a separate Elimination device) and link it to a Respawn action. But wait! If you just respawn them, they might keep their items. How do you ensure they spawn empty? (Think about the order of operations: Remove Items before Respawn).

Stuck? Check the Item Spawner device docs to see how to give items back, then try to reverse the logic!

Recap

• Item Remover devices let you force players to drop their loot.
• Events (like "Player Downed") trigger Actions (like "Remove Items").
• You can link devices in the editor using wires, or use Verse to bind events to functions programmatically.
• This mechanic creates high-stakes gameplay by forcing players to choose between survival and their gear.

Now go forth and make your players cry over their empty inventories. They’ll thank you later (probably).

References

• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-item-remover-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-item-remover-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/item-remover-device-design-example-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/item-remover-device-design-example-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-devices-in-fortnite-creative