fire_volume_device: Lighting (and Putting Out) the Battlefield

Overview

The fire_volume_device marks out an area of your island where things can be set on fire. Think of it as the spatial controller for fire-based gameplay: a burning building you ignite when a boss spawns, a moat of flames that activates during the final circle, or a campfire zone players must avoid. You drag it into your scene, size its volume around the space you want to control, then drive it from Verse with four methods — Ignite, Extinguish, Enable, and Disable.

What makes this device especially powerful is its inheritance: fire_volume_device extends volume_device, so on top of the fire controls it also exposes volume-tracking events and queries. You can subscribe to AgentEntersEvent / AgentExitsEvent to react when a player walks into the fire zone, call GetAgentsInVolume() to count who is currently inside, or use IsInVolume(Agent) to test a specific player. That combination — control the fire + know who is in it — is exactly what you need to build trap rooms, escape sequences, and environmental hazards.

Reach for this device whenever fire is part of the gameplay loop rather than just decoration: a trigger should set the room alight, a plate should douse the flames, or you need to punish players for lingering in a danger zone.

API Reference

fire_volume_device

Used to specify an area which allows (or prevents) various objects, terrain, or buildings from being set on fire.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from effect_volume_device.

fire_volume_device<public> := class<concrete><final>(effect_volume_device):

Methods (call these to make the device act):

volume_device

Used to track when agents enter and exit a volume.

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

volume_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 burning trap room. When a player steps into the fire volume, the floor ignites. While they're inside the burning area, the fire stays lit. The moment the room is empty, the flames go out automatically. We also keep a button-style reset by re-enabling the device.

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

fire_trap_channel := class(log_channel){}

# A trap room that ignites when a player enters and douses when empty.
fire_trap_room := class(creative_device):

    Logger:log = log{Channel := fire_trap_channel}

    # The fire volume covering the trap room floor.
    @editable
    FireZone:fire_volume_device = fire_volume_device{}

    OnBegin<override>()<suspends>:void =
        # Make sure the device is active and the room starts unlit.
        FireZone.Enable()
        FireZone.Extinguish()

        # React when players cross the volume boundary.
        FireZone.AgentEntersEvent.Subscribe(OnPlayerEntered)
        FireZone.AgentExitsEvent.Subscribe(OnPlayerExited)

    # Called whenever an agent steps into the fire volume.
    OnPlayerEntered(Agent:agent):void =
        Logger.Print("A player entered the trap room — igniting!")
        FireZone.Ignite()

    # Called whenever an agent leaves the fire volume.
    OnPlayerExited(Agent:agent):void =
        # Count who is still inside before deciding to douse.
        Remaining := FireZone.GetAgentsInVolume()
        if (Remaining.Length = 0):
            Logger.Print("Room is empty — extinguishing.")
            FireZone.Extinguish()
        else:
            Logger.Print("Players still inside — fire stays lit.")

Line by line:

• fire_trap_channel := class(log_channel){} declares a log channel so our debug prints are tagged and easy to find in the output log.
• @editable FireZone:fire_volume_device = fire_volume_device{} is the field that links to the device you placed in the level. Without this @editable field you cannot call the device's methods — a bare FireZone.Ignite() on an undeclared name fails with Unknown identifier.
• In OnBegin, FireZone.Enable() guarantees the device responds to commands, and FireZone.Extinguish() sets a clean, unlit starting state.
• FireZone.AgentEntersEvent.Subscribe(OnPlayerEntered) wires the volume's enter event to our handler method. AgentEntersEvent is a listenable(agent), so the handler receives the entering agent directly.
• OnPlayerEntered calls FireZone.Ignite() — the room bursts into flames the instant someone walks in.
• OnPlayerExited calls FireZone.GetAgentsInVolume(), which returns []agent. We check .Length and only Extinguish() when the array is empty, so the fire keeps burning as long as anyone is still inside.

Common patterns

Boss arena: ignite on a timer, then douse

Use Ignite and Extinguish on a schedule to create a recurring lava-flare hazard the players must dodge.

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

lava_flare_channel := class(log_channel){}

lava_flare := class(creative_device):

    Logger:log = log{Channel := lava_flare_channel}

    @editable
    FireZone:fire_volume_device = fire_volume_device{}

    OnBegin<override>()<suspends>:void =
        FireZone.Enable()
        loop:
            FireZone.Ignite()
            Logger.Print("Flare ON")
            Sleep(3.0)
            FireZone.Extinguish()
            Logger.Print("Flare OFF")
            Sleep(5.0)

Safe-zone toggle: disable the fire entirely

When a round ends you may want the fire volume to stop responding at all. Disable turns the device off; Enable turns it back on for the next round.

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

fire_safe_toggle := class(creative_device):

    @editable
    FireZone:fire_volume_device = fire_volume_device{}

    # A volume the player steps into to declare the area safe.
    @editable
    SafeZone:volume_device = volume_device{}

    OnBegin<override>()<suspends>:void =
        FireZone.Enable()
        SafeZone.AgentEntersEvent.Subscribe(OnReachedSafety)

    OnReachedSafety(Agent:agent):void =
        # Stop the fire volume from affecting anything.
        FireZone.Extinguish()
        FireZone.Disable()

Per-player hazard check with IsInVolume

Use IsInVolume to test whether one specific agent is standing in the fire — handy for awarding a "survived the fire" bonus or applying logic only to the right player.

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

fire_check_channel := class(log_channel){}

fire_check := class(creative_device):

    Logger:log = log{Channel := fire_check_channel}

    @editable
    FireZone:fire_volume_device = fire_volume_device{}

    OnBegin<override>()<suspends>:void =
        FireZone.Enable()
        FireZone.Ignite()
        FireZone.AgentEntersEvent.Subscribe(OnEntered)

    OnEntered(Agent:agent):void =
        # IsInVolume is a <decides> query — it must run inside a failure context.
        if (FireZone.IsInVolume[Agent]):
            Logger.Print("This agent is confirmed inside the burning volume.")

Gotchas

• You must declare the device as an @editable field. Calling fire_volume_device{}.Ignite() or a bare name will not bind to the placed device. Declare @editable FireZone:fire_volume_device = fire_volume_device{} and link it in the Details panel.
• IsInVolume is <decides> — it does not return a logic. You must call it inside a failure context with square brackets: if (FireZone.IsInVolume[Agent]):. Using parentheses or treating it like a bool will not compile.
• GetAgentsInVolume() returns []agent, not a count. Use .Length to count, and remember the array reflects the current occupancy — query it inside your exit handler to decide whether to extinguish.
• Ignite only affects ignitable objects inside the volume. If nothing in the area is flammable (no props, terrain, or buildings set up to burn), calling Ignite does nothing visible. Place burnable objects inside the volume bounds.
• Enable / Disable gate everything. A disabled fire volume ignores Ignite and Extinguish and stops firing enter/exit events. If your fire commands seem to do nothing, confirm you called Enable() first.
• The agent from a listenable(agent) arrives already unwrapped. AgentEntersEvent hands your handler a plain agent (not ?agent), so you can use it directly — no if (A := Agent?) unwrap needed here, unlike listenable(?agent) events on other devices.