vehicle_spawner_boat_device: Boats On Demand

Overview

The vehicle_spawner_boat_device is a specialized vehicle_spawner_device that spawns a configurable boat (the Motorboat) at its placement point. You reach for it whenever your mode needs water traversal on your terms: a race that hands each team a boat at the starting gate, a pirate-cove escape where the getaway boat only appears once an objective is complete, or an extraction map where leaving the boat triggers a checkpoint.

Because it derives from vehicle_spawner_device, it inherits the full vehicle-spawner surface: methods to Enable/Disable the spawner, RespawnVehicle to drop a fresh boat (destroying the old one first), DestroyVehicle to clear it, and AssignDriver to force a specific player into the driver seat. It also fires events when a boat spawns (SpawnedEvent), is destroyed (DestroyedEvent), and when agents enter or exit it (AgentEntersVehicleEvent / AgentExitsVehicleEvent).

The key thing to remember: a vehicle spawner manages one boat at a time. Calling RespawnVehicle always replaces the current boat rather than stacking new ones.

API Reference

vehicle_spawner_boat_device

Specialized vehicle_spawner_device that allows a boat 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_boat_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 dock that comes alive when the round starts. We place a vehicle_spawner_boat_device and a button_device on a pier. When the round begins we disable the spawner so there's no boat sitting idle. When a player presses the button, we enable the spawner and respawn a fresh boat, then assign that player as the driver so they're dropped straight into the seat. We log boat life-cycle moments to the HUD via a message device-free approach (using the events).

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

# A dock that hands the interacting player a freshly spawned boat.
boat_dock_device := class(creative_device):

    # The boat spawner placed on the pier.
    @editable
    BoatSpawner : vehicle_spawner_boat_device = vehicle_spawner_boat_device{}

    # The button a player presses to request a boat.
    @editable
    RequestButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        # Start with no boat available — the dock is "closed".
        BoatSpawner.Disable()

        # React to the button press.
        RequestButton.InteractedWithEvent.Subscribe(OnRequestBoat)

        # React to the boat life cycle.
        BoatSpawner.SpawnedEvent.Subscribe(OnBoatSpawned)
        BoatSpawner.DestroyedEvent.Subscribe(OnBoatDestroyed)
        BoatSpawner.AgentEntersVehicleEvent.Subscribe(OnDriverEntered)
        BoatSpawner.AgentExitsVehicleEvent.Subscribe(OnDriverExited)

    # Button handler. button_device.InteractedWithEvent sends an agent.
    OnRequestBoat(Agent : agent):void =
        # Open the dock and drop a fresh boat (replaces any existing one).
        BoatSpawner.Enable()
        BoatSpawner.RespawnVehicle()
        # Put the requesting player straight into the driver seat.
        BoatSpawner.AssignDriver(Agent)

    # SpawnedEvent sends the fort_vehicle that was spawned.
    OnBoatSpawned(Vehicle : fort_vehicle):void =
        Print("A boat has launched at the dock!")

    # DestroyedEvent sends an empty tuple.
    OnBoatDestroyed():void =
        Print("The dock's boat was destroyed.")

    OnDriverEntered(Agent : agent):void =
        Print("A player boarded the boat.")

    OnDriverExited(Agent : agent):void =
        Print("A player left the boat.")

Line by line:

• BoatSpawner : vehicle_spawner_boat_device and RequestButton : button_device are @editable fields — that's how you bind the placed devices in the UEFN Details panel. Without the editable field, calling BoatSpawner.Disable() would fail with Unknown identifier.
• In OnBegin we call BoatSpawner.Disable() so the round starts with the dock closed.
• We subscribe handlers to the button and to four spawner events. Subscriptions live in OnBegin; the handlers are methods at class scope.
• OnRequestBoat receives the interacting agent from the button. We Enable() the spawner, RespawnVehicle() to materialize the boat, then AssignDriver(Agent) to seat the player.
• OnBoatSpawned receives a fort_vehicle (the freshly spawned boat) — exactly what SpawnedEvent promises. OnBoatDestroyed takes no parameter because DestroyedEvent is a listenable(tuple()).
• AgentEntersVehicleEvent / AgentExitsVehicleEvent each hand us the boarding/leaving agent.

Common patterns

Despawn the boat when the round ends

Use a round_settings_device or any signal source, then call DestroyVehicle to clear the boat off the water. Here we wire a trigger to clean up.

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

cleanup_dock_device := class(creative_device):

    @editable
    BoatSpawner : vehicle_spawner_boat_device = vehicle_spawner_boat_device{}

    # A trigger that signals "round over".
    @editable
    EndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        EndTrigger.TriggeredEvent.Subscribe(OnRoundOver)

    # trigger_device.TriggeredEvent sends ?agent (optional).
    OnRoundOver(MaybeAgent : ?agent):void =
        # Remove the boat and shut the spawner down.
        BoatSpawner.DestroyVehicle()
        BoatSpawner.Disable()

Auto-respawn a boat the moment its old one is destroyed

Great for a race where the boat should always be ready. We listen to DestroyedEvent and immediately respawn.

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

always_ready_dock_device := class(creative_device):

    @editable
    BoatSpawner : vehicle_spawner_boat_device = vehicle_spawner_boat_device{}

    OnBegin<override>()<suspends>:void =
        BoatSpawner.Enable()
        BoatSpawner.RespawnVehicle()
        # Whenever a boat is destroyed, drop a fresh one.
        BoatSpawner.DestroyedEvent.Subscribe(OnBoatGone)

    OnBoatGone():void =
        BoatSpawner.RespawnVehicle()

Track who is currently aboard with the enter/exit events

This pattern keeps a count of riders so you could, e.g., open a gate only when the boat is empty.

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

rider_counter_device := class(creative_device):

    @editable
    BoatSpawner : vehicle_spawner_boat_device = vehicle_spawner_boat_device{}

    var RiderCount : int = 0

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

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

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

Gotchas

• SpawnedEvent vs VehicleSpawnedEvent. The deprecated VehicleSpawnedEvent / VehicleDestroyedEvent are listenable(tuple()) and carry no data. Prefer SpawnedEvent (gives you the fort_vehicle) and DestroyedEvent. Don't mix them up — handler signatures differ: a tuple() event handler takes no parameter, while SpawnedEvent's handler takes (Vehicle : fort_vehicle).
• Handler parameter shape must match the event. AgentEntersVehicleEvent is listenable(agent), so its handler is OnEnter(Agent : agent). A listenable(tuple()) event like DestroyedEvent needs a no-parameter handler OnBoatDestroyed(). Mismatches fail to compile.
• trigger_device sends ?agent, not agent. When you subscribe to a trigger, the handler receives an optional. Unwrap it with if (A := MaybeAgent?): before using the agent.
• RespawnVehicle replaces, it does not stack. Each spawner manages a single boat. Call it twice and you still have one boat — the old one is destroyed first. To have multiple boats, place multiple spawners.
• AssignDriver needs a boat to exist. Call RespawnVehicle() (or otherwise ensure a boat is present) before AssignDriver, or there's no vehicle to seat the player in.
• Disable stops spawning but doesn't delete an existing boat. If you want the water cleared, call DestroyVehicle() — Disable() alone just prevents future respawns.