vehicle_spawner_getaway_device: The Heist Car That Drives the Round

Overview

The vehicle_spawner_getaway_device is a specialized vehicle_spawner_device that spawns the GetAway Car — the heist vehicle used in cops-and-robbers / escape-style modes. It's the device you reach for when your round revolves around one important vehicle: a getaway car the robbers must reach and drive to an extraction point.

Because it inherits from vehicle_spawner_device, it gives you full Verse control over that car's lifecycle:

• Spawn / respawn the car (RespawnVehicle) so a new round always starts with a fresh, intact getaway car.
• Destroy it (DestroyVehicle) when the round ends or the heist fails.
• Force a driver into the seat (AssignDriver) — handy for cinematic getaways or auto-boarding a chosen player.
• React to players entering/exiting (AgentEntersVehicleEvent, AgentExitsVehicleEvent), to the car spawning (SpawnedEvent, which hands you the actual fort_vehicle), and to it being wrecked (DestroyedEvent).
• Enable / Disable the whole spawner so robbers can't grab the car until the heist phase begins.

Reach for this device whenever the vehicle itself is the objective, not just decoration.

API Reference

vehicle_spawner_getaway_device

Specialized vehicle_spawner_device that allows a GetAway 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_getaway_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 complete getaway mini-game loop:

1. The spawner starts disabled so no one can drive off early.
2. A button starts the heist — we enable the spawner and respawn a fresh car.
3. When a player enters the car, we announce the getaway is in progress.
4. If the car gets destroyed, we automatically respawn it so the heist can continue.
5. When the car spawns, we grab the fort_vehicle it hands us so we know it's ready.

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

# A full getaway-heist controller built around the GetAway Car spawner.
getaway_heist_device := class(creative_device):

    # The GetAway Car spawner placed in the level.
    @editable
    GetawaySpawner : vehicle_spawner_getaway_device = vehicle_spawner_getaway_device{}

    # A button the host/robbers press to begin the heist.
    @editable
    StartHeistButton : button_device = button_device{}

    # Localized message helper (message params need a localized value, not a raw string).
    Announce<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Lock the car away until the heist starts.
        GetawaySpawner.Disable()

        # Wire up the button to kick things off.
        StartHeistButton.InteractedWithEvent.Subscribe(OnStartHeist)

        # React to the car's lifecycle.
        GetawaySpawner.SpawnedEvent.Subscribe(OnCarSpawned)
        GetawaySpawner.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)
        GetawaySpawner.AgentExitsVehicleEvent.Subscribe(OnDriverExited)
        GetawaySpawner.DestroyedEvent.Subscribe(OnCarDestroyed)

    # Button handler: enable the spawner and drop a fresh getaway car.
    OnStartHeist(Agent : agent) : void =
        GetawaySpawner.Enable()
        # RespawnVehicle destroys any old car first, then spawns a clean one.
        GetawaySpawner.RespawnVehicle()

    # SpawnedEvent hands us the actual fort_vehicle that was spawned.
    OnCarSpawned(Vehicle : fort_vehicle) : void =
        Print("GetAway Car is ready for the heist!")

    # A robber climbed in — the getaway is on.
    OnDriverEntered(Agent : agent) : void =
        Print("A robber has taken the wheel — go go go!")

    # Driver bailed out.
    OnDriverExited(Agent : agent) : void =
        Print("The getaway driver bailed!")

    # Car got wrecked — respawn it so the round can continue.
    OnCarDestroyed(MaybeAgent : ?agent) : void =
        Print("GetAway Car destroyed — sending a replacement.")
        GetawaySpawner.RespawnVehicle()

Line by line:

• @editable GetawaySpawner : vehicle_spawner_getaway_device — you must declare the placed device as an editable field; calling its methods on a bare local would fail with Unknown identifier. In UEFN you then bind this field to the spawner you dragged into the level.
• GetawaySpawner.Disable() in OnBegin keeps the car unavailable until the heist phase.
• StartHeistButton.InteractedWithEvent.Subscribe(OnStartHeist) — event handlers are methods on the class; we subscribe them in OnBegin.
• In OnStartHeist, Enable() turns the spawner on and RespawnVehicle() guarantees a clean car (it destroys any leftover first).
• SpawnedEvent.Subscribe(OnCarSpawned) — note the handler param is Vehicle : fort_vehicle, the real spawned car object, because SpawnedEvent is listenable(fort_vehicle).
• AgentEntersVehicleEvent/AgentExitsVehicleEvent are listenable(agent), so their handlers take (Agent : agent).
• DestroyedEvent is listenable(?agent), so its handler takes a ?agent — you'd unwrap it with if (A := MaybeAgent?) if you needed the destroyer.

Common patterns

Auto-board a chosen driver with AssignDriver

For a cinematic getaway, force a specific player into the seat the moment the car spawns instead of waiting for them to walk over.

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

auto_driver_device := class(creative_device):

    @editable
    GetawaySpawner : vehicle_spawner_getaway_device = vehicle_spawner_getaway_device{}

    # When a player steps on this plate, they become the assigned driver.
    @editable
    DriverPlate : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        DriverPlate.TriggeredEvent.Subscribe(OnPlateStepped)

    OnPlateStepped(MaybeAgent : ?agent) : void =
        if (Driver := MaybeAgent?):
            # Make sure there is a fresh car, then seat the player.
            GetawaySpawner.RespawnVehicle()
            GetawaySpawner.AssignDriver(Driver)

Disable the spawner once the escape succeeds

When the heist is complete, shut the spawner down so no more getaway cars appear.

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

heist_complete_device := class(creative_device):

    @editable
    GetawaySpawner : vehicle_spawner_getaway_device = vehicle_spawner_getaway_device{}

    # A trigger at the extraction point.
    @editable
    ExtractionZone : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        ExtractionZone.TriggeredEvent.Subscribe(OnExtracted)

    OnExtracted(MaybeAgent : ?agent) : void =
        # Round over: get rid of the car and lock the spawner.
        GetawaySpawner.DestroyVehicle()
        GetawaySpawner.Disable()

Track exits to detect an abandoned car

Use AgentExitsVehicleEvent to punish robbers who leave the getaway car behind.

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

abandon_watch_device := class(creative_device):

    @editable
    GetawaySpawner : vehicle_spawner_getaway_device = vehicle_spawner_getaway_device{}

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

    OnExit(Agent : agent) : void =
        # A robber left the car — flag it as abandoned.
        Print("GetAway Car abandoned! Replacing it.")
        GetawaySpawner.RespawnVehicle()

Gotchas

• SpawnedEvent vs VehicleSpawnedEvent. VehicleSpawnedEvent/VehicleDestroyedEvent are deprecated and carry tuple() (no payload). Prefer SpawnedEvent (gives you the fort_vehicle) and DestroyedEvent. Don't mix old and new for the same logic.
• DestroyedEvent is listenable(?agent), not listenable(agent). Your handler must take (MaybeAgent : ?agent) and unwrap with if (A := MaybeAgent?): before using the agent. A non-agent destroyer (e.g. world damage) gives you a false option — handle that case.
• You must declare the device as an @editable field. Calling vehicle_spawner_getaway_device{} methods on a bare local won't reference your placed device. Bind the field in the UEFN Details panel.
• RespawnVehicle destroys the previous car first. If a robber is already driving, calling RespawnVehicle will yank the old car out from under them — only respawn when you actually want a fresh vehicle.
• AssignDriver needs a live agent and an existing car. If no vehicle is currently spawned, assign a driver after spawning. Call RespawnVehicle() then AssignDriver(Driver).
• Localized messages. Any device API taking a message needs a localized value — declare a Announce<localizes>(S:string):message = "{S}" helper and pass Announce("..."). There is no StringToMessage.
• Disabled spawners ignore method calls that depend on a car. Disable() stops new spawns; if you Disable() then RespawnVehicle(), behavior may not be what you expect. Enable before spawning.