vehicle_spawner_rocketracing_device: Rocket Racing Vehicles Under Verse Control

Overview

The vehicle_spawner_rocketracing_device is a specialised vehicle_spawner_device that spawns the Rocket Racing car — the lightweight, rocket-boosting vehicle from Fortnite's Rocket Racing mode. Drop one into your island and you get a fully configurable vehicle that players can enter, drive, and destroy, all while your Verse code reacts to every state change.

When to reach for it:

• You're building a custom racing experience and need programmatic control over when vehicles appear.
• You want to auto-assign a specific player as driver (e.g. the race leader gets a power-up car).
• You need to respawn a vehicle at a fixed location after it's destroyed, without relying on the device's built-in timer.
• You want to gate the spawner behind a countdown, a trigger, or a score threshold.

Inheritance note: vehicle_spawner_rocketracing_device extends vehicle_spawner_device, which is the abstract base shared by every vehicle spawner in UEFN. All methods (Enable, Disable, AssignDriver, DestroyVehicle, RespawnVehicle) and all events (AgentEntersVehicleEvent, AgentExitsVehicleEvent, SpawnedEvent, DestroyedEvent) live on the base class and are available here.

API Reference

vehicle_spawner_rocketracing_device

Specialized vehicle_spawner_device that allows a Rocket Racing Vehicle to be configured and spawned.

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

vehicle_spawner_rocketracing_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

Scenario: Rocket Racing Pit Lane Manager

You have a race island. A trigger plate sits in the pit lane. When a player steps on it they are immediately assigned as driver of the Rocket Racing car. If the car is destroyed during the race, it respawns automatically. A second trigger disables the spawner entirely when the race ends.

This single device class wires up AgentEntersVehicleEvent, SpawnedEvent, DestroyedEvent, AssignDriver, RespawnVehicle, Enable, and Disable.

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

# Pit Lane Manager — auto-assigns driver, auto-respawns on destroy,
# and shuts the spawner down when the race ends.
pit_lane_manager := class(creative_device):

    # Wire this to your vehicle_spawner_rocketracing_device in the editor.
    @editable
    RocketCar : vehicle_spawner_rocketracing_device = vehicle_spawner_rocketracing_device{}

    # A trigger_device placed in the pit lane entry zone.
    @editable
    PitEntryTrigger : trigger_device = trigger_device{}

    # A trigger_device that fires when the race director ends the race.
    @editable
    RaceEndTrigger : trigger_device = trigger_device{}

    # Called at session start.
    OnBegin<override>()<suspends> : void =
        # Enable the spawner so it produces a vehicle immediately.
        RocketCar.Enable()

        # Subscribe to the pit-entry trigger so we can assign the driver.
        PitEntryTrigger.TriggeredEvent.Subscribe(OnPitEntryTriggered)

        # React when someone climbs in — great for HUD messages or telemetry.
        RocketCar.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)

        # React when someone climbs out.
        RocketCar.AgentExitsVehicleEvent.Subscribe(OnDriverExited)

        # React when the vehicle spawns or respawns — log the fort_vehicle.
        RocketCar.SpawnedEvent.Subscribe(OnVehicleSpawned)

        # Auto-respawn the car whenever it is destroyed.
        RocketCar.DestroyedEvent.Subscribe(OnVehicleDestroyed)

        # Shut everything down when the race ends.
        RaceEndTrigger.TriggeredEvent.Subscribe(OnRaceEnded)

    # Pit entry trigger fired — the triggering agent becomes the driver.
    OnPitEntryTriggered(Agent : ?agent) : void =
        if (A := Agent?):
            # AssignDriver seats the agent in the vehicle immediately.
            RocketCar.AssignDriver(A)

    # Log (or react to) a driver entering the vehicle.
    OnDriverEntered(Agent : agent) : void =
        # AgentEntersVehicleEvent sends a plain agent (not optional).
        # Add your race-start logic here, e.g. start a lap timer.
        Print("Driver entered the Rocket Racing car.")

    # Log (or react to) a driver leaving the vehicle.
    OnDriverExited(Agent : agent) : void =
        Print("Driver exited the Rocket Racing car.")

    # SpawnedEvent sends the fort_vehicle that was just created.
    OnVehicleSpawned(Vehicle : fort_vehicle) : void =
        # You now hold a reference to the live vehicle.
        # Use it with other fort_vehicle APIs if needed.
        Print("Rocket Racing car spawned or respawned.")

    # DestroyedEvent fires with no payload — just respawn.
    OnVehicleDestroyed(Unused : tuple()) : void =
        # RespawnVehicle destroys any remnant and spawns a fresh one.
        RocketCar.RespawnVehicle()

    # Race is over — disable the spawner so no new vehicles appear.
    OnRaceEnded(Agent : ?agent) : void =
        RocketCar.Disable()```

**Line-by-line highlights:**

| Line / call | What it does |
|---|---|
| `RocketCar.Enable()` | Activates the spawner at session start so a vehicle appears immediately. |
| `PitEntryTrigger.TriggeredEvent.Subscribe(OnPitEntryTriggered)` | Listens for a player stepping into the pit zone. |
| `RocketCar.AssignDriver(A)` | Seats the unwrapped agent in the car — no player interaction required. |
| `RocketCar.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)` | Fires every time any agent gets in; payload is a plain `agent`. |
| `RocketCar.SpawnedEvent.Subscribe(OnVehicleSpawned)` | Fires on first spawn AND every respawn; payload is the live `fort_vehicle`. |
| `RocketCar.DestroyedEvent.Subscribe(OnVehicleDestroyed)` | Fires when the vehicle is destroyed; payload is `tuple()` (empty). |
| `RocketCar.RespawnVehicle()` | Destroys any remnant and spawns a fresh vehicle at the spawner's location. |
| `RocketCar.Disable()` | Prevents any further vehicles from spawning for the rest of the session. |

---

## Common patterns

### Pattern 1 — Countdown gate (Enable after a delay)

Keep the spawner disabled until a 5-second countdown finishes, then let the vehicle appear.

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

countdown_gate := class(creative_device):

    @editable
    RocketCar : vehicle_spawner_rocketracing_device = vehicle_spawner_rocketracing_device{}

    OnBegin<override>()<suspends> : void =
        # Start disabled — no vehicle yet.
        RocketCar.Disable()

        # Wait for the countdown.
        Sleep(5.0)

        # Now enable — the spawner produces a vehicle.
        RocketCar.Enable()

Pattern 2 — Destroy the vehicle on a button press

A button in the world lets a race director instantly remove the current vehicle (e.g. to reset a track incident).

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

director_reset := class(creative_device):

    @editable
    RocketCar : vehicle_spawner_rocketracing_device = vehicle_spawner_rocketracing_device{}

    # A button_device placed in the director booth.
    @editable
    ResetButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        ResetButton.InteractedWithEvent.Subscribe(OnResetPressed)

    OnResetPressed(Agent : agent) : void =
        # Immediately removes the vehicle from the world.
        RocketCar.DestroyVehicle()

Pattern 3 — Track which vehicle is live using SpawnedEvent

Capture the fort_vehicle reference every time the car spawns so you can pass it to other systems (e.g. a leaderboard or a camera rig).

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

vehicle_tracker := class(creative_device):

    @editable
    RocketCar : vehicle_spawner_rocketracing_device = vehicle_spawner_rocketracing_device{}

    # Mutable reference to the current live vehicle.
    var CurrentVehicle : ?fort_vehicle = false

    OnBegin<override>()<suspends> : void =
        RocketCar.SpawnedEvent.Subscribe(OnSpawned)
        RocketCar.DestroyedEvent.Subscribe(OnDestroyed)

    # SpawnedEvent payload is the fort_vehicle — store it.
    OnSpawned(Vehicle : fort_vehicle) : void =
        set CurrentVehicle = option{Vehicle}

    # Vehicle gone — clear the reference.
    OnDestroyed(Unused : tuple()) : void =
        set CurrentVehicle = false

Gotchas

1. @editable is mandatory — you cannot construct the device in code

You MUST declare RocketCar as an @editable field inside your class(creative_device) and wire it to a placed device in the UEFN editor. Writing vehicle_spawner_rocketracing_device{} as a standalone local variable gives you a default-constructed object that has no connection to the world and calling methods on it does nothing visible.

2. Event payload types differ between events

Do not try to unwrap agent from AgentEntersVehicleEvent with if (A := Agent?) — the payload is already a concrete agent, not ?agent. The ?agent pattern applies to trigger-style events like trigger_device.TriggeredEvent.

3. VehicleSpawnedEvent and VehicleDestroyedEvent are deprecated

As of UEFN 25.00, use SpawnedEvent (which gives you the fort_vehicle) and DestroyedEvent instead. The deprecated events still compile but carry no useful payload and will eventually be removed.

4. RespawnVehicle destroys the current vehicle first

Calling RespawnVehicle() when a vehicle already exists will destroy it before spawning a new one. This triggers DestroyedEvent. If you subscribe to DestroyedEvent to call RespawnVehicle(), you will get exactly one respawn per destruction — not an infinite loop — because the new vehicle hasn't been destroyed yet.

5. AssignDriver requires the vehicle to already exist

If you call AssignDriver before the spawner has produced a vehicle (e.g. before SpawnedEvent fires), the call is silently ignored. Either call it inside your OnSpawned handler or after a Sleep long enough for the vehicle to appear.

6. Disable does not destroy the current vehicle

Calling Disable() prevents the spawner from producing new vehicles but leaves any existing vehicle in the world. If you want to remove the vehicle AND prevent respawning, call DestroyVehicle() followed by Disable().