fuel_pump_device: Powering Up Vehicles with Verse

Overview

The fuel_pump_device serves two roles in UEFN creative maps:

1. Fuel source — players drive a vehicle up to it and refuel, just like a real gas station.
2. Environmental hazard — when destroyed, it deals significant damage to nearby agents and structures, making it a high-value target in PvP maps.

From Verse you can:

• Enable / Disable the pump (e.g., lock pumps behind a quest objective).
• Empty the pump programmatically, instantly granting fuel to a specific agent (the method is named Empty because it empties the pump's stock into the vehicle).
• Subscribe to EmptyEvent to react whenever a player empties the pump — award points, start a countdown, or spawn enemies.

Reach for this device whenever your map has vehicles that consume fuel and you want Verse logic to gate, reward, or react to refueling.

API Reference

fuel_pump_device

Used to provide fuel sources for vehicles. Can also be used to deal considerable damage to agents and the environment when destroyed.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A survival race map. Three fuel pumps are scattered around the track. When a player empties any pump, a 30-second countdown starts and all remaining pumps are disabled — forcing other players to scramble before fuel runs out. The player who triggered the pump gets a free refuel via Empty.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Vehicles }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Attach this Verse device to your island.
# Wire up PumpA, PumpB, PumpC in the Details panel.
fuel_race_manager := class(creative_device):

    # ---- Editable fields — wire these in the UEFN Details panel ----
    @editable
    PumpA : fuel_pump_device = fuel_pump_device{}

    @editable
    PumpB : fuel_pump_device = fuel_pump_device{}

    @editable
    PumpC : fuel_pump_device = fuel_pump_device{}

    # Tracks whether the lockdown has already been triggered
    var LockdownActive : logic = false

    # ---- Lifecycle ----
    OnBegin<override>()<suspends> : void =
        # Subscribe to each pump's EmptyEvent
        PumpA.EmptyEvent.Subscribe(OnPumpEmptied)
        PumpB.EmptyEvent.Subscribe(OnPumpEmptied)
        PumpC.EmptyEvent.Subscribe(OnPumpEmptied)

    # ---- Event handler — fires when any pump is emptied ----
    # EmptyEvent is listenable(agent), so the handler receives an agent directly
    OnPumpEmptied(Refueler : agent) : void =
        # Only trigger lockdown once
        if (LockdownActive = false):
            set LockdownActive = true
            # Disable all pumps so no one else can refuel normally
            PumpA.Disable()
            PumpB.Disable()
            PumpC.Disable()
            # Immediately grant a bonus refuel to the triggering player
            # Empty() "empties" the pump's stock into the agent's vehicle
            PumpA.Empty(Refueler)
            # Re-enable pumps after 30 seconds (run async)
            spawn { ReenablePumpsAfterDelay() }

    # ---- Async helper — waits 30 s then re-enables all pumps ----
    ReenablePumpsAfterDelay()<suspends> : void =
        Sleep(30.0)
        PumpA.Enable()
        PumpB.Enable()
        PumpC.Enable()
        set LockdownActive = false

Line-by-line breakdown:

Common patterns

Pattern 1 — Enable / Disable based on a quest flag

Lock the fuel pump until players complete an objective (e.g., capture a point). Wire a trigger_device to signal quest completion.

using { /Fortnite.com/Devices }

# Fuel pump starts DISABLED in the Details panel.
# Only the trigger (wired to a capture zone) can unlock it.
fuel_pump_quest_gate := class(creative_device):

    @editable
    QuestPump : fuel_pump_device = fuel_pump_device{}

    @editable
    ObjectiveTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Pump is disabled at start; wait for the objective trigger
        ObjectiveTrigger.TriggeredEvent.Subscribe(OnObjectiveComplete)

    OnObjectiveComplete(Activator : ?agent) : void =
        # Unlock the pump so vehicles can now refuel
        QuestPump.Enable()

Key point: Set the pump's Enabled at Game Start property to false in the Details panel, then call Enable() from Verse when the condition is met. Disable() works the same way in reverse — use it to shut the pump off after a time limit expires.

Pattern 2 — React to EmptyEvent and award score

Every time any player empties a pump, award them points via a score manager. Demonstrates subscribing to EmptyEvent and using the returned agent.

using { /Fortnite.com/Devices }

# Award points whenever a player refuels from the pump.
fuel_score_tracker := class(creative_device):

    @editable
    TrackPump : fuel_pump_device = fuel_pump_device{}

    @editable
    ScoreDevice : score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends> : void =
        TrackPump.EmptyEvent.Subscribe(OnRefuelScored)

    # EmptyEvent sends the agent who emptied the pump
    OnRefuelScored(Scorer : agent) : void =
        # Award 500 points to the refueling player
        ScoreDevice.Activate(Scorer)

Key point: EmptyEvent is listenable(agent) — the handler signature is (Scorer : agent), not (Scorer : ?agent). No option unwrapping is needed.

Pattern 3 — Force-grant fuel to all players on round start

At the start of a new round, call Empty() on every registered player so everyone begins with a full tank.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Game }

# Grants fuel to every player when the round manager fires RoundBeginEvent.
fuel_round_start := class(creative_device):

    @editable
    ServicePump : fuel_pump_device = fuel_pump_device{}

    @editable
    RoundManager : round_settings_device = round_settings_device{}

    OnBegin<override>()<suspends> : void =
        RoundManager.RoundBeginEvent.Subscribe(OnRoundBegin)

    OnRoundBegin(RoundIndex : int) : void =
        # GetPlayspace().GetPlayers() returns all current players
        AllPlayers := GetPlayspace().GetPlayers()
        for (Player : AllPlayers):
            # Empty() grants fuel to each player's vehicle
            ServicePump.Empty(Player)

Key point: Empty(Agent : agent) takes any agent — iterate GetPlayspace().GetPlayers() to hit every player at once. This is useful for race restarts or respawn sequences.

Gotchas

1. Empty() grants fuel, it doesn't drain it

Despite the name, Empty(Agent) empties the pump's stock into the agent's vehicle — it's a refuel operation from the pump's perspective. Don't confuse it with "draining" the player's fuel. If you want to monitor when fuel runs out on the vehicle side, use fort_vehicle.GetFuelRemaining() in a polling loop.

2. EmptyEvent is listenable(agent), not listenable(?agent)

The handler signature must be (Refueler : agent) — no option type, no if (A := Agent?) unwrap. Writing (?agent) will cause a compile error.

3. You MUST declare the device as an @editable field

You cannot write fuel_pump_device{}.Enable() inline. The device must be an @editable field inside your class(creative_device) and wired to a placed actor in the UEFN Details panel. A bare identifier without the field declaration produces an Unknown identifier compile error.

4. Reset() is in the digest but not in the original API surface list

The live digest exposes a Reset() method that resets the pump's stock to its Fuel Capacity setting. It is available and safe to call, but double-check the current digest before shipping — use it to restore a pump after calling Empty() programmatically.

5. Pump must be enabled to respond to player interaction

Calling Disable() prevents players from driving up and refueling normally, but Empty(Agent) called from Verse still works on a disabled pump. This is intentional — it lets you grant fuel as a reward without re-exposing the pump to general use.

6. The pump is a destructible hazard — account for it in your layout

A destroyed fuel_pump_device deals heavy damage to nearby agents and the environment. If your Verse logic depends on the pump being present (e.g., you call Enable() after a delay), consider placing it out of reach of combat or using a barrier device to protect it.