vehicle_spawner_tie_fighter_device: Pilot a TIE Fighter with Verse

Overview

The vehicle_spawner_tie_fighter_device is a specialized subclass of vehicle_spawner_device that manages a single TIE Fighter in your UEFN island. It solves a common creative problem: you want a vehicle to appear, disappear, or hand control to a specific player based on game logic — not just a static prop sitting in the world.

Reach for this device when you need to:

• Spawn or respawn the TIE Fighter on demand (e.g., after a round reset).
• Auto-assign a pilot so a specific player is instantly seated when the vehicle appears.
• React to boarding and exiting — start a timer when someone climbs in, award points when they land safely.
• Detect destruction — trigger an explosion effect or end a wave when the fighter goes down.

Because vehicle_spawner_tie_fighter_device inherits every method and event from vehicle_spawner_device, everything described here applies equally to other vehicle spawner types (UFO, Tank, Sports Car, etc.).

API Reference

vehicle_spawner_tie_fighter_device

Specialized vehicle_spawner_device that allows a TIE Fighter 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_tie_fighter_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

Scenario: Timed TIE Fighter Gauntlet

A player steps on a pressure plate to claim the TIE Fighter. The moment they board, a 30-second countdown begins. If the fighter survives the full 30 seconds, the player wins. If it's destroyed first, the round resets and the fighter respawns.

Place in UEFN:

1. Drop a vehicle_spawner_tie_fighter_device into your island.
2. Drop a trigger_device (the pressure plate) nearby.
3. Drop an end_game_device for the win condition.
4. Create a new Verse device and wire everything up via @editable fields.

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

# Timed TIE Fighter Gauntlet
# Place this device in your island, then assign the three @editable fields
# in the Details panel.
tie_fighter_gauntlet_device := class(creative_device):

    # The TIE Fighter spawner placed in the level
    @editable TieFighterSpawner : vehicle_spawner_tie_fighter_device = vehicle_spawner_tie_fighter_device{}

    # A trigger_device used as the "claim" pressure plate
    @editable ClaimPlate : trigger_device = trigger_device{}

    # An end_game_device that fires when the pilot survives
    @editable WinDevice : end_game_device = end_game_device{}

    # How long (seconds) the pilot must survive
    SurvivalTime : float = 30.0

    # Tracks whether a round is currently active
    var RoundActive : logic = false

    # Subscription handles to allow cleanup if needed
    var PlateSubscription : listenable_subscription(tuple(?agent)) = listenable_subscription{}
    var DestroyedSubscription : listenable_subscription(tuple()) = listenable_subscription{}
    var BoardedSubscription : listenable_subscription(tuple(agent)) = listenable_subscription{}
    var ExitedSubscription : listenable_subscription(tuple(agent)) = listenable_subscription{}
    var SpawnedSubscription : listenable_subscription(tuple(fort_vehicle)) = listenable_subscription{}

    OnBegin<override>()<suspends> : void =
        # Subscribe to the pressure plate — when a player steps on it,
        # we assign them as the TIE Fighter's driver.
        set PlateSubscription = ClaimPlate.TriggeredEvent.Subscribe(OnPlateClaimed)

        # React when the vehicle is destroyed mid-round
        set DestroyedSubscription = TieFighterSpawner.DestroyedEvent.Subscribe(OnFighterDestroyed)

        # React when a pilot boards the fighter
        set BoardedSubscription = TieFighterSpawner.AgentEntersVehicleEvent.Subscribe(OnPilotBoarded)

        # React when a pilot exits the fighter
        set ExitedSubscription = TieFighterSpawner.AgentExitsVehicleEvent.Subscribe(OnPilotExited)

        # React when the fighter successfully spawns/respawns
        set SpawnedSubscription = TieFighterSpawner.SpawnedEvent.Subscribe(OnFighterSpawned)

    # Called when a player steps on the claim plate
    OnPlateClaimed(Agent : ?agent) : void =
        if (A := Agent?):
            if (not RoundActive?):
                set RoundActive = true
                # Assign this player as the driver immediately
                TieFighterSpawner.AssignDriver(A)

    # Called every time the TIE Fighter spawns or respawns
    OnFighterSpawned(Vehicle : fort_vehicle) : void =
        # fort_vehicle is available here if you need to query it later
        # (e.g., attach effects, store a reference)
        set RoundActive = false

    # Called when a pilot boards — start the survival timer
    OnPilotBoarded(Agent : agent) : void =
        set RoundActive = true
        spawn { RunSurvivalTimer(Agent) }

    # Called when the pilot exits voluntarily
    OnPilotExited(Agent : agent) : void =
        # If they bail out, reset the round
        set RoundActive = false
        TieFighterSpawner.RespawnVehicle()

    # Called when the TIE Fighter is destroyed
    OnFighterDestroyed() : void =
        set RoundActive = false
        # Wait a moment, then respawn for the next attempt
        spawn { DelayedRespawn() }

    # Survival timer — if the pilot stays alive for SurvivalTime, they win
    RunSurvivalTimer(Agent : agent)<suspends> : void =
        Sleep(SurvivalTime)
        # Only award the win if the round is still active
        # (fighter wasn't destroyed during the wait)
        if (RoundActive?):
            set RoundActive = false
            WinDevice.Activate(Agent)

    # Respawn the fighter after a short delay
    DelayedRespawn()<suspends> : void =
        Sleep(3.0)
        TieFighterSpawner.RespawnVehicle()```

### Line-by-line highlights

| Line / block | What it does |
|---|---|
| `@editable TieFighterSpawner` | Binds the placed device; without `@editable` the identifier is unknown at runtime. |
| `ClaimPlate.TriggeredEvent.Subscribe(OnPlateClaimed)` | Wires the pressure plate to our handler — `TriggeredEvent` on `trigger_device` sends an `agent`. |
| `TieFighterSpawner.DestroyedEvent.Subscribe(OnFighterDestroyed)` | Uses the modern (non-deprecated) `DestroyedEvent`. |
| `TieFighterSpawner.SpawnedEvent.Subscribe(OnFighterSpawned)` | Receives the `fort_vehicle` reference — useful for future queries. |
| `TieFighterSpawner.AssignDriver(Agent)` | Seats the player in the fighter without them having to walk up to it. |
| `spawn { RunSurvivalTimer(Agent) }` | Runs the timer concurrently so `OnPilotBoarded` returns immediately. |
| `TieFighterSpawner.RespawnVehicle()` | Destroys the current fighter (if any) and spawns a fresh one. |

---

## Common patterns

### Pattern 1 — Enable / Disable the spawner based on team readiness

Only activate the TIE Fighter spawner once both teams have enough players. Disable it during intermission so no one can steal a ride.

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

# Enables the TIE Fighter spawner only when the game is live,
# and disables it during intermission.
tie_fighter_gate_device := class(creative_device):

    @editable TieFighterSpawner : vehicle_spawner_tie_fighter_device = vehicle_spawner_tie_fighter_device{}
    @editable GameStartTrigger : trigger_device = trigger_device{}
    @editable IntermissionTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Spawner starts disabled — configured in the device's Details panel
        # or explicitly here:
        TieFighterSpawner.Disable()

        GameStartTrigger.TriggeredEvent.Subscribe(OnGameStart)
        IntermissionTrigger.TriggeredEvent.Subscribe(OnIntermission)

    OnGameStart(Agent : agent) : void =
        TieFighterSpawner.Enable()

    OnIntermission(Agent : agent) : void =
        # Destroy the active fighter and lock the spawner
        TieFighterSpawner.DestroyVehicle()
        TieFighterSpawner.Disable()

Pattern 2 — Auto-assign the first player who touches a button

A button device grants the TIE Fighter to whoever presses it first, then locks out further presses until the fighter is destroyed.

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

# First player to press the button becomes the TIE Fighter pilot.
tie_fighter_claim_button_device := class(creative_device):

    @editable TieFighterSpawner : vehicle_spawner_tie_fighter_device = vehicle_spawner_tie_fighter_device{}
    @editable ClaimButton : button_device = button_device{}

    var FighterClaimed : logic = false

    OnBegin<override>()<suspends> : void =
        ClaimButton.InteractedWithEvent.Subscribe(OnButtonPressed)
        # Re-enable claiming when the fighter is destroyed
        TieFighterSpawner.DestroyedEvent.Subscribe(OnFighterDestroyed)

    OnButtonPressed(Agent : agent) : void =
        if (not FighterClaimed):
            set FighterClaimed = true
            ClaimButton.Disable()
            TieFighterSpawner.AssignDriver(Agent)

    OnFighterDestroyed() : void =
        set FighterClaimed = false
        ClaimButton.Enable()
        # Respawn the fighter for the next pilot
        TieFighterSpawner.RespawnVehicle()

Pattern 3 — Track pilot stats with enter/exit events

Count how many seconds each player spends piloting the TIE Fighter and print a summary when they exit. Uses both AgentEntersVehicleEvent and AgentExitsVehicleEvent.

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

# Tracks time-in-vehicle per pilot session.
tie_fighter_stat_tracker_device := class(creative_device):

    @editable TieFighterSpawner : vehicle_spawner_tie_fighter_device = vehicle_spawner_tie_fighter_device{}

    # Timestamp (seconds since island start) when the current pilot boarded
    var BoardTime : float = 0.0
    var PilotActive : logic = false

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

    OnEnter(Agent : agent) : void =
        set PilotActive = true
        # GetSimulationElapsedTime returns seconds as float
        set BoardTime = GetSimulationElapsedTime()

    OnExit(Agent : agent) : void =
        if (PilotActive):
            set PilotActive = false
            ExitTime := GetSimulationElapsedTime()
            Duration := ExitTime - BoardTime
            # Duration is a float — use it to award score, update a tracker, etc.
            # (Shown here as a debug log; replace with your scoring logic)
            Print("Pilot session lasted {Duration} seconds")

Gotchas

1. Always use @editable — never construct the device inline

Declaring TieFighterSpawner : vehicle_spawner_tie_fighter_device = vehicle_spawner_tie_fighter_device{} without @editable gives you a blank default object, not the device placed in your level. The @editable attribute is what links the Verse field to the actual placed device.

2. DestroyedEvent vs VehicleDestroyedEvent

VehicleDestroyedEvent and VehicleSpawnedEvent are deprecated. Always subscribe to DestroyedEvent and SpawnedEvent instead. SpawnedEvent has the added bonus of delivering the fort_vehicle reference, which the deprecated version does not.

3. DestroyedEvent sends tuple(), not an agent

DestroyedEvent on vehicle_spawner_tie_fighter_device is typed listenable(tuple()) — your handler signature must be OnFighterDestroyed() : void, not OnFighterDestroyed(Agent : agent) : void. Mismatching the signature causes a compile error.

4. AgentEntersVehicleEvent sends a plain agent, not ?agent

Unlike some device events that send ?agent (optional), both AgentEntersVehicleEvent and AgentExitsVehicleEvent send a non-optional agent. No unwrapping needed — use the value directly.

5. RespawnVehicle destroys the existing fighter first

Calling RespawnVehicle() when a fighter is already active will destroy it before spawning the new one. This fires DestroyedEvent. If your DestroyedEvent handler also calls RespawnVehicle(), you'll create an infinite loop. Guard with a flag (e.g., RoundActive) before respawning.

6. AssignDriver requires the vehicle to already exist

AssignDriver seats the agent in the current vehicle. If you call it before the vehicle has spawned (e.g., before SpawnedEvent fires), nothing happens. Either call it inside a SpawnedEvent handler or ensure the spawner's Auto Spawn setting is on so the vehicle exists at round start.

7. int ↔ float conversions are manual

Verse does not auto-promote int to float. If you're doing arithmetic with GetSimulationElapsedTime() (which returns float) and an integer counter, cast explicitly with Int * 1.0 or use float literals (30.0, not 30).