vehicle_spawner_baller_device: Roll Out the Baller

Overview

The vehicle_spawner_baller_device is a specialized vehicle_spawner_device that spawns the Baller — the spherical grapple-and-roll vehicle. Use it when you want a controllable hamster-ball vehicle in your mode: an obstacle-course racer, a 'last ball rolling' elimination game, or a traversal aid that respawns when destroyed.

Because it inherits from vehicle_spawner_device, it has all the base spawning controls (Enable, Disable, AssignDriver, DestroyVehicle, RespawnVehicle) plus events for agents entering/exiting and the vehicle spawning/being destroyed. The Baller adds one thing unique to its energy-based grapple: the RefillEnergy() method and the OutOfEnergyEvent.

Reach for this device whenever your gameplay revolves around a Baller you need to script — handing it to a winner, refueling it as a reward, or auto-respawning it so the action never stops.

API Reference

vehicle_spawner_baller_device

Specialized vehicle_spawner_device that allows a Baller vehicle 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_baller_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 Baller Arena: when a player enters the Baller we announce it and immediately top off its energy so they start with a full grapple charge. If the Baller runs out of energy mid-game we refill it once as a 'second wind'. When the Baller is destroyed we automatically respawn a fresh one so the arena never sits empty.

Drop a Baller Spawner device in your level and a Verse device, then set the @editable field to point at the spawner.

baller_arena := class(creative_device):

    # Set this in the Details panel to your placed Baller Spawner device.
    @editable
    BallerSpawner : vehicle_spawner_baller_device = vehicle_spawner_baller_device{}

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

    OnBegin<override>()<suspends>:void =
        # Make sure the spawner is active so a Baller is present.
        BallerSpawner.Enable()

        # React when a player climbs into the Baller.
        BallerSpawner.AgentEntersVehicleEvent.Subscribe(OnAgentEnters)

        # React when the Baller's grapple energy is depleted.
        BallerSpawner.OutOfEnergyEvent.Subscribe(OnOutOfEnergy)

        # React when the Baller is destroyed so we can respawn it.
        BallerSpawner.DestroyedEvent.Subscribe(OnDestroyed)

        # React when a fresh Baller is spawned.
        BallerSpawner.SpawnedEvent.Subscribe(OnSpawned)

    # AgentEntersVehicleEvent is listenable(agent) -> handler gets a plain agent.
    OnAgentEnters(Driver : agent) : void =
        Print("A player rolled into the Baller!")
        # Give the new driver a full grapple charge to start.
        BallerSpawner.RefillEnergy()

    # OutOfEnergyEvent is listenable(tuple()) -> handler takes no useful payload.
    OnOutOfEnergy() : void =
        Print("Baller out of energy — granting a second wind.")
        BallerSpawner.RefillEnergy()

    # DestroyedEvent is listenable(tuple()).
    OnDestroyed() : void =
        Print("Baller destroyed — respawning a fresh one.")
        BallerSpawner.RespawnVehicle()

    # SpawnedEvent is listenable(fort_vehicle) -> handler gets the new vehicle.
    OnSpawned(Vehicle : fort_vehicle) : void =
        Print("A new Baller is ready in the arena.")

Line by line:

• @editable BallerSpawner : vehicle_spawner_baller_device = vehicle_spawner_baller_device{} declares the field you bind to your placed device in the Details panel. You must declare a device as an @editable field to call it — a bare Device.Method() won't compile.
• BallerSpawner.Enable() in OnBegin turns the spawner on, ensuring a Baller exists at game start.
• Each .Subscribe(...) connects an event to a method handler. We subscribe in OnBegin so the hooks are live for the whole match.
• OnAgentEnters(Driver : agent) — AgentEntersVehicleEvent is listenable(agent), so the handler receives the agent directly (not optional). We call RefillEnergy() so every new pilot starts full.
• OnOutOfEnergy() — OutOfEnergyEvent is listenable(tuple()), so the handler takes no parameters. We refill once for a 'second wind'.
• OnDestroyed() calls RespawnVehicle(), which destroys any leftover vehicle and spawns a brand new Baller.
• OnSpawned(Vehicle : fort_vehicle) — SpawnedEvent sends the freshly spawned fort_vehicle, useful if you want to track or manipulate the specific vehicle instance.

Common patterns

Hand the Baller to a chosen winner with AssignDriver

Use AssignDriver to teleport a specific player straight into the Baller — perfect for a 'King of the Hill' reward.

baller_reward := class(creative_device):

    @editable
    BallerSpawner : vehicle_spawner_baller_device = vehicle_spawner_baller_device{}

    # A trigger the winner steps on to claim the Baller.
    @editable
    ClaimTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        BallerSpawner.Enable()
        ClaimTrigger.TriggeredEvent.Subscribe(OnClaim)

    # TriggeredEvent is listenable(?agent) -> unwrap the optional agent.
    OnClaim(MaybeAgent : ?agent) : void =
        if (Winner := MaybeAgent?):
            # Drop the winner into the driver seat of the Baller.
            BallerSpawner.AssignDriver(Winner)

Despawn the Baller when the round ends with DestroyVehicle

When a round timer ends, clear the Baller off the field and disable the spawner.

baller_round_end := class(creative_device):

    @editable
    BallerSpawner : vehicle_spawner_baller_device = vehicle_spawner_baller_device{}

    # Button or timer end event that signals round over.
    @editable
    EndButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        EndButton.InteractedWithEvent.Subscribe(OnRoundEnd)

    # InteractedWithEvent is listenable(agent).
    OnRoundEnd(Agent : agent) : void =
        # Remove the Baller from the world...
        BallerSpawner.DestroyVehicle()
        # ...and stop it from being driven again this round.
        BallerSpawner.Disable()

Track exits and clean up with AgentExitsVehicleEvent

Detect when a player leaves the Baller — for example to start a self-destruct timer on an abandoned vehicle.

baller_exit_watch := class(creative_device):

    @editable
    BallerSpawner : vehicle_spawner_baller_device = vehicle_spawner_baller_device{}

    OnBegin<override>()<suspends>:void =
        BallerSpawner.Enable()
        BallerSpawner.AgentExitsVehicleEvent.Subscribe(OnExit)

    # AgentExitsVehicleEvent is listenable(agent).
    OnExit(Leaver : agent) : void =
        Print("Player left the Baller — refilling for the next pilot.")
        BallerSpawner.RefillEnergy()

Gotchas

• RefillEnergy and OutOfEnergyEvent are Baller-specific. They live on vehicle_spawner_baller_device, not on the base vehicle_spawner_device. If you type the field as the base class, the compiler won't find them — declare your @editable field as vehicle_spawner_baller_device.
• Event payload shapes differ. AgentEntersVehicleEvent/AgentExitsVehicleEvent are listenable(agent) (handler takes a plain agent), SpawnedEvent is listenable(fort_vehicle), and OutOfEnergyEvent/DestroyedEvent are listenable(tuple()) (handler takes no parameter). A trigger's TriggeredEvent, by contrast, is listenable(?agent) and needs if (A := MaybeAgent?): to unwrap.
• Use the new events, not the deprecated ones. VehicleSpawnedEvent and VehicleDestroyedEvent still exist but are deprecated — prefer SpawnedEvent (which gives you the fort_vehicle) and DestroyedEvent.
• RespawnVehicle destroys first, then spawns. Calling it always removes the existing Baller before making a new one, so you don't need to call DestroyVehicle() beforehand.
• message params need a localized value. If you pass a Baller-related message to another device (like a HUD message device), declare a <localizes> helper such as ArenaText<localizes>(S:string):message = "{S}" — there is no StringToMessage.
• You must Enable() if the spawner starts disabled. A disabled spawner has no vehicle for AssignDriver or RefillEnergy to act on.