hiding_prop_device: Stealth Spots, Hidden Travel & Forced Ejects

Overview

The hiding_prop_device gives players a place to physically hide inside a prop (think a hollow rock, a barrel, or a bush). Players can enter the prop, become invisible to seekers, and — if you link multiple hiding props — perform a Hidden Travel that teleports them from one prop to another while staying concealed.

Reach for this device when you are building:

• A hide-and-seek or Prop Hunt-style mode where hiders dive into cover.
• A stealth escape network where players tunnel between linked hiding spots.
• A trap mechanic where a seeker can force-eject hiders from their hiding place.

In Verse you get three events to react to (BeginPlayerHideEvent, EndPlayerHideEvent, PlayerHiddenTravelEvent) and three methods to drive the device (EjectHiddenPlayer, EjectAllHiddenPlayers, HideNearbyPlayers). Because it inherits enableable, you can also Enable()/Disable() it to open and close the hiding spot during a round.

API Reference

hiding_prop_device

The hiding prop device can be used to give players a place to hide, or to allow players a special way to commence a Hidden Travel to another Hiding prop.

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

hiding_prop_device<public> := class<concrete><final>(creative_device_base, enableable):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a small hide-and-seek round. We have a hiding prop (the hiders' bush). When a player hides, we award a point in our scoreboard message and start a 15-second timer for that prop. When the timer ends, we forcibly eject every hidden player — the bush "collapses" and everyone tumbles out. We also react when a player leaves on their own, and when a player completes a hidden travel to another prop.

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

hide_and_seek_round := class(creative_device):

    # The bush/rock/barrel players dive into.
    @editable
    HideSpot : hiding_prop_device = hiding_prop_device{}

    # Localized text helper: 'message' params need a localized value, not a raw string.
    HideMessage<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # React when someone climbs into the prop.
        HideSpot.BeginPlayerHideEvent.Subscribe(OnPlayerHid)
        # React when someone leaves the prop on their own.
        HideSpot.EndPlayerHideEvent.Subscribe(OnPlayerLeft)
        # React when a player tunnels to another linked hiding prop.
        HideSpot.PlayerHiddenTravelEvent.Subscribe(OnHiddenTravel)

    # listenable(player) hands the handler a 'player' directly.
    OnPlayerHid(Player : player) : void =
        Print("A player started hiding!")
        # Kick off a coroutine that ejects everyone after a delay.
        spawn { CollapseAfterDelay() }

    OnPlayerLeft(Player : player) : void =
        Print("A player left the hiding spot.")

    # PlayerHiddenTravelEvent carries a tuple(player, hiding_prop_device).
    OnHiddenTravel(Result : tuple(player, hiding_prop_device)) : void =
        TravelingPlayer := Result(0)
        DestinationProp := Result(1)
        Print("A hidden player traveled to another prop!")

    # After 15 seconds the bush collapses and spits everyone out.
    CollapseAfterDelay()<suspends> : void =
        Sleep(15.0)
        # EjectAllHiddenPlayers returns the array of players that were ejected.
        EjectedPlayers := HideSpot.EjectAllHiddenPlayers()
        Print("The hiding spot collapsed! Ejected {EjectedPlayers.Length} players.")

Line by line:

• @editable HideSpot : hiding_prop_device — you MUST declare the placed device as an @editable field so Verse can reference it. After building, you drop the real prop into this slot in the device's Details panel.
• HideMessage<localizes>(S:string):message — the canonical way to make a message from a string. Several device fields (and UI) require message, never a raw string.
• In OnBegin we Subscribe to all three events. Each handler is a method at class scope, passed by name.
• BeginPlayerHideEvent / EndPlayerHideEvent are listenable(player), so their handlers receive a player directly — no ?agent unwrap needed here.
• PlayerHiddenTravelEvent is listenable(tuple(player, hiding_prop_device)), so the handler takes a tuple. We pull the player out with Result(0) and the destination prop with Result(1).
• CollapseAfterDelay is a <suspends> coroutine launched with spawn. After Sleep(15.0), it calls EjectAllHiddenPlayers(), which both ejects everyone AND returns the array of ejected players so we can count them.

Common patterns

Sweep nearby players into cover with HideNearbyPlayers

Maybe a "smoke bomb" button instantly hides everyone standing close to the prop. HideNearbyPlayers takes a distance in meters and respects the prop's MaxNumberOfOccupants setting.

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

smoke_bomb_device := class(creative_device):

    @editable
    HideSpot : hiding_prop_device = hiding_prop_device{}

    @editable
    SmokeButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        SmokeButton.InteractedWithEvent.Subscribe(OnSmokeUsed)

    OnSmokeUsed(Agent : agent) : void =
        # Hide every player within 5 meters of the prop.
        Hidden := HideSpot.HideNearbyPlayers(5.0)
        Print("Smoke bomb hid {Hidden.Length} players!")

Eject one specific player with EjectHiddenPlayer

A seeker who finds a hider can force just that one player out. EjectHiddenPlayer is <decides>, so it can fail (e.g. the player isn't actually hiding here) — call it inside an if.

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

seeker_tag_device := class(creative_device):

    @editable
    HideSpot : hiding_prop_device = hiding_prop_device{}

    # Remember the last player who hid so we can eject them.
    var LastHider : ?player = false

    OnBegin<override>()<suspends> : void =
        HideSpot.BeginPlayerHideEvent.Subscribe(OnPlayerHid)

    OnPlayerHid(Player : player) : void =
        set LastHider = option{Player}

    # Call this (e.g. from another event) to flush the last hider out.
    EjectLastHider() : void =
        if (Target := LastHider?):
            # <decides>: wrap in 'if' because the eject may fail.
            if (HideSpot.EjectHiddenPlayer[Target]):
                Print("Seeker forced a hider out!")

Toggle the hiding spot open and closed with enableable

Because hiding_prop_device is enableable, you can lock the hideout during a "seek" phase and reopen it for the next round.

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

round_phase_device := class(creative_device):

    @editable
    HideSpot : hiding_prop_device = hiding_prop_device{}

    OnBegin<override>()<suspends> : void =
        # Hide phase: spot is open for 20 seconds.
        HideSpot.Enable()
        Sleep(20.0)
        # Seek phase: eject everyone, then close the spot.
        HideSpot.EjectAllHiddenPlayers()
        HideSpot.Disable()

Gotchas

• EjectHiddenPlayer is <decides>. Its signature is EjectHiddenPlayer(Player:player)<transacts><decides>:void. You must call it in a failure context — if (HideSpot.EjectHiddenPlayer[Target]): with square brackets — not as a plain statement. Calling it bare won't compile.
• HideNearbyPlayers and EjectAllHiddenPlayers return arrays you can ignore or use. HideNearbyPlayers takes a float distance in METERS, not centimeters — passing 500.0 would mean 500 meters, not 5. Verse won't auto-convert int to float, so write 5.0, never 5.
• MaxNumberOfOccupants caps HideNearbyPlayers. Even if 10 players stand close, only as many as the prop allows will be hidden; the returned array tells you who actually got in.
• Event payload shapes differ. BeginPlayerHideEvent/EndPlayerHideEvent give a plain player. PlayerHiddenTravelEvent gives a tuple(player, hiding_prop_device) — index it with Result(0) and Result(1). Don't expect a ?agent here; these are non-optional payloads.
• message is not a string. Any device field or UI call that wants a message needs a localized value. Use a <localizes> helper like HideMessage(S:string):message = "{S}". There is no StringToMessage.
• You must place and assign the device. A bare hiding_prop_device{} default is just a placeholder — link the actual placed prop in the Details panel, or the events never fire.