barrier_device: Invisible Walls You Control in Code

Overview

A barrier_device creates an invisible (or visible) wall that blocks agent movement and weapon fire inside its configured zone. It is the go-to tool whenever you want to temporarily keep players penned in or fenced out: the starting cage of a box fight, a locked VIP room, a hazard area that opens only when an objective is complete.

The key thing the barrier gives you over a static wall in the level is runtime control. From Verse you can:

• Enable() the barrier to raise the wall.
• Disable() the barrier to drop it (the classic "timer runs out, cages open" moment).
• AddToIgnoreList(Agent) to let one specific player walk through while everyone else is still blocked.
• RemoveFromIgnoreList(Agent) / RemoveAllFromIgnoreList() to undo those exceptions.

Reach for it whenever a wall needs to be conditional — controlled by a timer, a trigger, a team, or a single VIP.

API Reference

barrier_device

Creates an impenetrable zone that can block agent movement and weapon fire.

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

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

Methods (call these to make the device act):

Walkthrough

Let's build the classic box-fight cage. When the match begins, three barriers wall the players into their starting boxes. A timer_device counts down; when it succeeds, all three barriers drop so combat can begin.

This is exactly the box-fight pattern, written as one complete device.

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

# Manages the start-of-round cages for a box fight.
box_fight_manager := class(creative_device):

    # The three barriers that pen players in at the start.
    @editable
    Barrier1 : barrier_device = barrier_device{}

    @editable
    Barrier2 : barrier_device = barrier_device{}

    @editable
    MidBarrier : barrier_device = barrier_device{}

    # The countdown that decides when the cages drop.
    @editable
    Timer : timer_device = timer_device{}

    OnBegin<override>()<suspends> : void =
        # Raise all cages the moment the game starts.
        Barrier1.Enable()
        Barrier2.Enable()
        MidBarrier.Enable()

        # When the timer finishes, run DropBarriers.
        Timer.SuccessEvent.Subscribe(DropBarriers)

        # Kick off the countdown.
        Timer.Start()

    # SuccessEvent hands us the agent that activated the timer (if any).
    DropBarriers(Player : ?agent) : void =
        Barrier1.Disable()
        Barrier2.Disable()
        MidBarrier.Disable()

Line by line:

• box_fight_manager := class(creative_device): — our custom device. You compile it, then drag it into the level.
• The four @editable fields are the slots that appear in the Details panel. After compiling you click each one and pick the real placed barrier_device / timer_device in your map. Without @editable fields you cannot call a placed device from Verse.
• OnBegin<override>()<suspends>:void = runs once when the game experience starts. Note the 8-space indent for its body.
• Barrier1.Enable() (and the others) raise the walls right away so nobody escapes their box.
• Timer.SuccessEvent.Subscribe(DropBarriers) registers our handler. SuccessEvent is a listenable(?agent), so the handler must accept a ?agent.
• Timer.Start() begins the countdown.
• DropBarriers(Player : ?agent) : void = is the handler method (defined at class scope, 4-space indent). When the timer succeeds we Disable() each barrier, dropping all three cages so the fight can begin. We don't even need to unwrap Player here because we treat every barrier the same.

Common patterns

Let a single VIP walk through the wall

Use AddToIgnoreList so one chosen player can pass while the barrier still blocks everyone else. Here a button grants the player who pressed it a free pass through a barrier.

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

vip_gate := class(creative_device):

    @editable
    VaultBarrier : barrier_device = barrier_device{}

    # Pressing this button lets the presser through the barrier.
    @editable
    PassButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        VaultBarrier.Enable()
        PassButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    OnButtonPressed(Agent : agent) : void =
        # This agent now ignores the barrier; everyone else stays blocked.
        VaultBarrier.AddToIgnoreList(Agent)

InteractedWithEvent hands us a plain agent (not optional), so we can pass it straight into AddToIgnoreList.

Re-block a player after they pass

Grant access, then revoke it again with RemoveFromIgnoreList so they can't keep going back and forth. Here a trigger on the far side re-locks whoever crosses it.

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

one_way_gate := class(creative_device):

    @editable
    Gate : barrier_device = barrier_device{}

    # Placed just past the barrier.
    @editable
    ExitTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        Gate.Enable()
        ExitTrigger.TriggeredEvent.Subscribe(OnCrossed)

    # TriggeredEvent is listenable(?agent): unwrap before use.
    OnCrossed(Agent : ?agent) : void =
        if (Crosser := Agent?):
            # They made it through — re-block them so it's one-way.
            Gate.RemoveFromIgnoreList(Crosser)

TriggeredEvent is a listenable(?agent), so we unwrap with if (Crosser := Agent?): before calling RemoveFromIgnoreList.

Reset all exceptions when a new round starts

RemoveAllFromIgnoreList() wipes every individual exception in one call — ideal for a clean slate at round start.

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

round_resetter := class(creative_device):

    @editable
    ArenaBarrier : barrier_device = barrier_device{}

    # Fires at the top of every new round.
    @editable
    RoundStartButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        RoundStartButton.InteractedWithEvent.Subscribe(OnNewRound)

    OnNewRound(Agent : agent) : void =
        # Clear every per-player pass, then re-raise the wall.
        ArenaBarrier.RemoveAllFromIgnoreList()
        ArenaBarrier.Enable()

Gotchas

• You must declare the barrier as an @editable field. Calling barrier_device{}.Enable() on a bare value, or any Barrier.Method() where Barrier isn't an editable field linked to a placed device, fails with Unknown identifier or simply does nothing. Compile, then assign the real device in the Details panel.
• The ignore list does NOT stop bullets. AddToIgnoreList only lets an agent move through the barrier — they will still be blocked from shooting through it (and incoming fire is still blocked). The doc text is explicit: "Has no effect on bullets."
• AddToIgnoreList takes a plain agent, but timer/trigger events give you a ?agent. When you wire the ignore list to a listenable(?agent) event (like TriggeredEvent), unwrap first: if (A := Agent?): Barrier.AddToIgnoreList(A). Button InteractedWithEvent gives a non-optional agent, so no unwrap is needed there.
• RemoveFromIgnoreList / RemoveAllFromIgnoreList don't override team/class ignores. If a player is on an Ignore Team or Ignore Class configured in the device's options, removing them from the Verse ignore list won't re-block them — they'll still pass. The Verse list is additional to those panel settings.
• The barrier has no events. Unlike a trigger or timer, barrier_device exposes only methods. To react to something, subscribe to another device's event (a trigger, button, or timer) and call the barrier's methods from that handler.
• Enable()/Disable() are the on/off switch — there is no Show/Hide toggle for the wall itself. Disabling drops the wall entirely; enabling raises it. Don't confuse the barrier's collision with cosmetic visibility.