vehicle_spawner_armored_assault_tank_device: Tanks Your Players Earn and Drive

Overview

The vehicle_spawner_armored_assault_tank_device is a specialized vehicle_spawner_device that configures and spawns a single Armored Assault Tank. You place it in the level, then drive it from Verse to build real game loops:

• Reward loop — disable the spawner until a player wins a round, then Enable + RespawnVehicle to hand them a fresh tank.
• Boss vehicle — AssignDriver to drop an NPC or a chosen player straight into the gunner's seat.
• Score / streak tracking — subscribe to AgentEntersVehicleEvent to know who's piloting, and DestroyedEvent to know when the tank dies.
• Cleanup — DestroyVehicle to remove the tank at end of round so it doesn't litter the arena.

Because it inherits everything from vehicle_spawner_device, every method and event below is shared with the other vehicle spawners (tank, UFO, sportbike, etc.) — learn it once, reuse it everywhere.

API Reference

vehicle_spawner_armored_assault_tank_device

Specialized vehicle_spawner_device that allows an Armored Assault Tank 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_assault_tank_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 "King of the Tank" arena. The spawner starts disabled. When a player steps on a capture trigger, we spawn a tank and assign them as the driver. We track who's inside, and when the tank is destroyed we respawn a new one after the trigger fires again.

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

# King-of-the-Tank arena controller
tank_arena_device := class(creative_device):

    # Drag your Armored Assault Tank spawner here in the Details panel
    @editable
    TankSpawner : vehicle_spawner_armored_assault_tank_device = vehicle_spawner_armored_assault_tank_device{}

    # The capture pad players step on to claim the tank
    @editable
    CaptureTrigger : trigger_device = trigger_device{}

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

    OnBegin<override>()<suspends>:void =
        # Start with no tank in the arena
        TankSpawner.Disable()

        # When a player captures the pad, give them the tank
        CaptureTrigger.TriggeredEvent.Subscribe(OnCaptured)

        # React to vehicle lifecycle
        TankSpawner.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)
        TankSpawner.AgentExitsVehicleEvent.Subscribe(OnDriverExited)
        TankSpawner.SpawnedEvent.Subscribe(OnTankSpawned)
        TankSpawner.DestroyedEvent.Subscribe(OnTankDestroyed)

    # trigger TriggeredEvent hands us a ?agent — unwrap it before use
    OnCaptured(Agent : ?agent) : void =
        if (Player := Agent?):
            # Enable the spawner and force a fresh tank
            TankSpawner.Enable()
            TankSpawner.RespawnVehicle()
            # Put the capturing player directly in the driver seat
            TankSpawner.AssignDriver(Player)

    # AgentEntersVehicleEvent sends a plain agent (already unwrapped)
    OnDriverEntered(Driver : agent) : void =
        Print("A player took control of the tank")

    OnDriverExited(Driver : agent) : void =
        Print("The tank was abandoned")

    # SpawnedEvent sends the fort_vehicle that appeared
    OnTankSpawned(Vehicle : fort_vehicle) : void =
        Print("A fresh Armored Assault Tank rolled into the arena")

    # DestroyedEvent has no payload (tuple())
    OnTankDestroyed() : void =
        Print("The tank was destroyed — pad is open again")
        # Clean up and wait for the next capture
        TankSpawner.Disable()

Line by line:

• @editable TankSpawner : vehicle_spawner_armored_assault_tank_device — the field you bind to the placed device in the Details panel. Without this @editable field, calling TankSpawner.Enable() would fail with Unknown identifier.
• TankSpawner.Disable() in OnBegin — the arena begins empty.
• CaptureTrigger.TriggeredEvent.Subscribe(OnCaptured) — wires the pad to our handler.
• The four TankSpawner.*Event.Subscribe(...) lines hook the vehicle's lifecycle events to class methods.
• OnCaptured(Agent : ?agent) — the trigger event is listenable(?agent), so we get an optional agent. if (Player := Agent?) unwraps it; only then do we Enable, RespawnVehicle, and AssignDriver(Player).
• OnDriverEntered(Driver : agent) — AgentEntersVehicleEvent is listenable(agent), so the agent arrives already unwrapped, no ? needed.
• OnTankSpawned(Vehicle : fort_vehicle) — SpawnedEvent hands you the actual fort_vehicle, which you could use to query or move the spawned tank.
• OnTankDestroyed() — DestroyedEvent is listenable(tuple()), so the handler takes no parameters.

Common patterns

Force-respawn a tank on a timer

Use RespawnVehicle to keep a fresh tank available — the previous tank is destroyed automatically before the new one spawns.

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

tank_refresher_device := class(creative_device):

    @editable
    TankSpawner : vehicle_spawner_armored_assault_tank_device = vehicle_spawner_armored_assault_tank_device{}

    OnBegin<override>()<suspends>:void =
        TankSpawner.Enable()
        # Every 30 seconds, wipe and re-spawn a clean tank
        loop:
            Sleep(30.0)
            TankSpawner.RespawnVehicle()

Despawn the tank at the end of a round

DestroyVehicle removes the current tank without spawning a replacement — ideal for cleanup when an end-game trigger fires.

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

tank_cleanup_device := class(creative_device):

    @editable
    TankSpawner : vehicle_spawner_armored_assault_tank_device = vehicle_spawner_armored_assault_tank_device{}

    @editable
    EndRoundTrigger : trigger_device = trigger_device{}

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

    OnRoundEnd(Agent : ?agent) : void =
        # Remove the tank and shut the spawner down
        TankSpawner.DestroyVehicle()
        TankSpawner.Disable()

Count kills with the deprecated-vs-current destroyed events

You only need DestroyedEvent; VehicleDestroyedEvent is the older alias. Here we count how many tanks have been blown up this match.

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

tank_score_device := class(creative_device):

    @editable
    TankSpawner : vehicle_spawner_armored_assault_tank_device = vehicle_spawner_armored_assault_tank_device{}

    var TanksDestroyed : int = 0

    OnBegin<override>()<suspends>:void =
        TankSpawner.Enable()
        # Use the current event, not the deprecated VehicleDestroyedEvent
        TankSpawner.DestroyedEvent.Subscribe(OnTankKilled)

    OnTankKilled() : void =
        set TanksDestroyed = TanksDestroyed + 1
        Print("Tanks destroyed this match: {TanksDestroyed}")

Gotchas

• You must bind the device. The @editable field gives you a placeholder (vehicle_spawner_armored_assault_tank_device{}); the real placed device is wired in the Details panel. Calling methods on an unbound default does nothing useful.
• Event payloads differ. AgentEntersVehicleEvent / AgentExitsVehicleEvent are listenable(agent) (already unwrapped). SpawnedEvent is listenable(fort_vehicle). DestroyedEvent and VehicleDestroyedEvent are listenable(tuple()) — their handlers take no parameters. A trigger_device.TriggeredEvent, by contrast, is listenable(?agent) and must be unwrapped with if (P := Agent?):.
• Don't subscribe to the deprecated events. VehicleSpawnedEvent and VehicleDestroyedEvent still exist but are superseded by SpawnedEvent and DestroyedEvent. Prefer the new ones.
• RespawnVehicle destroys first. If you call it while a player is driving, that player is ejected as the old tank is removed. Use AssignDriver after RespawnVehicle to seat them in the new one.
• Enable doesn't always equal a spawned tank. Enabling the device makes it operational; call RespawnVehicle if you want to guarantee a tank exists right now.
• message params need localized text. Anywhere a UI/HUD method wants a message, use a <localizes> helper like StatusText("...") — there is no StringToMessage.
• No int↔float auto-convert. Sleep takes a float (30.0), not 30.