vehicle_spawner_drivable_reboot_van_device: Revive Vans With Full Verse Control

Overview

The Drivable Reboot Van Spawner device (vehicle_spawner_drivable_reboot_van_device) combines two roles in one:

1. Vehicle spawner — it places a drivable Reboot Van on your island that players can enter, drive, and exit, just like any other vehicle spawner.
2. Reboot Van — it exposes a revival seat that teammates can use to bring back eliminated squad members.

Because it inherits from both vehicle_spawner_device and reboot_van_interface, you get the full vehicle event surface (AgentEntersVehicleEvent, AgentExitsVehicleEvent, SpawnedEvent, DestroyedEvent) plus the revival-specific API (EnableRevive, DisableRevive, IsEnabledRevive, ReviveCompleteEvent).

When to reach for it:

• You want a Reboot Van that roams the map (driven by an NPC or a player).
• You need to gate revivals behind a game condition (e.g., only allow revives after a certain round starts).
• You want to reward a team for capturing a zone by spawning a fresh Reboot Van for them.
• You need to track every revive that happens and update a scoreboard or trigger a cinematic.

API Reference

vehicle_spawner_drivable_reboot_van_device

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from vehicle_spawner_device.

vehicle_spawner_drivable_reboot_van_device<public> := class<concrete><final>(vehicle_spawner_device, reboot_van_interface):

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):

reboot_van_device

Allow players to bring eliminated teammates back into the game.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

reboot_van_device<public> := class<concrete><final>(creative_device_base, reboot_van_interface):

Walkthrough

Scenario: "Capture the Van" — a Reboot Van that only activates after a team captures a zone

In this scenario a trigger plate represents a capture zone. When a player steps on it:

1. The Reboot Van respawns (fresh HP, ready to drive).
2. The revival seat is enabled so teammates can be revived.
3. The capturing player is assigned as the driver automatically.
4. Every time a revive completes, a HUD message is displayed and the van is respawned to keep it at full health.
5. When the van is destroyed, the revival seat is disabled until the zone is captured again.

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

# Localised HUD helper
ReviveMessage<localizes>(S : string) : message = "{S}"

capture_the_van_device := class(creative_device):

    # Wire this to your Drivable Reboot Van Spawner in the editor
    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # Wire this to a Trigger device that acts as the capture zone
    @editable
    CapturePlate : trigger_device = trigger_device{}

    # Wire this to a HUD Message device to display revive notifications
    @editable
    HUDMessage : hud_message_device = hud_message_device{}

    OnBegin<override>()<suspends> : void =
        # Start with the revival seat OFF — players must capture the zone first
        RebootVan.DisableReboot()

        # Subscribe to the capture plate
        CapturePlate.TriggeredEvent.Subscribe(OnZoneCaptured)

        # Subscribe to revive completions
        RebootVan.RebootEvent.Subscribe(OnReviveComplete)

        # Subscribe to van destruction so we can lock revivals again
        RebootVan.DestroyedEvent.Subscribe(OnVanDestroyed)

        # Subscribe to the SpawnedEvent to confirm each spawn in the log
        RebootVan.SpawnedEvent.Subscribe(OnVanSpawned)

    # Called when a player steps on the capture plate
    OnZoneCaptured(Agent : ?agent) : void =
        if (A := Agent?):
            # Respawn the van fresh (destroys any existing one first)
            RebootVan.RespawnVehicle()
            # Enable the revival seat now that the zone is captured
            RebootVan.EnableReboot()
            # Assign the capturing player as the driver
            RebootVan.AssignDriver(A)

    # Called each time a teammate is fully revived
    OnReviveComplete(RevivedAgent : agent) : void =
        # Show a HUD notification
        HUDMessage.Show(RevivedAgent)
        # Respawn the van to restore its health after the revive sequence
        RebootVan.RespawnVehicle()

    # Called when the van is destroyed in combat
    OnVanDestroyed(_tuple : tuple()) : void =
        # Lock the revival seat until the zone is recaptured
        RebootVan.DisableReboot()

    # Called each time the van (re)spawns — receives the fort_vehicle
    OnVanSpawned(Vehicle : fort_vehicle) : void =
        # You could store Vehicle or query its state here
        # For now we just confirm the spawn happened
        Print("Reboot Van spawned.")```

### Line-by-line explanation

| Line(s) | What it does |
|---|---|
| `@editable RebootVan` | Declares the device reference so Verse can call its methods. **Required** — bare identifiers won't resolve. |
| `RebootVan.DisableRevive()` | Locks the revival seat at game start; players can't use it until the zone is captured. |
| `CapturePlate.TriggeredEvent.Subscribe(OnZoneCaptured)` | Hooks the trigger so any player stepping on the plate fires `OnZoneCaptured`. |
| `RebootVan.ReviveCompleteEvent.Subscribe(OnReviveComplete)` | Fires every time the van finishes reviving a DBNO player; the `agent` is the newly-revived player. |
| `RebootVan.DestroyedEvent.Subscribe(OnVanDestroyed)` | Fires when the van is destroyed; payload is `tuple()` so we use `_`. |
| `RebootVan.SpawnedEvent.Subscribe(OnVanSpawned)` | Fires on every spawn/respawn; payload is the live `fort_vehicle`. |
| `if (A := Agent?)` | Unwraps the `?agent` option before passing it to `AssignDriver`. |
| `RebootVan.RespawnVehicle()` | Destroys the existing van and spawns a fresh one — triggers `SpawnedEvent`. |
| `RebootVan.EnableRevive()` | Re-opens the revival seat after capture. |
| `RebootVan.AssignDriver(A)` | Puts the capturing player in the driver's seat immediately. |
| `HUDMessage.Show(RevivedAgent)` | Displays the HUD notification for the revived player. |

## Common patterns

### Pattern 1 — Gate the revival seat behind a round timer

Disable revivals for the first 60 seconds of a round, then enable them. Uses `EnableRevive` / `DisableRevive` and `IsEnabledRevive`.

```verse
using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/Patchwork }
using { /Verse.org/Simulation }

revive_gate_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    OnBegin<override>()<suspends> : void =
        # Ensure revive is off at round start
        RebootVan.DisableRevive()

        # Wait 60 seconds before opening the revival seat
        Sleep(60.0)

        # Only enable if it isn't already on (safe guard)
        if (not RebootVan.IsEnabledRevive[]):
            RebootVan.EnableRevive()

Key APIs used: DisableRevive, IsEnabledRevive (decides expression — call with [] inside an if), EnableRevive.

Pattern 2 — Track who enters and exits the van, then destroy it after 3 rides

Uses AgentEntersVehicleEvent, AgentExitsVehicleEvent, and DestroyVehicle.

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

three_rides_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    var RideCount : int = 0

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

    OnEnter(Agent : agent) : void =
        set RideCount += 1
        Print("Ride {RideCount} started.")

    OnExit(Agent : agent) : void =
        if (RideCount >= 3):
            # After 3 rides the van is permanently destroyed
            RebootVan.DestroyVehicle()

Key APIs used: AgentEntersVehicleEvent, AgentExitsVehicleEvent, DestroyVehicle.

Pattern 3 — Auto-assign a specific player as driver whenever the van respawns

Uses SpawnedEvent and AssignDriver. Useful when an NPC or VIP player should always be the driver.

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

auto_driver_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # A trigger that fires when the designated driver is identified
    @editable
    DriverTrigger : trigger_device = trigger_device{}

    var DesignatedDriver : ?agent = false

    OnBegin<override>()<suspends> : void =
        DriverTrigger.TriggeredEvent.Subscribe(OnDriverSelected)
        RebootVan.SpawnedEvent.Subscribe(OnVanSpawned)

    OnDriverSelected(A : ?agent) : void =
        if (Driver := A?):
            set DesignatedDriver = option{Driver}

    # Every time the van spawns, seat the designated driver immediately
    OnVanSpawned(Vehicle : fort_vehicle) : void =
        if (Driver := DesignatedDriver?):
            RebootVan.AssignDriver(Driver)

Key APIs used: SpawnedEvent (receives fort_vehicle), AssignDriver.

Gotchas

1. ?agent vs agent — always unwrap option events

TriggeredEvent on a trigger_device sends ?agent, not agent. Handlers for ReviveCompleteEvent and AgentEntersVehicleEvent send plain agent — no unwrap needed. Mix them up and you'll get a type mismatch at compile time. Always check the signature in the API Reference above.

2. IsEnabledRevive is a <decides> expression — call it with [] inside if

# WRONG — does not compile
if (RebootVan.IsEnabledRevive()):

# CORRECT
if (RebootVan.IsEnabledRevive[]):

<decides> functions use the [] call syntax and must appear inside a failure context (if, or, etc.).

3. RespawnVehicle destroys the current van first

Calling RespawnVehicle() fires DestroyedEvent before SpawnedEvent. If your OnVanDestroyed handler disables the revival seat, you must re-enable it inside OnVanSpawned (or after RespawnVehicle returns) or the new van will have revivals locked.

4. DestroyedEvent payload is tuple(), not agent

The van's DestroyedEvent sends tuple() — declare your handler as OnVanDestroyed(_ : tuple()) : void. Trying to receive an agent here is a compile error.

5. @editable is mandatory — you cannot construct the device in code

vehicle_spawner_drivable_reboot_van_device is <concrete><final> and lives in the UEFN scene. You must declare it as an @editable field and wire it in the editor. Any attempt to call methods on a bare identifier (not a field) will fail with Unknown identifier.

6. AssignDriver requires the van to exist

If you call AssignDriver before the van has spawned (or after DestroyVehicle), the call silently does nothing. Subscribe to SpawnedEvent and call AssignDriver from that handler to guarantee the van is present.

7. message parameters need a localised wrapper

If you pass text to any device that takes a message parameter (e.g., hud_message_device), you cannot pass a raw string. Declare a localised helper:

MyText<localizes>(S : string) : message = "{S}"

There is no StringToMessage function in Verse.