trick_tile_device: Floors That Vanish Under Your Feet

Overview

The trick_tile_device is a trap tile — a piece of floor that gets removed (destroyed) when the device is activated. Anyone standing on it suddenly has nothing under their feet. It's the building block for disappearing-floor deathruns, fake-safe-zone traps, collapsing bridges, and "don't step on the wrong tile" puzzles.

Reach for it when you want a piece of the world to drop out from under a player. Two things make it trigger:

• Agent contact — a player walks onto it (toggle this on/off with EnableAgentContactTrigger / DisableAgentContactTrigger).
• Your Verse code — call Trigger() to remove the tile on cue (e.g. when a timer ends or a button is pressed).

Two events let you react: TriggeredEvent fires the moment the device is triggered, and ActivatedEvent fires when the tile is actually removed (which can be later if you set an Activation Delay in the device's details panel). The whole device can be turned off with Disable so it ignores everything until you bring it back with Enable.

API Reference

trick_tile_device

A trap device that destroys the tile it's placed on when activated.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

trick_tile_device<public> := class<concrete><final>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a collapsing parkour tile. The scenario: a player sprints across a row of tiles. Each tile is a trick_tile_device set to trigger on contact. When a player steps on one, we want to:

1. Know who triggered it (via TriggeredEvent).
2. Know when the tile is actually gone (via ActivatedEvent) so we can flash a warning sign device.
3. Give the player a short head-start window: the trap starts disabled and we Enable it after the round begins.

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

# A collapsing parkour tile that drops players who step on it.
collapsing_tile_manager := class(creative_device):

    # The trap tile placed under the parkour path.
    @editable
    TrickTile : trick_tile_device = trick_tile_device{}

    # A localized helper so we can show real on-screen messages.
    Warn<localizes>(S:string):message = "{S}"

    OnBegin<override>()<suspends>:void =
        # The trap is enabled and listens for players stepping on it.
        TrickTile.Enable()
        TrickTile.EnableAgentContactTrigger()

        # React the instant the tile is triggered.
        TrickTile.TriggeredEvent.Subscribe(OnTileTriggered)

        # React when the tile is actually removed (may be delayed).
        TrickTile.ActivatedEvent.Subscribe(OnTileActivated)

    # Called the moment a player makes contact / the device fires.
    OnTileTriggered(Agent:agent):void =
        if (Player := player[Agent]):
            Print("A player triggered the trick tile!")

    # Called when the tile is physically removed from the world.
    OnTileActivated(Agent:agent):void =
        Print("The tile is gone — someone is falling!")

Line by line:

• @editable TrickTile : trick_tile_device = trick_tile_device{} — this field is what lets Verse talk to a placed device. After compiling, you assign your real placed trick tile to this slot in the device's Details panel. Without an @editable field, calling TrickTile.Method() would fail with Unknown identifier.
• TrickTile.Enable() turns the device on so it will react to events.
• TrickTile.EnableAgentContactTrigger() makes stepping on the tile fire it. If you only ever want to trigger it from code, skip this call.
• TrickTile.TriggeredEvent.Subscribe(OnTileTriggered) wires our method to the "device fired" event. Subscribe must be done inside OnBegin.
• OnTileTriggered(Agent:agent):void — a listenable(agent) event hands the handler an agent. We narrow it to a real player with if (Player := player[Agent]) before doing anything player-specific.
• ActivatedEvent fires after the tile is actually removed. With no Activation Delay it's near-instant; with a delay set in the details panel, this is your hook for "the floor just vanished."

Common patterns

Trigger the tile from your own logic

No contact needed — drop the floor on cue. Here a button device, when interacted with, calls Trigger() to yank the tile out.

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

# Pressing a button collapses a far-away tile (a lever-controlled trap).
lever_trap := class(creative_device):

    @editable
    Lever : button_device = button_device{}

    @editable
    TrickTile : trick_tile_device = trick_tile_device{}

    OnBegin<override>()<suspends>:void =
        # We do NOT want contact triggering here — only the lever fires it.
        TrickTile.Enable()
        TrickTile.DisableAgentContactTrigger()
        Lever.InteractedWithEvent.Subscribe(OnLeverPulled)

    OnLeverPulled(Agent:agent):void =
        # Remove the tile right now, regardless of who is standing on it.
        TrickTile.Trigger()

Toggle the trap on and off during a round

Use ToggleEnabled and ToggleAgentContactTrigger to make a tile that is only dangerous part of the time — perfect for a "safe phase / danger phase" rhythm trap.

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

# A tile that switches between safe and deadly every few seconds.
rhythm_tile := class(creative_device):

    @editable
    TrickTile : trick_tile_device = trick_tile_device{}

    OnBegin<override>()<suspends>:void =
        # Start enabled but with contact triggering OFF (safe phase).
        TrickTile.Enable()
        TrickTile.DisableAgentContactTrigger()

        loop:
            Sleep(3.0)
            # Flip whether stepping on the tile is dangerous.
            TrickTile.ToggleAgentContactTrigger()

Hard-disable the trap after it fires once

For a one-shot trap, Disable the device once it triggers so it stops reacting entirely.

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

# A one-time collapse: once it drops, the device goes inert.
one_shot_tile := class(creative_device):

    @editable
    TrickTile : trick_tile_device = trick_tile_device{}

    OnBegin<override>()<suspends>:void =
        TrickTile.Enable()
        TrickTile.EnableAgentContactTrigger()
        TrickTile.TriggeredEvent.Subscribe(OnTriggered)

    OnTriggered(Agent:agent):void =
        # Stop reacting to anything else for the rest of the game.
        TrickTile.Disable()

Gotchas

• You must have an @editable field. A bare trick_tile_device{} instance you new yourself is not the placed tile. Declare an @editable field, compile, then bind your real placed device in the Details panel.
• TriggeredEvent vs ActivatedEvent are not the same moment. TriggeredEvent fires when the device is triggered; ActivatedEvent fires when the tile is actually removed. If you set an Activation Delay in the device options, there can be a gap between them. Use TriggeredEvent for "someone set it off" and ActivatedEvent for "the floor is now gone."
• Enable vs contact-trigger are independent switches. Disable() makes the device ignore everything. DisableAgentContactTrigger() only stops stepping on it from firing — you can still fire it with Trigger(). Calling Trigger() on a fully Disabled device does nothing.
• Trigger() removes the tile immediately (subject to Activation Delay). There is no "un-trigger" — to bring the floor back you use the device's Reset() function (restores the removed tile).
• Unwrap the agent. Event handlers receive an agent. To treat it as a player, narrow it with if (Player := player[Agent]): before using player-only APIs. Don't assume every agent is a human player.
• Subscribe inside OnBegin. Event subscriptions belong in OnBegin; the handlers themselves are ordinary methods at class scope.