vehicle_spawner_armored_battle_bus_device: Drop the Battle Bus on Cue

Overview

The vehicle_spawner_armored_battle_bus_device is a specialized vehicle_spawner_device that places an Armored Battle Bus in your level. It solves the classic team-mobility problem: you want a big, tanky vehicle that a squad can pile into, that you can spawn/destroy on demand, and that fires events your game logic can hook into.

Reach for it when you want:

• A central getaway vehicle that respawns after it's destroyed.
• A boss bus that you destroy from script when a round ends.
• Reactive logic — give a player a shield buff the moment they board, or score points when the bus is wrecked.

Because it inherits everything from vehicle_spawner_device, the same Enable/Disable/AssignDriver/DestroyVehicle/RespawnVehicle methods and the AgentEntersVehicleEvent/AgentExitsVehicleEvent/SpawnedEvent/DestroyedEvent events all apply. Everything below works identically for the dirtbike, helicopter, UFO, and tank spawners too.

API Reference

vehicle_spawner_armored_battle_bus_device

Specialized vehicle_spawner_device that allows an armored battle bus 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_armored_battle_bus_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 respawning getaway bus. When the round starts we enable the spawner. When the bus is destroyed we wait a moment and respawn a fresh one. When a player boards we tag them as the driver and grant a small shield (via an item granter); when they leave we just log it. We'll also reward the team with a score whenever the bus is wrecked.

Place an Armored Battle Bus spawner, an item granter, and a score manager in your level, then bind them to the editable fields.

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

# Getaway-bus controller: spawns, respawns, and reacts to the Armored Battle Bus.
getaway_bus_device := class(creative_device):

    # Drag your Armored Battle Bus spawner here in the Details panel.
    @editable
    BusSpawner : vehicle_spawner_armored_battle_bus_device = vehicle_spawner_armored_battle_bus_device{}

    # Item granter that hands the driver a shield item.
    @editable
    DriverGranter : item_granter_device = item_granter_device{}

    # Score awarded to whoever wrecks the bus.
    @editable
    WreckScore : score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends>:void =
        # Turn the spawner on so the first bus appears.
        BusSpawner.Enable()

        # React to players boarding / leaving the bus.
        BusSpawner.AgentEntersVehicleEvent.Subscribe(OnEnter)
        BusSpawner.AgentExitsVehicleEvent.Subscribe(OnExit)

        # React to the bus spawning and being destroyed.
        BusSpawner.SpawnedEvent.Subscribe(OnBusSpawned)
        BusSpawner.DestroyedEvent.Subscribe(OnBusDestroyed)

    # AgentEntersVehicleEvent hands us a plain agent (not an option here).
    OnEnter(Agent : agent):void =
        # Make this player the official driver.
        BusSpawner.AssignDriver(Agent)
        # Give them a shield item from the granter.
        DriverGranter.GrantItem(Agent)
        Print("A player boarded the battle bus and was assigned as driver.")

    OnExit(Agent : agent):void =
        Print("A player left the battle bus.")

    # SpawnedEvent sends the fort_vehicle that was spawned.
    OnBusSpawned(Vehicle : fort_vehicle):void =
        Print("A fresh armored battle bus is ready.")

    # DestroyedEvent sends an empty tuple; we kick off a respawn.
    OnBusDestroyed():void =
        Print("Battle bus destroyed — respawning shortly.")
        spawn { RespawnAfterDelay() }

    RespawnAfterDelay()<suspends>:void =
        Sleep(5.0)
        # RespawnVehicle destroys any existing bus, then spawns a new one.
        BusSpawner.RespawnVehicle()

Line by line:

• The three @editable fields are how Verse reaches placed devices. Without declaring BusSpawner as an editable field of a creative_device class, calling BusSpawner.Enable() would fail with Unknown identifier.
• OnBegin runs when the game starts. We Enable() the spawner so a bus appears, then Subscribe each handler to its event. Subscriptions belong in OnBegin; the handlers themselves are methods at class scope.
• OnEnter(Agent : agent) — AgentEntersVehicleEvent is listenable(agent), so the handler receives a ready-to-use agent (no ? unwrap needed). We call AssignDriver(Agent) to seat them as driver and GrantItem(Agent) to hand a shield.
• OnBusSpawned(Vehicle : fort_vehicle) — SpawnedEvent is listenable(fort_vehicle), so we get the actual vehicle object.
• OnBusDestroyed() — DestroyedEvent is listenable(tuple()), an empty payload, so the handler takes no parameters. We spawn an async helper because handlers aren't <suspends> and can't Sleep directly.
• RespawnAfterDelay waits 5 seconds, then RespawnVehicle() replaces the wreck with a fresh bus — closing the loop.

Common patterns

Pattern 1 — Force-spawn a bus from another event and reward the wrecker

Use RespawnVehicle to manufacture a fresh bus on command (e.g. from a button), and award score on DestroyedEvent.

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

bus_button_device := class(creative_device):

    @editable
    BusSpawner : vehicle_spawner_armored_battle_bus_device = vehicle_spawner_armored_battle_bus_device{}

    @editable
    SummonButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        BusSpawner.Enable()
        SummonButton.InteractedWithEvent.Subscribe(OnSummon)
        BusSpawner.DestroyedEvent.Subscribe(OnWrecked)

    OnSummon(Agent : agent):void =
        # Replace any existing bus with a brand new one.
        BusSpawner.RespawnVehicle()
        Print("Battle bus summoned by button.")

    OnWrecked():void =
        Print("The summoned bus was wrecked.")

Pattern 2 — Disable the spawner and clear the bus at round end

Disable stops the spawner from producing more buses; DestroyVehicle removes the current one immediately.

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

round_end_bus_device := class(creative_device):

    @editable
    BusSpawner : vehicle_spawner_armored_battle_bus_device = vehicle_spawner_armored_battle_bus_device{}

    # Trigger that fires when the round ends.
    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    # TriggeredEvent passes ?agent; unwrap it if you need the instigator.
    OnRoundEnd(MaybeAgent : ?agent):void =
        # No more buses, and clear the current one off the field.
        BusSpawner.Disable()
        BusSpawner.DestroyVehicle()
        if (Agent := MaybeAgent?):
            Print("Round ended — bus cleared.")

Pattern 3 — Track who is aboard with enter/exit events

Keep a count of riders using AgentEntersVehicleEvent and AgentExitsVehicleEvent.

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

bus_rider_counter_device := class(creative_device):

    @editable
    BusSpawner : vehicle_spawner_armored_battle_bus_device = vehicle_spawner_armored_battle_bus_device{}

    var RiderCount : int = 0

    OnBegin<override>()<suspends>:void =
        BusSpawner.Enable()
        BusSpawner.AgentEntersVehicleEvent.Subscribe(OnBoard)
        BusSpawner.AgentExitsVehicleEvent.Subscribe(OnLeave)

    OnBoard(Agent : agent):void =
        set RiderCount += 1
        Print("Riders aboard: {RiderCount}")

    OnLeave(Agent : agent):void =
        set RiderCount -= 1
        Print("Riders aboard: {RiderCount}")

Gotchas

• DestroyedEvent / VehicleDestroyedEvent carry no agent. They are listenable(tuple()), so the handler must take no parameters (OnBusDestroyed():void). Writing OnBusDestroyed(X : agent) will not match and won't compile.
• Use SpawnedEvent, not VehicleSpawnedEvent. Both exist, but VehicleSpawnedEvent and VehicleDestroyedEvent are deprecated tuple() events. Prefer SpawnedEvent (gives you the fort_vehicle) and DestroyedEvent.
• Enter/exit events hand you a plain agent, not ?agent. AgentEntersVehicleEvent is listenable(agent), so no if (A := Agent?) unwrap is needed — just use Agent. Contrast this with trigger_device.TriggeredEvent, which IS ?agent and DOES need unwrapping.
• Handlers can't Sleep. Event handlers are ordinary methods, not <suspends>. To wait before respawning, spawn a separate <suspends> helper as in the walkthrough.
• RespawnVehicle destroys the old bus first. It's not additive — calling it repeatedly leaves you with exactly one bus, not many.
• AssignDriver needs a valid occupant context. Assigning a driver only makes sense for an agent who is in (or boarding) the vehicle; calling it on a random faraway agent has no useful effect.
• Bind every @editable in the Details panel. An unbound spawner field defaults to an empty device and your Enable()/RespawnVehicle() calls will silently do nothing.