reboot_van_device: Bringing Teammates Back from the Brink

Overview

The Reboot Van device lets players bring eliminated teammates back into the game by collecting and cashing in Reboot Cards at the van. In Verse, the device is represented by reboot_van_device, which inherits from reboot_van_interface. Its drivable variant, vehicle_spawner_drivable_reboot_van_device, extends this with additional controls for the revival seat and the underlying vehicle.

When to reach for it:

• You want to enable or disable rebooting at specific moments (e.g., rebooting is only allowed during a 30-second window between waves).
• You need to react to a Reboot Card purchase — for example, to deduct gold from a player's score.
• You want to detect when a revive completes — for example, to grant the revived player a shield potion.
• You need to configure decay, recharge timers, or purchase options at runtime.

The core interface is reboot_van_interface, which provides:

• EnableReboot() / DisableReboot() — toggle the van on/off.
• IsEnabledReboot[] — a failable check for current state.
• RebootCardPurchaseEvent — fires when a player buys a Reboot Card.

The drivable variant (vehicle_spawner_drivable_reboot_van_device) adds:

• EnableRevive() / DisableRevive() — toggle the revival seat independently.
• IsEnabledRevive[] — check revival seat state.
• ReviveCompleteEvent — fires when a player is fully revived from DBNO.
• Configurable vars: CanPurchaseRebootCard, DecayRateMultiplier, RebootProgressDecay, RechargeTimer, RechargeTimerLength.

API Reference

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: A wave-defense mode where the Reboot Van is disabled by default. After each wave ends (simulated here by a trigger), the van becomes active for 20 seconds so teammates can revive fallen squadmates. When a Reboot Card is purchased, a message is broadcast. When a revive completes, the revived player is noted.

wave_reboot_manager_device := class(creative_device):

    # The drivable Reboot Van placed in your level
    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # A trigger_device the designer fires to signal "wave complete"
    @editable
    WaveEndTrigger : trigger_device = trigger_device{}

    # A hud_message_device to show status text
    @editable
    StatusHUD : hud_message_device = hud_message_device{}

    # How long the van stays active between waves (seconds)
    @editable
    RebootWindowSeconds : float = 20.0

    OnBegin<override>()<suspends> : void =
        # Start with the van disabled — no rebooting during combat
        RebootVan.DisableReboot()
        RebootVan.DisableRevive()

        # Subscribe to the wave-end trigger
        WaveEndTrigger.TriggeredEvent.Subscribe(OnWaveEnded)

        # Subscribe to reboot card purchases
        RebootVan.RebootCardPurchaseEvent.Subscribe(OnCardPurchased)

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

    # Called when the wave-end trigger fires
    OnWaveEnded(Agent : ?agent) : void =
        spawn { RunRebootWindow() }

    # Opens the van for RebootWindowSeconds, then closes it again
    RunRebootWindow()<suspends> : void =
        RebootVan.EnableReboot()
        RebootVan.EnableRevive()
        Sleep(RebootWindowSeconds)
        RebootVan.DisableReboot()
        RebootVan.DisableRevive()

    # Fires when any player purchases a Reboot Card
    OnCardPurchased(Buyer : agent) : void =
        # React to the purchase — e.g., log it, deduct currency, etc.
        # Here we just confirm the van is still enabled before acting
        if (RebootVan.IsEnabledReboot[]):
            # Van is active; purchase is valid
            spawn { AcknowledgePurchase(Buyer) }

    AcknowledgePurchase(Buyer : agent)<suspends> : void =
        # Brief pause, then check state again
        Sleep(0.1)
        # Additional logic (e.g., deduct score) would go here

    # Fires when a player finishes being revived
    OnReviveComplete(RevivedPlayer : agent) : void =
        # Grant the revived player a bonus or log the event
        spawn { HandleRevived(RevivedPlayer) }

    HandleRevived(RevivedPlayer : agent)<suspends> : void =
        Sleep(0.5)
        # e.g., trigger an item granter for the revived player
        # ItemGranter.GrantItem(RevivedPlayer)  ← wire up your own granter

Line-by-line highlights:

Common patterns

Pattern 1 — Conditional reboot: only allow rebooting if a team has fewer than 2 players alive

This snippet checks the van's enabled state and toggles it based on a custom game condition. Wire TeamCheckTrigger to a repeating trigger or a score event.

conditional_reboot_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # A trigger that fires periodically or when a player is eliminated
    @editable
    TeamCheckTrigger : trigger_device = trigger_device{}

    # Minimum alive count below which rebooting is allowed
    @editable
    MinAliveToAllowReboot : int = 2

    # Track alive count (set by your elimination logic)
    var AliveCount : int = 4

    OnBegin<override>()<suspends> : void =
        RebootVan.DisableReboot()
        TeamCheckTrigger.TriggeredEvent.Subscribe(OnCheckTeam)

    OnCheckTeam(Agent : ?agent) : void =
        if (AliveCount < MinAliveToAllowReboot):
            # Team is small — allow rebooting
            if (not RebootVan.IsEnabledReboot[]):
                RebootVan.EnableReboot()
        else:
            # Team has enough players — no rebooting
            if (RebootVan.IsEnabledReboot[]):
                RebootVan.DisableReboot()

Pattern 2 — Recharge timer manipulation: reset the recharge timer when a VIP player is eliminated

This pattern shows writing to RechargeTimer and RechargeTimerLength at runtime.

vip_reboot_reset_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # A trigger that fires when the VIP is eliminated
    @editable
    VIPEliminatedTrigger : trigger_device = trigger_device{}

    # How long the recharge takes normally (seconds)
    @editable
    NormalRechargeLength : float = 60.0

    # Penalty recharge when VIP is eliminated (seconds)
    @editable
    PenaltyRechargeLength : float = 120.0

    OnBegin<override>()<suspends> : void =
        # Set the default recharge length
        RebootVan.RechargeTimerLength = NormalRechargeLength
        VIPEliminatedTrigger.TriggeredEvent.Subscribe(OnVIPEliminated)

    OnVIPEliminated(Agent : ?agent) : void =
        # Punish the team: extend the recharge and reset the timer
        RebootVan.RechargeTimerLength = PenaltyRechargeLength
        RebootVan.RechargeTimer = PenaltyRechargeLength

Pattern 3 — Enable/disable the revival seat independently from rebooting

Some modes want players to be able to revive DBNO teammates but NOT cash in Reboot Cards (or vice versa). EnableRevive / DisableRevive are separate from EnableReboot / DisableReboot.

revive_only_mode_device := class(creative_device):

    @editable
    RebootVan : vehicle_spawner_drivable_reboot_van_device = vehicle_spawner_drivable_reboot_van_device{}

    # Trigger to switch into "revive only" mode
    @editable
    ReviveOnlyTrigger : trigger_device = trigger_device{}

    # Trigger to restore full reboot capability
    @editable
    FullRebootTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Start fully enabled
        RebootVan.EnableReboot()
        RebootVan.EnableRevive()

        ReviveOnlyTrigger.TriggeredEvent.Subscribe(OnReviveOnly)
        FullRebootTrigger.TriggeredEvent.Subscribe(OnFullReboot)

        # React to every completed revive
        RebootVan.ReviveCompleteEvent.Subscribe(OnReviveDone)

    OnReviveOnly(Agent : ?agent) : void =
        # Allow DBNO revives, but block card purchases
        RebootVan.DisableReboot()
        RebootVan.EnableRevive()

    OnFullReboot(Agent : ?agent) : void =
        RebootVan.EnableReboot()
        RebootVan.EnableRevive()

    OnReviveDone(RevivedPlayer : agent) : void =
        # Check revival seat is still enabled before acting
        if (RebootVan.IsEnabledRevive[]):
            spawn { PostReviveBonus(RevivedPlayer) }

    PostReviveBonus(RevivedPlayer : agent)<suspends> : void =
        Sleep(1.0)
        # e.g., grant a shield — wire your item_granter here

Gotchas

1. reboot_van_device vs vehicle_spawner_drivable_reboot_van_device

The plain reboot_van_device class (the static prop van) exposes only the reboot_van_interface methods. The drivable variant (vehicle_spawner_drivable_reboot_van_device) is a full vehicle spawner and adds EnableRevive, DisableRevive, IsEnabledRevive[], ReviveCompleteEvent, and all the configurable vars. If you need ReviveCompleteEvent or ReviveCompleteEvent, you must use vehicle_spawner_drivable_reboot_van_device as your field type.

2. IsEnabledReboot[] and IsEnabledRevive[] are failable — use them inside if

These are <decides> functions. Calling them outside a failure context is a compile error. Always write:

if (RebootVan.IsEnabledReboot[]):
    # van is on

Never call them as plain statements.

3. RebootCardPurchaseEvent sends agent, not ?agent

Unlike some device events that send ?agent, RebootCardPurchaseEvent sends a concrete agent. Your handler signature should be OnCardPurchased(Buyer : agent) : void = — no optional unwrap needed.

4. ReviveCompleteEvent also sends a concrete agent

Same as above — the revived player is a non-optional agent. No if (A := Agent?) unwrap required.

5. DecayRateMultiplier is ?float — check before setting

The var is typed ?float. If the device is configured without custom decay, this may be false (none). When writing to it, assign an option: RebootVan.DecayRateMultiplier := option{1.5}. Reading it requires an unwrap: if (Rate := RebootVan.DecayRateMultiplier?):.

6. RechargeTimer clamps between 0.0 and 3600.0

Setting RechargeTimer to a value outside that range is silently clamped. If there is no active timer, setting it does nothing. Make sure the van is in a recharging state before you try to manipulate the timer.

7. Always declare the device as an @editable field

You cannot write vehicle_spawner_drivable_reboot_van_device{}.EnableReboot() inline — that creates a detached instance with no connection to the placed device. The device must be declared as an @editable field and wired in the UEFN editor's Details panel.