vehicle_spawner_sports_car_device: Whiplash on Demand

Overview

The vehicle_spawner_sports_car_device is a specialized vehicle spawner that places a Whiplash sports car on your island. It inherits everything from the abstract vehicle_spawner_device, so the same methods and events you learn here apply to every vehicle spawner (sedan, taxi, UFO, big rig, and so on).

Reach for this device when your game needs a fast ground vehicle on demand: a heist getaway car, a racing checkpoint that respawns a fresh car, a reward for a quest, or an arena hazard you destroy on a timer. From Verse you can:

• RespawnVehicle() — make a fresh car appear (the old one is removed first).
• DestroyVehicle() — blow it up.
• AssignDriver(Agent) — drop a specific player straight into the driver's seat.
• Enable() / Disable() — turn the spawner on or off.
• React to SpawnedEvent, DestroyedEvent, AgentEntersVehicleEvent, and AgentExitsVehicleEvent to wire up game logic.

Because this is a real placed device, you must expose it as an @editable field in your creative_device class and link it to the placed spawner in the UEFN Details panel.

API Reference

vehicle_spawner_sports_car_device

Specialized vehicle_spawner_device that allows a Whiplash sports car 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_sports_car_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 getaway-car heist station. A button spawns a fresh Whiplash and assigns the interacting player as its driver. Whenever a player enters the car we track them, and when the car is destroyed we automatically respawn a replacement after a short delay.

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

# A heist getaway station built around the Whiplash sports car spawner.
heist_getaway_station := class(creative_device):

    # Link these to the placed devices in the UEFN Details panel.
    @editable
    CarSpawner : vehicle_spawner_sports_car_device = vehicle_spawner_sports_car_device{}

    @editable
    CallCarButton : button_device = button_device{}

    # How long to wait before auto-respawning a destroyed car.
    @editable
    RespawnDelay : float = 5.0

    OnBegin<override>()<suspends>:void =
        # When the button is pressed, spawn a car and put the presser in it.
        CallCarButton.InteractedWithEvent.Subscribe(OnCallCar)

        # React to the car's own lifecycle and seat events.
        CarSpawner.SpawnedEvent.Subscribe(OnCarSpawned)
        CarSpawner.DestroyedEvent.Subscribe(OnCarDestroyed)
        CarSpawner.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)
        CarSpawner.AgentExitsVehicleEvent.Subscribe(OnDriverExited)

    # Button handler: a button always hands us a real agent.
    OnCallCar(Agent : agent):void =
        # Spawn a fresh Whiplash (destroys any previous car first)...
        CarSpawner.RespawnVehicle()
        # ...then drop the presser straight into the driver's seat.
        CarSpawner.AssignDriver(Agent)

    # SpawnedEvent hands us the fort_vehicle that was created.
    OnCarSpawned(Vehicle : fort_vehicle):void =
        Print("A Whiplash sports car has spawned!")

    # DestroyedEvent is a tuple() event — no payload.
    OnCarDestroyed():void =
        Print("Car destroyed — respawning shortly.")
        spawn { AutoRespawn() }

    # AgentEntersVehicleEvent sends the agent that climbed in.
    OnDriverEntered(Agent : agent):void =
        Print("A player got behind the wheel.")

    # AgentExitsVehicleEvent sends the agent that climbed out.
    OnDriverExited(Agent : agent):void =
        Print("A player left the car.")

    # Async helper: wait, then bring a new car back.
    AutoRespawn()<suspends>:void =
        Sleep(RespawnDelay)
        CarSpawner.RespawnVehicle()```

**Line by line:**

- `CarSpawner : vehicle_spawner_sports_car_device` — the `@editable` field is how Verse references your placed spawner. The `= vehicle_spawner_sports_car_device{}` is just a default so the file compiles; in UEFN you bind it to the real device.
- `OnBegin<override>()<suspends>:void` — runs once when the game starts. All subscriptions are set up here.
- `CallCarButton.InteractedWithEvent.Subscribe(OnCallCar)` — wires the button press to our handler.
- `CarSpawner.RespawnVehicle()` — spawns a fresh Whiplash, removing any existing one. This is what guarantees the driver gets a brand-new car.
- `CarSpawner.AssignDriver(Agent)` — places that specific player directly in the driver's seat. No walking up required.
- `SpawnedEvent.Subscribe(OnCarSpawned)` — `OnCarSpawned` receives a `fort_vehicle`, the actual spawned vehicle object.
- `DestroyedEvent.Subscribe(OnCarDestroyed)` — this event carries **no payload** (`tuple()`), so the handler takes no parameters.
- `spawn { AutoRespawn() }` — launches the async respawn helper without blocking the destroy handler.
- `Sleep(RespawnDelay)` then `RespawnVehicle()` — waits five seconds, then a fresh car returns.

## Common patterns

### Disable the spawner until the match starts

Keep the car locked away, then enable the spawner when a starting trigger fires.

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

race_start_gate := class(creative_device):

    @editable
    CarSpawner : vehicle_spawner_sports_car_device = vehicle_spawner_sports_car_device{}

    @editable
    StartTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Lock the car away at the start of the match.
        CarSpawner.Disable()
        StartTrigger.TriggeredEvent.Subscribe(OnRaceStart)

    OnRaceStart(MaybeAgent : ?agent):void =
        # Open the spawner and put a fresh car on the line.
        CarSpawner.Enable()
        CarSpawner.RespawnVehicle()

Destroy the car when the round ends

Use DestroyVehicle() to clean up the Whiplash on a timer or end-of-round signal.

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

timed_car_cleanup := class(creative_device):

    @editable
    CarSpawner : vehicle_spawner_sports_car_device = vehicle_spawner_sports_car_device{}

    @editable
    CarLifetime : float = 30.0

    OnBegin<override>()<suspends>:void =
        # Spawn a car, let players enjoy it, then blow it up.
        CarSpawner.RespawnVehicle()
        Sleep(CarLifetime)
        CarSpawner.DestroyVehicle()
        Print("The getaway car self-destructed!")

Award a bonus the moment a player drives

React to AgentEntersVehicleEvent to grant something when a player takes the wheel.

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

drive_to_earn := class(creative_device):

    @editable
    CarSpawner : vehicle_spawner_sports_car_device = vehicle_spawner_sports_car_device{}

    @editable
    SpeedBoost : speed_modulation_device = speed_modulation_device{}

    OnBegin<override>()<suspends>:void =
        CarSpawner.AgentEntersVehicleEvent.Subscribe(OnEnterCar)

    OnEnterCar(Agent : agent):void =
        # Apply a perk to whoever climbs in.
        SpeedBoost.AddTo(Agent)
        Print("Driver buffed!")

Gotchas

• DestroyedEvent and VehicleDestroyedEvent carry no agent. They are listenable(tuple()), so their handlers take no parameters — OnCarDestroyed():void. Don't try to read which player destroyed the car from these events.
• SpawnedEvent gives you a fort_vehicle, not an agent. The handler signature is (Vehicle : fort_vehicle). Use this when you need the vehicle object itself; use AgentEntersVehicleEvent when you need the player.
• Prefer the non-deprecated events. VehicleSpawnedEvent and VehicleDestroyedEvent still exist but are deprecated — use SpawnedEvent and DestroyedEvent in new code.
• RespawnVehicle() destroys the old car first. If a player is currently driving, calling RespawnVehicle() will yank them out and replace the car. Call DestroyVehicle() instead if you only want it gone.
• AssignDriver needs a valid agent. Button InteractedWithEvent hands you a plain agent, so you can pass it straight in. But if you get an agent from an ?agent event (like a trigger), unwrap it first: if (A := MaybeAgent?) { CarSpawner.AssignDriver(A) }.
• The @editable field must be bound in UEFN. A default like vehicle_spawner_sports_car_device{} only makes the file compile — if you forget to link the real placed device in the Details panel, your method calls do nothing at runtime.
• You must call methods on a declared field, not the bare type. vehicle_spawner_sports_car_device.RespawnVehicle() fails to compile; only CarSpawner.RespawnVehicle() (an instance field) works.