vehicle_spawner_atk_device: Karts on Demand

Overview

The vehicle_spawner_atk_device is a specialized vehicle_spawner_device that spawns the All-Terrain Kart (ATK) — the four-seat off-road kart. You place one in your level, and it spawns a kart at its location. From Verse you can:

• Spawn / respawn the kart on cue (RespawnVehicle).
• Destroy the current kart (DestroyVehicle).
• Turn the spawner on/off (Enable / Disable).
• Force a player into the driver seat (AssignDriver).
• React when a player enters (AgentEntersVehicleEvent), exits (AgentExitsVehicleEvent), the kart spawns (SpawnedEvent), or is destroyed (DestroyedEvent).

Reach for it whenever the kart's lifecycle is part of your game logic: a race that hands each runner a fresh kart at the start line, an escape sequence where the getaway cart only spawns once the vault is cracked, or a checkpoint that scores a player only while they're behind the wheel.

Because it inherits from vehicle_spawner_device, everything here also applies to its siblings (boat, baller, biplane, tank, etc.) — just swap the editable's type.

API Reference

vehicle_spawner_atk_device

Specialized vehicle_spawner_device that allows an ATK (all terrain kart) 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_atk_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 heist getaway: a button cracks the vault, which spawns a fresh ATK and forces the interacting player straight into the driver seat. We also track entries/exits and announce when the kart spawns or gets wrecked.

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

heist_getaway_device := class(creative_device):

    # Place these in the level, then assign them in the Details panel.
    @editable
    KartSpawner : vehicle_spawner_atk_device = vehicle_spawner_atk_device{}

    @editable
    VaultButton : button_device = button_device{}

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

    OnBegin<override>()<suspends>:void =
        # Don't spawn a kart until the vault is cracked.
        KartSpawner.Disable()

        # Wire up the vault button.
        VaultButton.InteractedWithEvent.Subscribe(OnVaultCracked)

        # React to the kart's lifecycle.
        KartSpawner.SpawnedEvent.Subscribe(OnKartSpawned)
        KartSpawner.DestroyedEvent.Subscribe(OnKartDestroyed)
        KartSpawner.AgentEntersVehicleEvent.Subscribe(OnDriverIn)
        KartSpawner.AgentExitsVehicleEvent.Subscribe(OnDriverOut)

    # The robber finishes the vault: enable the spawner, spawn a kart, seat them.
    OnVaultCracked(Agent : agent) : void =
        KartSpawner.Enable()
        KartSpawner.RespawnVehicle()      # spawns a fresh ATK at the spawner
        KartSpawner.AssignDriver(Agent)   # drop the robber into the driver seat

    # SpawnedEvent hands us the fort_vehicle that was created.
    OnKartSpawned(Vehicle : fort_vehicle) : void =
        Print("A getaway kart has spawned!")

    OnKartDestroyed() : void =
        Print("The getaway kart was wrecked!")
        # Give the crew another chance after a wreck.
        KartSpawner.RespawnVehicle()

    OnDriverIn(Agent : agent) : void =
        Print("A player climbed into the kart.")

    OnDriverOut(Agent : agent) : void =
        Print("A player left the kart.")

Line by line:

• The two @editable fields let you drag your placed vehicle_spawner_atk_device and button_device onto this Verse device in the Details panel. Without the editable field you cannot call the device's methods.
• KartSpawner.Disable() in OnBegin keeps the kart from existing until the heist is done.
• VaultButton.InteractedWithEvent.Subscribe(OnVaultCracked) runs OnVaultCracked whenever a player interacts. That event hands us the agent, already unwrapped (button_device.InteractedWithEvent is listenable(agent)).
• In OnVaultCracked we Enable(), then RespawnVehicle() to spawn a brand-new ATK (RespawnVehicle destroys any old one first), then AssignDriver(Agent) to seat the robber instantly.
• SpawnedEvent is the modern event — its handler receives the actual fort_vehicle so you can inspect or operate on the spawned kart.
• DestroyedEvent fires on a wreck; here we immediately respawn so the heist can continue.
• AgentEntersVehicleEvent / AgentExitsVehicleEvent give you the agent climbing in or out — perfect for scoring "time in the driver seat."

Common patterns

Pattern 1 — A timed kart that despawns on exit (DestroyVehicle)

Great for a single-use escape pod: the moment a player abandons the kart, it's gone.

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

single_use_kart_device := class(creative_device):

    @editable
    KartSpawner : vehicle_spawner_atk_device = vehicle_spawner_atk_device{}

    OnBegin<override>()<suspends>:void =
        KartSpawner.AgentExitsVehicleEvent.Subscribe(OnAbandoned)

    OnAbandoned(Agent : agent) : void =
        # Player bailed out — destroy the kart so nobody else can grab it.
        KartSpawner.DestroyVehicle()
        Print("Escape kart consumed.")

Pattern 2 — Race start: one kart per round, seat the racer (RespawnVehicle + AssignDriver)

When a round begins, hand a clean kart to whoever stepped on the start plate.

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

race_start_device := class(creative_device):

    @editable
    KartSpawner : vehicle_spawner_atk_device = vehicle_spawner_atk_device{}

    @editable
    StartPlate : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        StartPlate.TriggeredEvent.Subscribe(OnRaceStart)

    # TriggeredEvent is listenable(?agent): the agent is optional and must be unwrapped.
    OnRaceStart(MaybeAgent : ?agent) : void =
        if (Racer := MaybeAgent?):
            KartSpawner.RespawnVehicle()
            KartSpawner.AssignDriver(Racer)

Pattern 3 — Inspect the spawned vehicle via SpawnedEvent

SpawnedEvent is the only event that hands you the fort_vehicle itself, so use it instead of the deprecated VehicleSpawnedEvent.

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

spawn_logger_device := class(creative_device):

    @editable
    KartSpawner : vehicle_spawner_atk_device = vehicle_spawner_atk_device{}

    OnBegin<override>()<suspends>:void =
        KartSpawner.Enable()
        KartSpawner.SpawnedEvent.Subscribe(OnSpawned)
        # Force the first spawn so we have something to track.
        KartSpawner.RespawnVehicle()

    OnSpawned(Vehicle : fort_vehicle) : void =
        # You now hold the real fort_vehicle that was created.
        Print("ATK spawned and ready to drive.")

Gotchas

• You must use an @editable field. Calling vehicle_spawner_atk_device{}.RespawnVehicle() on a bare value does nothing useful — declare it as an @editable field and assign your placed device in the Details panel, or you'll get 'Unknown identifier'/no-op behavior.
• SpawnedEvent vs VehicleSpawnedEvent. VehicleSpawnedEvent and VehicleDestroyedEvent are deprecated (they carry tuple() — no data). Use SpawnedEvent (gives you the fort_vehicle) and DestroyedEvent instead.
• RespawnVehicle replaces the old kart. It destroys any existing kart before spawning a new one — calling it twice fast doesn't give you two karts.
• AssignDriver needs a spawned vehicle. Spawn (or respawn) the kart before assigning a driver, or there's no seat to put them in. In the walkthrough we RespawnVehicle() then AssignDriver().
• Optional agents from triggers. trigger_device.TriggeredEvent is listenable(?agent) — the handler param is ?agent and you must unwrap with if (A := MaybeAgent?): before passing it to AssignDriver. By contrast AgentEntersVehicleEvent is listenable(agent) (non-optional) and hands you the agent directly.
• fort_vehicle needs its import. To name the fort_vehicle type in a SpawnedEvent handler, add using { /Fortnite.com/Vehicles }.
• Disable doesn't destroy. Disable() stops the spawner from spawning, but an already-spawned kart stays. Call DestroyVehicle() if you also want the existing kart gone.