vehicle_spawner_armored_transport_device: Roll Out an Armored Convoy

Overview

The vehicle_spawner_armored_transport_device is a specialized vehicle_spawner_device that places a single armored transport vehicle on your island and lets you control it from Verse. It is the device you reach for when you want an escort/convoy mission: a tanky, multi-seat vehicle that a squad rides while defending an objective, plus a clear signal whenever a player boards, bails, or the transport is destroyed.

Because it inherits everything from vehicle_spawner_device, the API is the same one shared by tanks, UFOs, SUVs, and every other vehicle spawner — so what you learn here transfers directly. The methods let you Enable/Disable the spawner, force a specific player into the driver seat with AssignDriver, blow the vehicle up with DestroyVehicle, and bring a fresh one back with RespawnVehicle. The events tell you when an agent enters or exits, when a fort_vehicle spawns, and when one is destroyed.

Reach for it when you want game logic tied to the state of a vehicle — for example, starting a timer when the convoy is boarded, awarding points when the squad survives, or instantly recovering the vehicle if it is destroyed mid-mission.

API Reference

vehicle_spawner_armored_transport_device

Specialized vehicle_spawner_device that allows an armored transport 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_transport_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 "escort the transport" loop. The mission button enables the spawner and forces the first interacting player into the driver seat. While players ride, we react to boarding and bailing. If the transport is destroyed, we automatically respawn a fresh one so the mission can continue.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Vehicles }
using { /Fortnite.com/Characters }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/UI }
using { /UnrealEngine.com/Temporary/SpatialMath }

# Escort mission controller for an armored transport.
convoy_mission := class(creative_device):

    # The armored transport spawner placed in the level.
    @editable
    Transport : vehicle_spawner_armored_transport_device = vehicle_spawner_armored_transport_device{}

    # A button players press to start the mission and become driver.
    @editable
    StartButton : button_device = button_device{}

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

    OnBegin<override>()<suspends> : void =
        # Start with the spawner off until the mission begins.
        Transport.Disable()

        # Wire up all the vehicle lifecycle events.
        Transport.AgentEntersVehicleEvent.Subscribe(OnEnter)
        Transport.AgentExitsVehicleEvent.Subscribe(OnExit)
        Transport.SpawnedEvent.Subscribe(OnSpawned)
        Transport.DestroyedEvent.Subscribe(OnDestroyed)

        # The button kicks off the mission.
        StartButton.InteractedWithEvent.Subscribe(OnStartPressed)

    # Player pressed the start button: turn the spawner on and seat them.
    OnStartPressed(Agent : agent) : void =
        # Enable so a vehicle exists to drive.
        Transport.Enable()
        # Bring a fresh transport in immediately.
        Transport.RespawnVehicle()
        # Put this player behind the wheel.
        Transport.AssignDriver(Agent)

    # Fired every time someone climbs aboard.
    OnEnter(Agent : agent) : void =
        if (Player := player[Agent], UI := GetPlayerUI[Player]):
            UI.ShowMessage(Msg("You boarded the armored transport!"))

    # Fired every time someone bails out.
    OnExit(Agent : agent) : void =
        if (Player := player[Agent], UI := GetPlayerUI[Player]):
            UI.ShowMessage(Msg("You left the transport — get back in!"))

    # Fired when a vehicle is spawned/respawned. Hands us the fort_vehicle.
    OnSpawned(Vehicle : fort_vehicle) : void =
        # The mission convoy is on the field; logic could hook the vehicle here.
        Print("Armored transport spawned and ready.")

    # Fired when the transport is destroyed — auto-recover it.
    OnDestroyed() : void =
        Print("Transport destroyed — sending a replacement.")
        Transport.RespawnVehicle()

Line by line:

• The @editable Transport field is what lets Verse talk to the placed device. Without declaring it as a field you cannot call its methods.
• In OnBegin we Disable() the spawner so no vehicle exists until the mission starts, then Subscribe each handler to its event. Handlers are methods declared at class scope.
• OnStartPressed receives the agent who pressed the button. We Enable(), call RespawnVehicle() to guarantee a fresh vehicle, then AssignDriver(Agent) to seat them.
• AgentEntersVehicleEvent/AgentExitsVehicleEvent hand us the boarding/bailing agent. We convert to player and grab the UI to show a localized message.
• SpawnedEvent hands us a fort_vehicle, the actual spawned vehicle object. DestroyedEvent takes no payload — when it fires we just call RespawnVehicle() to keep the mission alive.

Common patterns

Despawn the convoy when a round ends

Use DestroyVehicle to clean up the transport and Disable to stop new ones from appearing — perfect for an end-of-round reset.

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

round_cleanup := class(creative_device):

    @editable
    Transport : vehicle_spawner_armored_transport_device = vehicle_spawner_armored_transport_device{}

    @editable
    EndRoundButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        EndRoundButton.InteractedWithEvent.Subscribe(OnEndRound)

    OnEndRound(Agent : agent) : void =
        # Blow up the current transport...
        Transport.DestroyVehicle()
        # ...and stop the spawner from making more this round.
        Transport.Disable()

Count survivors using enter/exit events

Track how many players are currently riding by reacting to both vehicle events.

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

rider_counter := class(creative_device):

    @editable
    Transport : vehicle_spawner_armored_transport_device = vehicle_spawner_armored_transport_device{}

    var RiderCount : int = 0

    OnBegin<override>()<suspends> : void =
        Transport.AgentEntersVehicleEvent.Subscribe(OnEnter)
        Transport.AgentExitsVehicleEvent.Subscribe(OnExit)

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

    OnExit(Agent : agent) : void =
        if (RiderCount > 0):
            set RiderCount -= 1
        Print("Riders aboard: {RiderCount}")

React to a fresh spawn with SpawnedEvent

SpawnedEvent delivers the fort_vehicle itself, useful when you want to act on the new vehicle as soon as it appears.

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

spawn_logger := class(creative_device):

    @editable
    Transport : vehicle_spawner_armored_transport_device = vehicle_spawner_armored_transport_device{}

    OnBegin<override>()<suspends> : void =
        Transport.SpawnedEvent.Subscribe(OnSpawned)
        # Force the first spawn right away.
        Transport.Enable()
        Transport.RespawnVehicle()

    OnSpawned(Vehicle : fort_vehicle) : void =
        Print("A new armored transport entered the field.")

Gotchas

• You must declare the device as an @editable field. Calling vehicle_spawner_armored_transport_device.Enable() directly fails with 'Unknown identifier'. Place the device in the level and bind it in the Details panel.
• DestroyedEvent carries no payload. Its handler signature is OnDestroyed() : void — there is no agent or vehicle argument. The deprecated VehicleDestroyedEvent is listenable(tuple()); prefer DestroyedEvent.
• Prefer SpawnedEvent over VehicleSpawnedEvent. The latter is deprecated and only signals tuple() (no vehicle). SpawnedEvent hands you the actual fort_vehicle.
• RespawnVehicle destroys the old vehicle first. Anyone currently riding will be ejected when you respawn, so use it deliberately (e.g. only when the previous vehicle was destroyed).
• AssignDriver needs a valid vehicle to exist. Call Enable() and ensure a vehicle is spawned (e.g. via RespawnVehicle) before assigning a driver, or the assignment has nothing to seat the player in.
• Localized text for UI. A message parameter needs a localizes value — declare a helper like Msg<localizes>(S:string):message = "{S}" and call Msg("..."). There is no StringToMessage.
• Unwrap the agent. Event handlers receive an agent; convert to player with if (Player := player[Agent]): before grabbing player-specific things like the UI.