vehicle_spawner_nitro_drifter_sedan_device: High-Speed Drift Cars on Demand

Overview

The vehicle_spawner_nitro_drifter_sedan_device is a concrete specialization of the abstract vehicle_spawner_device base class. It represents a single Nitro Drifter sedan placed in your level and exposes a full Verse API for:

• Spawning / respawning the vehicle on demand (RespawnVehicle)
• Destroying it mid-game (DestroyVehicle)
• Force-assigning a driver so a specific player is immediately behind the wheel (AssignDriver)
• Reacting to players entering or exiting the car (AgentEntersVehicleEvent, AgentExitsVehicleEvent)
• Reacting to the vehicle being spawned or destroyed (SpawnedEvent, DestroyedEvent)
• Enabling / disabling the spawner itself (Enable, Disable)

Reach for this device whenever your game needs a scripted car moment: a getaway vehicle that appears when a vault opens, a race car that resets to the start line after each lap, or a VIP sedan that auto-assigns the round winner as driver.

API Reference

vehicle_spawner_nitro_drifter_sedan_device

Specialized vehicle_spawner_device that allows a Nitro Drifter sedan 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_nitro_drifter_sedan_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: The Getaway Car

A player triggers a button to crack a vault. The moment the vault opens, a Nitro Drifter sedan spawns and the triggering player is assigned as its driver. If the car is destroyed (e.g., by pursuers), it respawns after a short delay and a new driver is assigned. When any player exits the vehicle, the spawner is temporarily disabled so no one else can steal it.

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

# Place this Verse device in your level alongside a button_device
# and a vehicle_spawner_nitro_drifter_sedan_device.
getaway_car_manager := class(creative_device):

    # Wire these up in the Details panel
    @editable
    VaultButton : button_device = button_device{}

    @editable
    NitroDrifterSpawner : vehicle_spawner_nitro_drifter_sedan_device = vehicle_spawner_nitro_drifter_sedan_device{}

    # Track the current getaway driver so we can reassign on respawn
    var CurrentDriver : ?agent = false

    OnBegin<override>()<suspends> : void =
        # Start with the spawner disabled — car appears only when vault opens
        NitroDrifterSpawner.Disable()

        # Subscribe to the vault button
        VaultButton.InteractedWithEvent.Subscribe(OnVaultOpened)

        # React to vehicle lifecycle events
        NitroDrifterSpawner.SpawnedEvent.Subscribe(OnCarSpawned)
        NitroDrifterSpawner.DestroyedEvent.Subscribe(OnCarDestroyed)

        # React to players entering / exiting
        NitroDrifterSpawner.AgentEntersVehicleEvent.Subscribe(OnPlayerEntersCar)
        NitroDrifterSpawner.AgentExitsVehicleEvent.Subscribe(OnPlayerExitsCar)

    # Called when the player presses the vault button
    OnVaultOpened(Agent : agent) : void =
        set CurrentDriver = option{Agent}
        NitroDrifterSpawner.Enable()
        NitroDrifterSpawner.RespawnVehicle()   # Destroys any old vehicle, spawns fresh

    # SpawnedEvent sends the fort_vehicle that was just spawned
    OnCarSpawned(Vehicle : fort_vehicle) : void =
        # Assign the stored driver as soon as the car exists
        if (Driver := CurrentDriver?):
            NitroDrifterSpawner.AssignDriver(Driver)

    # DestroyedEvent fires when the vehicle is destroyed
    OnCarDestroyed(Unused : tuple()) : void =
        # Wait 3 seconds then respawn so pursuers can't permanently stop the getaway
        spawn:
            RespawnAfterDelay()

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

    # AgentEntersVehicleEvent — update the current driver reference
    OnPlayerEntersCar(Agent : agent) : void =
        set CurrentDriver = option{Agent}

    # AgentExitsVehicleEvent — lock the spawner so no one else hops in
    OnPlayerExitsCar(Agent : agent) : void =
        NitroDrifterSpawner.Disable()```

**Line-by-line highlights:**

| Line(s) | What's happening |
|---|---|
| `NitroDrifterSpawner.Disable()` | Spawner starts off — car only appears on vault trigger |
| `NitroDrifterSpawner.RespawnVehicle()` | Destroys any existing vehicle and spawns a fresh one |
| `SpawnedEvent.Subscribe(OnCarSpawned)` | Fires with the `fort_vehicle` reference once the car exists |
| `AssignDriver(Driver)` | Forces the triggering player into the driver seat |
| `DestroyedEvent.Subscribe(OnCarDestroyed)` | Fires (with an empty tuple) when the vehicle is wrecked |
| `Sleep(3.0)` inside `spawn:` | Non-blocking 3-second delay before respawn |
| `AgentExitsVehicleEvent` | Fires with the `agent` who just got out; we lock the spawner |

---

## Common patterns

### Pattern 1 — Force-assign the round winner as driver (AssignDriver + Enable)

At the end of a round, enable the spawner and immediately put the winning player in the driver seat as a victory lap reward.

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

victory_lap_controller := class(creative_device):

    @editable
    WinnerSpawner : vehicle_spawner_nitro_drifter_sedan_device = vehicle_spawner_nitro_drifter_sedan_device{}

    @editable
    EndGameTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        WinnerSpawner.Disable()
        EndGameTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundEnd(MaybeAgent : ?agent) : void =
        if (Winner := MaybeAgent?):
            WinnerSpawner.Enable()
            WinnerSpawner.RespawnVehicle()   # Spawn a fresh car
            # SpawnedEvent fires next; assign driver there
            WinnerSpawner.SpawnedEvent.Subscribe(OnVictoryCarReady)
            # Store winner for the handler
            set PendingWinner = option{Winner}

    var PendingWinner : ?agent = false

    OnVictoryCarReady(Vehicle : fort_vehicle) : void =
        if (W := PendingWinner?):
            WinnerSpawner.AssignDriver(W)

Pattern 2 — Destroy the vehicle and disable the spawner (DestroyVehicle + Disable)

A timed bomb sequence: when a countdown trigger fires, destroy the getaway car and lock the spawner so it can't be used again.

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

bomb_sequence_controller := class(creative_device):

    @editable
    NitroDrifterSpawner : vehicle_spawner_nitro_drifter_sedan_device = vehicle_spawner_nitro_drifter_sedan_device{}

    @editable
    BombTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        BombTrigger.TriggeredEvent.Subscribe(OnBombDetonated)

    OnBombDetonated(MaybeAgent : ?agent) : void =
        # Immediately wreck the car — no escape!
        NitroDrifterSpawner.DestroyVehicle()
        # Lock the spawner so it can't produce another vehicle
        NitroDrifterSpawner.Disable()

Pattern 3 — Track how many players have ridden the sedan (AgentEntersVehicleEvent counter)

Achievement logic: count unique ride-alongs during the match and fire a custom trigger when 5 players have entered the car.

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

ride_counter_device := class(creative_device):

    @editable
    NitroDrifterSpawner : vehicle_spawner_nitro_drifter_sedan_device = vehicle_spawner_nitro_drifter_sedan_device{}

    @editable
    AchievementTrigger : trigger_device = trigger_device{}

    var RideCount : int = 0
    var GoalReached : logic = false

    OnBegin<override>()<suspends> : void =
        NitroDrifterSpawner.AgentEntersVehicleEvent.Subscribe(OnAgentEnters)

    OnAgentEnters(Agent : agent) : void =
        if (not GoalReached):
            set RideCount = RideCount + 1
            if (RideCount >= 5):
                set GoalReached = true
                AchievementTrigger.Trigger()

Gotchas

1. SpawnedEvent vs deprecated VehicleSpawnedEvent

SpawnedEvent is the modern API and sends the actual fort_vehicle reference — use it. VehicleSpawnedEvent sends an empty tuple() and is deprecated; avoid it in new code.

2. DestroyedEvent sends tuple(), not an agent

Unlike AgentEntersVehicleEvent / AgentExitsVehicleEvent, the DestroyedEvent handler receives an empty tuple (Unused : tuple()). You cannot determine who destroyed the car from this event alone.

3. AssignDriver requires the vehicle to already exist

Calling AssignDriver before the vehicle has spawned has no effect. Always call it inside a SpawnedEvent handler (or after await-ing the event) to guarantee the car is present.

4. RespawnVehicle destroys the old vehicle first

If you call RespawnVehicle() while a player is still inside, they will be ejected. This triggers AgentExitsVehicleEvent — make sure your exit handler doesn't create an infinite loop (e.g., don't call RespawnVehicle again from inside OnPlayerExitsCar).

5. AgentEntersVehicleEvent sends agent, not ?agent

This event's listenable is typed listenable(agent) — the handler receives a plain agent, not an optional. No unwrapping needed. Contrast this with trigger_device.TriggeredEvent which sends ?agent and does require unwrapping with if (A := MaybeAgent?).

6. Spawner must be Enabled to spawn

If you call Disable() and then RespawnVehicle(), the vehicle will not appear. Always call Enable() before RespawnVehicle() if you previously disabled the spawner.

7. DestroyVehicle is a no-op if no vehicle exists

Calling DestroyVehicle() when the spawner has no active vehicle is safe — it simply does nothing. You don't need a guard check.