Sky High Chaos: The Biplane Spawner Tutorial

So you want to turn your island into a dogfighting arena, a flying race track, or just a way to let your friends escape the storm in style? The Biplane Spawner is your ticket to the clouds. It’s not just about dropping a vehicle; it’s about controlling when, where, and who gets to fly.

In this tutorial, we’re going to build a "Sky Gate." It’s a system where players walk through a trigger zone, and poof—a biplane spawns right in front of them, ready to take off. We’ll also look at how to use Verse (Epic’s programming language for Fortnite islands) to make this happen dynamically, rather than just placing a plane in the editor and hoping for the best.

What You'll Learn

• What a Biplane Spawner is: The device that conjures a flying vehicle out of thin air.
• The Scene Graph & Hierarchy: Understanding how devices relate to each other (like a team roster).
• Verse Basics: Writing a simple script to connect a Trigger to a Spawner.
• Game Design: How to create a "pay-to-fly" or "zone-to-fly" mechanic.

How It Works

Before we write code, let’s break down the pieces using mechanics you already know.

The Biplane Spawner: The "Bus" for Vehicles

Think of the Biplane Spawner like the Battle Bus, but instead of dropping you into the map, it drops a vehicle onto your island. When you place this device in UEFN (Unreal Editor for Fortnite), it doesn’t show the plane immediately. It’s like a reservation ticket. The plane exists in the "void" until you tell the game to spawn it.

The Trigger: The "Gate"

A Trigger is a 3D box you place in the world. When a player walks into it, it fires an event. Think of it like a pressure plate in a trap or a zone in a race. If you step on it, something happens.

Verse: The "Game Logic"

If the Spawner is the car and the Trigger is the key, Verse is the engine that connects them. Verse is a programming language that lets you tell the game: "When Player A hits Trigger B, Spawn Vehicle C."

Without Verse, you’d have to place the plane manually in the editor. With Verse, you can make the plane appear only when a player reaches a certain score, or only after a timer counts down.

The Scene Graph: The "Team Roster"

In UEFN, every device (Spawner, Trigger, Timer) is part of the Scene Graph. Imagine the Scene Graph as a spreadsheet of every object in your game. Each object has a Name (like "Player1" or "SpawnPoint_A"). When we write Verse code, we refer to these names to tell specific devices what to do. If you have three Biplane Spawners, you must rename them (e.g., "Biplane_Spawn_1", "Biplane_Spawn_2") so Verse knows which one to activate.

Let's Build It

We are going to build a Sky Gate.

1. Place a Trigger where you want the plane to appear.
2. Place a Biplane Spawner nearby (facing the direction you want the player to fly).
3. Write Verse code to link them.

Step 1: Setup in UEFN

1. Open your island in UEFN.
2. Go to the Devices tab.
3. Search for Trigger and place it on the ground. Make it big enough for a player to walk through.
4. Search for Biplane Spawner. Place it a few meters in front of the Trigger. Important: Rotate it so the nose points in the direction you want the player to fly.
5. Rename the Devices:
   • Click the Trigger. In the Details panel, find the Name field. Change it to SkyGateTrigger.
   • Click the Biplane Spawner. Change its Name to BiplaneSpawn.
   • Why? If you don’t rename them, Verse won’t know which specific trigger or spawner you’re talking about. It’s like trying to call your friend "Hey You" in a crowded room.

Step 2: The Verse Code

Now, we need a Verse script. Create a new Verse file in your project folder (or use the Verse Editor if you’re on the latest build). We’ll call this script SkyGateLogic.

Here is the code. Don’t worry if it looks alien; we’ll break it down line by line.

# SkyGateLogic.verse
# This script connects a Trigger to a Biplane Spawner.

use EngineLibs.Core
use DevicesLib.Trigger
use DevicesLib.BiplaneSpawner

# This is our main "Actor" (the thing that runs the logic)
# Think of an Actor as a specific device or object that has a job.
actor SkyGateLogic:
    # These are "Properties" - the devices this script controls.
    # We tell Verse which devices to watch by name.
    trigger_device: TriggerDevice = Self.GetParent().FindDevice<TriggerDevice>("SkyGateTrigger")
    biplane_spawner: BiplaneSpawnerDevice = Self.GetParent().FindDevice<BiplaneSpawnerDevice>("BiplaneSpawn")

    # This is a "Function" (a set of instructions).
    # We call this function when the trigger is hit.
    on_trigger_hit():
        # 1. Spawn the Biplane
        # The "Spawn" function creates the vehicle at the spawner's location.
        biplane_spawner.Spawn()
        
        # 2. Optional: Tell the player something happened
        # We can use a HUD Message device if we had one linked, 
        # but for now, let's just spawn the plane.
        print("Biplane spawned! Fly safe!")

Step 3: Connecting the Dots

The code above defines what happens, but we need to tell Verse when to run it. We do this by linking the Trigger’s event to our function.

In Verse, this is often done in the BeginPlay function or by setting up an Event Binding. Since we want this to happen every time someone walks through, we need to bind the trigger's "OnOverlap" event to our on_trigger_hit function.

Here’s the more complete version that actually wires it up:

What’s Happening Here?

1. actor SkyGateLogic: This creates a new "controller" for our island. It’s like assigning a new staff member to the Sky Gate.
2. my_trigger: TriggerDevice = ...: This line tells Verse: "Find the device named SkyGateTrigger in the scene graph and store it in a variable called my_trigger." A variable is just a box where we store information (in this case, the reference to the trigger device).
3. on_begin_play(): This is a special function that runs once when the game starts. It’s like the "Start Button" on the console.
4. my_trigger.OnOverlap.Add(delegate(): ...): This is the magic.
   • OnOverlap is an Event. An event is a signal that something happened (like a player stepping on a pressure plate).
   • .Add(delegate(): ...) is how we attach our code to that signal. We’re saying, "Hey Trigger, whenever you overlap with a player, execute the code inside these brackets."
   • The code inside (my_biplane.Spawn()) tells the Biplane Spawner to create the vehicle.

Try It Yourself

Now that you have the basics, try to expand the system.

Challenge: Add a Timer device to your island. Modify the Verse code so that the Biplane only spawns if a player hits the trigger after 10 seconds have passed.

Hint: You’ll need to:

1. Place a Timer device and name it CountdownTimer.
2. In Verse, find the Timer device.
3. Use the Timer’s OnTimeout event to set a boolean variable (a true/false switch) to true after 10 seconds.
4. In your trigger’s delegate, check if that boolean is true before spawning the plane.

If you get stuck, remember: Variables are just boxes. Events are signals. Functions are instructions. Keep it simple.

Recap

• The Biplane Spawner creates a flying vehicle at a specific location.
• Verse allows you to connect devices (like Triggers) to actions (like Spawning).
• Renaming devices is crucial so Verse can find them in the Scene Graph.
• Events (like OnOverlap) are the triggers that start your code.
• Variables store the references to your devices so you can control them.

Now go forth and fill the skies with chaos. Or at least, fill them with one biplane. One is a start.

References

• https://dev.epicgames.com/documentation/en-us/fortnite/using-biplane-spawner-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-biplane-spawner-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-devices-in-fortnite
• https://dev.epicgames.com/documentation/en-us/fortnite/timer-device-design-examples-in-fortnite