vehicle_spawner_sedan_device: Sedans on Demand

Overview

The vehicle_spawner_sedan_device is a specialized vehicle_spawner_device that spawns a Prevalent sedan — a four-seat road car — at its placed location. You drop it in the level, and a car appears for players to drive.

Where it gets powerful is Verse. Because it inherits every method and event from vehicle_spawner_device, you can:

• Respawn a fresh car after the old one is wrecked (a heist getaway car that's always waiting).
• Destroy the car on command (blow it up when a timer runs out).
• Assign a driver so a specific player is dropped behind the wheel.
• React when an agent enters or exits, when the car spawns, or when it's destroyed — to award points, lock doors, trigger cinematics, etc.

Reach for this device whenever your mode needs a controllable, scriptable car: getaway missions, demolition derbies, taxi services, or simply giving players wheels when they reach a checkpoint.

API Reference

vehicle_spawner_sedan_device

Specialized vehicle_spawner_device that allows a Prevalent 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_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

Let's build a getaway car scenario. A button calls the car. When a player gets in, we assign them as the driver and start a 30-second escape timer. If they bail out, we wreck the car. When the car is destroyed, we automatically respawn a fresh one so the next player has wheels.

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

getaway_car_device := class(creative_device):

    # Drag your placed vehicle_spawner_sedan_device onto this field in UEFN.
    @editable
    SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{}

    # A button the player presses to call the car.
    @editable
    CallButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        # Wire up the button to spawn (or replace) the sedan.
        CallButton.InteractedWithEvent.Subscribe(OnCallPressed)

        # React to the sedan's own events.
        SedanSpawner.AgentEntersVehicleEvent.Subscribe(OnEntered)
        SedanSpawner.AgentExitsVehicleEvent.Subscribe(OnExited)
        SedanSpawner.DestroyedEvent.Subscribe(OnCarDestroyed)

        # Make sure the spawner is on at match start.
        SedanSpawner.Enable()

    # Button handler: hands the player a fresh getaway car.
    OnCallPressed(Agent : agent):void =
        SedanSpawner.RespawnVehicle()

    # An agent climbed in — put them in the driver seat and start the clock.
    OnEntered(Agent : agent):void =
        SedanSpawner.AssignDriver(Agent)
        spawn { EscapeTimer() }

    # An agent bailed — wreck the car so it can't be reused mid-escape.
    OnExited(Agent : agent):void =
        SedanSpawner.DestroyVehicle()

    # When the car is destroyed (wreck or timer), drop in a fresh one.
    OnCarDestroyed():void =
        SedanSpawner.RespawnVehicle()

    # 30-second escape window; wreck the car when time's up.
    EscapeTimer()<suspends>:void =
        Sleep(30.0)
        SedanSpawner.DestroyVehicle()```

**Line by line:**

- `@editable SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{}` — declares the field you bind to your placed spawner in UEFN. Without this `@editable` field, calling `SedanSpawner.RespawnVehicle()` would fail with *Unknown identifier*.
- In `OnBegin`, we `Subscribe` four handlers. `InteractedWithEvent` (from the button) and the spawner's `AgentEntersVehicleEvent`, `AgentExitsVehicleEvent`, and `DestroyedEvent`.
- `OnCallPressed` calls **`RespawnVehicle()`** — this destroys any existing car and spawns a fresh one. The handler receives `(Agent : agent)` because `InteractedWithEvent` passes the interacting agent.
- `OnEntered` calls **`AssignDriver(Agent)`** to force the player who just entered into the driver seat, then `spawn`s the timer.
- `OnExited` calls **`DestroyVehicle()`** — bailing out wrecks the car.
- `OnCarDestroyed` (subscribed to **`DestroyedEvent`**) calls `RespawnVehicle()` so a clean car is always available. Note: `DestroyedEvent` is a `listenable(tuple())`, so its handler takes **no parameters**.
- `EscapeTimer` is a `<suspends>` function — it can call `Sleep`. After 30 seconds it destroys the car.

## Common patterns

### Award points when a player drives off (SpawnedEvent + AgentEntersVehicleEvent)

`SpawnedEvent` is a `listenable(fort_vehicle)` — it hands you the actual vehicle that spawned, so you can react to a car being created.

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

car_reward_device := class(creative_device):

    @editable
    SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{}

    @editable
    ScoreManager : score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends>:void =
        SedanSpawner.SpawnedEvent.Subscribe(OnVehicleSpawned)
        SedanSpawner.AgentEntersVehicleEvent.Subscribe(OnPlayerDroveOff)

    # Handler receives the spawned fort_vehicle.
    OnVehicleSpawned(Vehicle : fort_vehicle):void =
        # A new sedan exists — could attach effects, etc.
        SedanSpawner.Enable()

    # Award the entering player.
    OnPlayerDroveOff(Agent : agent):void =
        ScoreManager.Activate(Agent)

A timed roadblock toggle (Enable / Disable)

Disable the spawner so no new cars appear during a "no vehicles" phase, then re-enable it later.

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

roadblock_device := class(creative_device):

    @editable
    SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{}

    OnBegin<override>()<suspends>:void =
        # No cars during the opening 10-second sprint phase.
        SedanSpawner.Disable()
        Sleep(10.0)
        # Now vehicles are allowed.
        SedanSpawner.Enable()
        SedanSpawner.RespawnVehicle()

Clean up the car when its owner leaves (AgentExitsVehicleEvent + DestroyVehicle)

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

abandoned_car_cleanup := class(creative_device):

    @editable
    SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{}

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

    OnExit(Agent : agent):void =
        # Whoever just left abandoned the sedan — destroy it to keep the map clean.
        SedanSpawner.DestroyVehicle()

Gotchas

• You must bind the @editable field in UEFN. Declaring SedanSpawner : vehicle_spawner_sedan_device = vehicle_spawner_sedan_device{} only creates a placeholder; select your creative_device in the editor and drag the placed spawner into the property. An unbound field calls a phantom device and nothing happens.
• Event handler signatures must match the event's payload type. AgentEntersVehicleEvent / AgentExitsVehicleEvent are listenable(agent), so handlers take (Agent : agent). SpawnedEvent is listenable(fort_vehicle), so its handler takes (Vehicle : fort_vehicle). DestroyedEvent is listenable(tuple()), so its handler takes no parameters — writing OnCarDestroyed(Agent : agent) for it won't compile.
• Don't use the deprecated events. VehicleSpawnedEvent and VehicleDestroyedEvent still exist but are deprecated; prefer SpawnedEvent and DestroyedEvent, which give you richer payloads.
• RespawnVehicle() destroys the old car first. It is destroy-then-spawn, not spawn-a-second-car. If you want two sedans, place two spawner devices.
• AssignDriver needs a valid agent that can drive. Call it from inside an enter/spawn handler where you already have a live agent; assigning a driver to a non-existent car silently does nothing.
• Sleep and other waiting calls only work inside <suspends> functions. That's why EscapeTimer is marked <suspends> and launched with spawn { ... } rather than called directly from a plain event handler.
• Verse does not auto-convert int↔float. Sleep takes a float, so write Sleep(30.0), not Sleep(30).