vehicle_spawner_octane_device: Rocket-Boosting Cars on Demand

Overview

The vehicle_spawner_octane_device spawns a single Octane — a lightweight rocket car built for boosting, jumping, and aerial maneuvers. You drop the spawner in your level, and it produces (and re-produces) an Octane at its location.

From Verse you get two kinds of control:

• Events that tell you what's happening: a vehicle spawned (SpawnedEvent), a player got in (AgentEntersVehicleEvent), got out (AgentExitsVehicleEvent), or the vehicle was destroyed (DestroyedEvent).
• Methods that make the device act: Enable/Disable, RespawnVehicle (replaces the current car with a fresh one), DestroyVehicle, and AssignDriver (forces an agent to become the driver).

Reach for this device when your game mode is built around a hero vehicle: a race where every player gets a fresh Octane at the start line, a "king of the hill" car that respawns when destroyed, or a stunt arena where stepping on a pad teleports you straight into the driver's seat. Because vehicle_spawner_octane_device extends the shared vehicle_spawner_device base class, every event and method below works identically on the dirtbike, helicopter, UFO, and other vehicle spawners too.

API Reference

vehicle_spawner_octane_device

Spawns a lightweight vehicle made for defying gravity with its rocket boosting, jumping, and aerial maneuverability capabilities.

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

vehicle_spawner_octane_device<public> := class<concrete><final>(vehicle_spawner_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

vehicle_spawner_device

Base class for various specialized vehicle spawners which allow specific vehicle types to be spawned and configured with specialized options.

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

vehicle_spawner_device<public> := class<abstract><epic_internal>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a respawning stunt car. We have an Octane spawner and a trigger pad. When the round begins we enable the spawner. When a player steps on the pad, we respawn a fresh Octane (in case the old one is wrecked or stuck) and assign that player as the driver — instant launch into the seat. We also track when players enter and leave, and we automatically respawn the car a moment after it's destroyed so the arena always has a ride.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Vehicles }
using { /Fortnite.com/Characters }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporal }

# A self-resetting Octane stunt arena.
stunt_arena := class(creative_device):

    # Drag your Octane spawner into this slot in the Details panel.
    @editable
    OctaneSpawner : vehicle_spawner_octane_device = vehicle_spawner_octane_device{}

    # A trigger pad players step on to claim the car.
    @editable
    ClaimPad : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Turn the spawner on so it produces an Octane.
        OctaneSpawner.Enable()

        # React when a player steps on the claim pad.
        ClaimPad.TriggeredEvent.Subscribe(OnClaimPadStepped)

        # React to the vehicle lifecycle.
        OctaneSpawner.SpawnedEvent.Subscribe(OnOctaneSpawned)
        OctaneSpawner.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)
        OctaneSpawner.AgentExitsVehicleEvent.Subscribe(OnDriverExited)
        OctaneSpawner.DestroyedEvent.Subscribe(OnOctaneDestroyed)

    # TriggeredEvent hands us an ?agent — unwrap it before use.
    OnClaimPadStepped(Agent : ?agent):void =
        if (Player := Agent?):
            # Give the arena a fresh car, then drop the player into it.
            OctaneSpawner.RespawnVehicle()
            OctaneSpawner.AssignDriver(Player)

    # SpawnedEvent sends the fort_vehicle that was created.
    OnOctaneSpawned(Vehicle : fort_vehicle):void =
        Print("A fresh Octane is ready in the arena!")

    OnDriverEntered(Driver : agent):void =
        Print("A player jumped into the Octane.")

    OnDriverExited(Driver : agent):void =
        Print("A player left the Octane.")

    # DestroyedEvent signals with an empty tuple — no payload.
    OnOctaneDestroyed():void =
        Print("Octane wrecked — respawning shortly.")
        spawn { RespawnAfterDelay() }

    RespawnAfterDelay()<suspends>:void =
        Sleep(3.0)
        OctaneSpawner.RespawnVehicle()

Line by line:

• The two @editable fields let you bind the real placed devices in the UEFN Details panel. The Octane field is typed vehicle_spawner_octane_device; the trigger is a trigger_device.
• In OnBegin, OctaneSpawner.Enable() makes sure the spawner is active and produces a car.
• We subscribe each event to a handler method declared at class scope. Subscriptions happen once in OnBegin.
• OnClaimPadStepped receives ?agent because TriggeredEvent is optional-agent. We unwrap with if (Player := Agent?). Then RespawnVehicle() guarantees a clean car and AssignDriver(Player) seats the player instantly.
• OnOctaneSpawned takes a fort_vehicle — the exact payload SpawnedEvent sends. We just confirm the car is ready.
• AgentEntersVehicleEvent/AgentExitsVehicleEvent send a non-optional agent, so no unwrap is needed.
• OnOctaneDestroyed takes no parameter because DestroyedEvent is listenable(tuple()). We spawn an async task that waits 3 seconds then respawns, keeping the arena stocked.

Common patterns

One-shot starting-line spawn (Disable after first use)

Give players a single car at the start, then disable the spawner so they can't farm extra Octanes.

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

start_line := class(creative_device):

    @editable
    OctaneSpawner : vehicle_spawner_octane_device = vehicle_spawner_octane_device{}

    @editable
    StartButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        OctaneSpawner.Enable()
        StartButton.InteractedWithEvent.Subscribe(OnStartPressed)

    OnStartPressed(Agent : agent):void =
        # Seat the racer, then lock the spawner so no more cars appear.
        OctaneSpawner.AssignDriver(Agent)
        OctaneSpawner.Disable()

Destroy the car when the round ends

Use DestroyVehicle to clear the Octane off the field — handy for resetting between rounds.

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

round_cleaner := class(creative_device):

    @editable
    OctaneSpawner : vehicle_spawner_octane_device = vehicle_spawner_octane_device{}

    @editable
    EndRoundPad : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        EndRoundPad.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundEnd(Agent : ?agent):void =
        # Remove the car from play and stop new ones from spawning.
        OctaneSpawner.DestroyVehicle()
        OctaneSpawner.Disable()

Count vehicle exits to award a "survivor" bonus

Track how many times players bail out of the car using AgentExitsVehicleEvent.

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

exit_counter := class(creative_device):

    @editable
    OctaneSpawner : vehicle_spawner_octane_device = vehicle_spawner_octane_device{}

    var ExitCount : int = 0

    OnBegin<override>()<suspends>:void =
        OctaneSpawner.Enable()
        OctaneSpawner.AgentExitsVehicleEvent.Subscribe(OnExit)

    OnExit(Agent : agent):void =
        set ExitCount = ExitCount + 1
        Print("Players have exited the Octane {ExitCount} times.")

Gotchas

• DestroyedEvent and VehicleSpawnedEvent carry no agent. They are listenable(tuple()), so their handler takes zero parameters — OnDestroyed():void, not OnDestroyed(X : tuple()). Trying to declare a payload here is a common compile error.
• SpawnedEvent sends a fort_vehicle, not an agent. The handler signature is (Vehicle : fort_vehicle). You'll need using { /Fortnite.com/Vehicles } for that type to resolve.
• AgentEntersVehicleEvent/AgentExitsVehicleEvent send a plain agent (not ?agent). Don't try to unwrap with Agent? — that only applies to optional-agent events like a trigger's TriggeredEvent.
• RespawnVehicle destroys the old car first. If a player is currently driving when you call it, their ride disappears and a new empty one appears. Pair it with AssignDriver if you want to re-seat them.
• AssignDriver needs a vehicle to exist. If the spawner is disabled or the car was destroyed and not respawned, there's nothing to seat the agent into — call RespawnVehicle() (or Enable()) first.
• Use the non-deprecated events. VehicleSpawnedEvent and VehicleDestroyedEvent still exist but are deprecated; prefer SpawnedEvent and DestroyedEvent.
• You can't call OctaneSpawner.Enable() on a bare type. The device must be an @editable field on a class(creative_device) and bound in the Details panel, or you'll get 'Unknown identifier'.
• spawn for delayed work. Calling Sleep inside a non-suspends event handler won't compile. Wrap delayed logic in a <suspends> helper and launch it with spawn { ... }, as in the walkthrough's respawn delay.