vehicle_spawner_quadcrasher_device: Quadcrashers on Demand

Overview

The vehicle_spawner_quadcrasher_device is a specialized vehicle spawner that produces a Quadcrasher — the chunky, boost-and-bash ATV from Fortnite. It inherits everything from the abstract vehicle_spawner_device base class, so the same methods and events you learn here apply to every other vehicle spawner (sedan, big rig, surfboard, etc.).

Reach for this device when your game needs a drivable vehicle that you want to control from code: a race start gate that spawns each racer's ride, a respawn-on-death system that hands the player a fresh Quadcrasher, or a checkpoint that destroys an abandoned vehicle so the lane stays clear.

The key things it does for you:

• Spawn / respawn a Quadcrasher on cue (RespawnVehicle).
• Destroy the current vehicle (DestroyVehicle).
• Auto-seat a specific player as the driver (AssignDriver).
• Enable / Disable the spawner so players can or can't get a new ride.
• React when someone enters or exits, or when a vehicle spawns or is destroyed (AgentEntersVehicleEvent, AgentExitsVehicleEvent, SpawnedEvent, DestroyedEvent).

API Reference

vehicle_spawner_quadcrasher_device

Specialized vehicle_spawner_device that allows a Quadcrasher 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_quadcrasher_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 race-start podium. When a player steps on a trigger, we respawn a clean Quadcrasher and instantly seat that player as the driver. We also track when they climb out (e.g. they bailed) and clear the vehicle so the lane is ready for the next racer.

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

# A race-start podium that spawns a Quadcrasher and seats the player who triggers it.
race_start_device := class(creative_device):

    # Drag your Quadcrasher spawner into this slot in the Details panel.
    @editable
    QuadSpawner : vehicle_spawner_quadcrasher_device = vehicle_spawner_quadcrasher_device{}

    # The trigger players step on to claim a ride.
    @editable
    StartTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        # Subscribe our handlers to the device events.
        StartTrigger.TriggeredEvent.Subscribe(OnPlayerReady)
        QuadSpawner.SpawnedEvent.Subscribe(OnVehicleSpawned)
        QuadSpawner.AgentEntersVehicleEvent.Subscribe(OnEntered)
        QuadSpawner.AgentExitsVehicleEvent.Subscribe(OnExited)

    # trigger_device hands us an ?agent — unwrap it before use.
    OnPlayerReady(MaybeAgent : ?agent) : void =
        if (Driver := MaybeAgent?):
            # Spawn a fresh Quadcrasher (destroys any previous one first)...
            QuadSpawner.RespawnVehicle()
            # ...then seat this player in it.
            QuadSpawner.AssignDriver(Driver)

    # SpawnedEvent sends the fort_vehicle that was spawned.
    OnVehicleSpawned(Vehicle : fort_vehicle) : void =
        Print("A Quadcrasher spawned and is ready to drive.")

    OnEntered(Agent : agent) : void =
        Print("A racer boarded the Quadcrasher.")

    OnExited(Agent : agent) : void =
        # Player bailed — clear the vehicle so the lane is empty.
        QuadSpawner.DestroyVehicle()

Line by line:

• race_start_device := class(creative_device): — every placed Verse script is a creative_device subclass.
• The two @editable fields are how Verse reaches the placed devices. After you drop this script in the level, you assign your real Quadcrasher spawner and trigger in the Details panel. Without the @editable field, calling QuadSpawner.RespawnVehicle() would fail with Unknown identifier.
• OnBegin<override>()<suspends>:void = runs when the game starts. This is where we wire up every event subscription.
• StartTrigger.TriggeredEvent.Subscribe(OnPlayerReady) — connects the trigger to our method. TriggeredEvent is a listenable(?agent), so the handler receives a ?agent.
• if (Driver := MaybeAgent?): unwraps the optional agent. Only inside this block do we have a real agent to work with.
• QuadSpawner.RespawnVehicle() spawns a new Quadcrasher; if one already existed, it is destroyed first. This guarantees a clean ride each time.
• QuadSpawner.AssignDriver(Driver) seats the triggering player directly in the driver seat — no walking up to the vehicle required.
• QuadSpawner.SpawnedEvent.Subscribe(OnVehicleSpawned) — SpawnedEvent is listenable(fort_vehicle), so OnVehicleSpawned takes a fort_vehicle parameter (the actual vehicle that appeared).
• OnExited calls DestroyVehicle() to remove the abandoned Quadcrasher.

Common patterns

Disable the spawner once a player is driving

Use Disable to prevent a fresh vehicle being created until the round resets, then Enable when it's time again.

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

single_use_quad_device := class(creative_device):

    @editable
    QuadSpawner : vehicle_spawner_quadcrasher_device = vehicle_spawner_quadcrasher_device{}

    OnBegin<override>()<suspends>:void =
        # Lock it until a vehicle exists.
        QuadSpawner.AgentEntersVehicleEvent.Subscribe(OnEntered)
        QuadSpawner.AgentExitsVehicleEvent.Subscribe(OnExited)

    OnEntered(Agent : agent) : void =
        # Someone claimed it — no more spawns this round.
        QuadSpawner.Disable()
        Print("Quadcrasher claimed, spawner disabled.")

    OnExited(Agent : agent) : void =
        # Free again — let it produce another.
        QuadSpawner.Enable()
        Print("Quadcrasher free, spawner re-enabled.")

React to a destroyed vehicle and respawn it

DestroyedEvent fires when the Quadcrasher is wrecked. Here we automatically respawn a replacement after it blows up.

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

auto_respawn_quad_device := class(creative_device):

    @editable
    QuadSpawner : vehicle_spawner_quadcrasher_device = vehicle_spawner_quadcrasher_device{}

    OnBegin<override>()<suspends>:void =
        QuadSpawner.DestroyedEvent.Subscribe(OnVehicleDestroyed)

    # DestroyedEvent is listenable(tuple()) — handler takes no useful payload.
    OnVehicleDestroyed() : void =
        Print("Quadcrasher destroyed — spawning a replacement.")
        # Wait a beat, then bring a fresh one back.
        spawn { RespawnAfterDelay() }

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

A button that spawns a ride for whoever pressed it

Combine a button with RespawnVehicle + AssignDriver for an on-demand garage.

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

quad_garage_device := class(creative_device):

    @editable
    QuadSpawner : vehicle_spawner_quadcrasher_device = vehicle_spawner_quadcrasher_device{}

    @editable
    GarageButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        GarageButton.InteractedWithEvent.Subscribe(OnPressed)

    # button_device sends a plain agent (not an option).
    OnPressed(Agent : agent) : void =
        QuadSpawner.RespawnVehicle()
        QuadSpawner.AssignDriver(Agent)

Gotchas

• You must declare the spawner as an @editable field. A bare vehicle_spawner_quadcrasher_device{} literal is not the placed device. Drop your Verse script in the level and bind the real spawner in the Details panel, or none of the methods affect anything in-world.
• SpawnedEvent vs VehicleSpawnedEvent. VehicleSpawnedEvent and VehicleDestroyedEvent are deprecated. Use SpawnedEvent (gives you the fort_vehicle) and DestroyedEvent. Don't write new code against the deprecated tuple events.
• Event payload shapes differ. AgentEntersVehicleEvent/AgentExitsVehicleEvent give a plain agent. SpawnedEvent gives a fort_vehicle. The deprecated and Destroyed events are listenable(tuple()), so their handlers take no parameters. Match your handler signature to the event or it won't compile.
• ?agent vs agent. A trigger_device.TriggeredEvent hands you a ?agent — you must unwrap with if (A := MaybeAgent?):. But the vehicle spawner's AgentEntersVehicleEvent hands you a non-optional agent directly. Don't add an unnecessary ? unwrap to the vehicle events.
• RespawnVehicle destroys the old vehicle first. If a player is sitting in the current Quadcrasher and you call RespawnVehicle, their ride disappears under them. Use DestroyVehicle deliberately and RespawnVehicle only when you want a clean slate.
• AssignDriver needs a vehicle to exist. Call RespawnVehicle() first (or make sure one is spawned) before AssignDriver, otherwise there's no seat to put the player in.
• using { /Fortnite.com/Vehicles } is required to name the fort_vehicle type in your SpawnedEvent handler. Forgetting it gives Unknown identifier: fort_vehicle.