bank_vault_device: Heist Doors That Crack Open on Cue

Overview

The bank_vault_device is a vault door built around a weakpoint sequence. When the sequence starts, weakpoints begin to glow; once they become vulnerable, players damage them, and when enough are destroyed (or an event force-opens it) the vault opens. It implements bank_vault_interface, which is where its real Verse surface lives.

Reach for it when you want a heist objective: a defended door that gates a loot room, a boss vault that opens only after a phase, or a co-op puzzle where a whole squad must focus fire on the weakpoints together. Unlike a plain trigger, the vault tracks an internal multi-stage state for you — you just subscribe to the stages and decide what they mean for your game.

Key Verse pieces you'll use:

• OpenEvent — fires when the vault opens, sending the last agent that damaged a weakpoint (or false if a function opened it).
• ActivateWeakpointEvent — fires when a weakpoint starts glowing, sending the agent and the weakpoint index.
• PauseSequence() / Reset() — freeze or restore the vault.
• IsSequenceActive[] and GetWeakpointCount() — query state.

Because OpenEvent hands you a ?agent, you always unwrap it before rewarding a player.

API Reference

bank_vault_device

A vault door that requires a start of a sequence to damage a number of weakpoints to open.

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

bank_vault_device<public> := class<concrete><final>(creative_device_base, bank_vault_interface):

Walkthrough

Let's build a complete heist beat. When a player steps on a start trigger, we kick off the vault sequence. Every time a weakpoint activates we play a cinematic flash and bump a score. When the vault opens, we grant the cracker some points and teleport them into the loot room. We also wire a panic button that pauses the sequence (guards arrived!).

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

heist_manager := class(creative_device):

    # The vault door itself.
    @editable
    Vault : bank_vault_device = bank_vault_device{}

    # Player steps here to begin the heist.
    @editable
    StartTrigger : trigger_device = trigger_device{}

    # Guards arrive — pressing this pauses the weakpoints.
    @editable
    PanicButton : button_device = button_device{}

    # Cinematic sting that plays when a weakpoint lights up.
    @editable
    WeakpointFlash : cinematic_sequence_device = cinematic_sequence_device{}

    # Awards points to the player who cracks the vault.
    @editable
    ScoreManager : score_manager_device = score_manager_device{}

    # Drops the cracker into the loot room.
    @editable
    LootRoomTeleporter : teleporter_device = teleporter_device{}

    # Localized helper so we can pass message-typed text.
    Announce<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Begin the heist when someone steps on the start pad.
        StartTrigger.TriggeredEvent.Subscribe(OnStartHeist)
        # React to each weakpoint lighting up.
        Vault.ActivateWeakpointEvent.Subscribe(OnWeakpointActivated)
        # React when the vault finally opens.
        Vault.OpenEvent.Subscribe(OnVaultOpened)
        # Guards arrive — freeze the weakpoints.
        PanicButton.InteractedWithEvent.Subscribe(OnPanic)

    # The trigger hands us a ?agent; unwrap before using.
    OnStartHeist(Agent : ?agent) : void =
        if (Player := Agent?):
            # Force-start the vault's weakpoint sequence.
            Vault.Activate()
            Print("Heist started — weakpoints are now live!")

    # Sends the agent that activated it and the weakpoint index 0-4.
    OnWeakpointActivated(Agent : ?agent, Index : int) : void =
        Print("Weakpoint {Index} is glowing!")
        # Play the cinematic flash for everyone.
        WeakpointFlash.Play()
        # Bump a shared progress score per weakpoint hit.
        if (Player := Agent?):
            ScoreManager.Activate(Player)

    # OpenEvent sends a ?agent: the last damager, or false if a function opened it.
    OnVaultOpened(Agent : ?agent) : void =
        if (Cracker := Agent?):
            Print("Vault cracked by a player — paying out.")
            # Reward the cracker.
            ScoreManager.Activate(Cracker)
            # Whisk them into the loot room.
            LootRoomTeleporter.Teleport(Cracker)
        else:
            Print("Vault opened by a scripted event — no instigator.")

    OnPanic(Agent : agent) : void =
        # Freeze weakpoint vulnerability until the coast is clear.
        Vault.PauseSequence()
        Print("Guards inbound — weakpoints frozen!")

Line by line:

• Every placed device is an @editable field so you can bind it in the Details panel. A bare Vault.Activate() outside a creative_device class would fail with Unknown identifier — the field is what makes it real.
• In OnBegin we subscribe all our handlers. TriggeredEvent and OpenEvent are listenable(?agent), so their handlers take (Agent : ?agent). ActivateWeakpointEvent adds the int index. InteractedWithEvent on a button hands a plain agent.
• OnStartHeist unwraps Agent? with if (Player := Agent?): before calling Vault.Activate(), which force-starts the weakpoint sequence.
• OnWeakpointActivated plays a cinematic and adds a point — the Index lets you tailor feedback per weakpoint (e.g. a louder sting on the last one).
• OnVaultOpened distinguishes a player-cracked vault (Cracker := Agent? succeeds) from a function-opened one (Agent? fails, else branch). Only a real agent gets rewarded and teleported.
• OnPanic calls PauseSequence() so weakpoints stop taking damage — a clean way to gate the heist behind a defense phase.

Common patterns

Pattern 1 — Query state and reset the vault for a new round. Use IsSequenceActive[] (a <decides> query, so it needs []) and Reset() to recycle the vault between rounds.

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

vault_round_resetter := class(creative_device):

    @editable
    Vault : bank_vault_device = bank_vault_device{}

    # Pressed by the host to start a fresh heist round.
    @editable
    NewRoundButton : button_device = button_device{}

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

    OnNewRound(Agent : agent) : void =
        # Only reset if a sequence is actually running.
        if (Vault.IsSequenceActive[]):
            Print("Sequence active — resetting vault to default.")
        # Reset heals all weakpoints and deactivates the device.
        Vault.Reset()
        Print("Vault is ready for a new round.")

Pattern 2 — Count the weakpoints to drive a progress display. GetWeakpointCount() returns the total so you can announce "Crack 5 weakpoints".

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

vault_briefing := class(creative_device):

    @editable
    Vault : bank_vault_device = bank_vault_device{}

    @editable
    Billboard : hud_message_device = hud_message_device{}

    Brief<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        Total := Vault.GetWeakpointCount()
        Print("This vault has {Total} weakpoints.")
        Billboard.SetText(Brief("Destroy all weakpoints to crack the vault!"))
        Billboard.Show()

Pattern 3 — Open the vault for a story beat, then pause future damage. Subscribe to OpenEvent and freeze the door once it's done.

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

vault_finale := class(creative_device):

    @editable
    Vault : bank_vault_device = bank_vault_device{}

    @editable
    VictoryCinematic : cinematic_sequence_device = cinematic_sequence_device{}

    OnBegin<override>()<suspends> : void =
        Vault.OpenEvent.Subscribe(OnOpened)

    OnOpened(Agent : ?agent) : void =
        # Play the heist-complete cinematic for everyone.
        VictoryCinematic.Play()
        # Stop any further weakpoint interaction.
        Vault.PauseSequence()
        Print("Vault open — finale rolling.")

Gotchas

• OpenEvent is listenable(?agent), not listenable(agent). When a function (like Activate()) opens the vault, there is no instigator and you receive false. Always if (P := Agent?): before rewarding — the else branch is your scripted-open case.
• Weakpoints are only vulnerable while the sequence is active. If you call PauseSequence(), damage stops registering. Players hitting a frozen weakpoint will see nothing happen — re-Activate() or Reset() to recover.
• IsSequenceActive[] and GetActiveWeakpointIndex[] are <decides> queries. They fail rather than return a bool, so call them inside an if (...) with square brackets, never as if (Vault.IsSequenceActive()).
• Reset() requires the device to be enabled. Calling it on a disabled vault does nothing; enable the device first in the Details panel or via its base controls.
• Localized text, not raw strings. Any message parameter (HUD billboards, etc.) needs a <localizes> helper like Brief<localizes>(S:string):message = "{S}". There is no StringToMessage.
• Bind the field in UEFN. Vault : bank_vault_device = bank_vault_device{} is just a default placeholder — you must drop the actual vault into the device's slot in the Details panel, or your handlers will fire on nothing.