The Storm is Coming: Mastering the Advanced Storm Controller

You know the drill. You drop from the bus, loot up, and suddenly the purple wall of doom starts creeping in. In standard Battle Royale, that storm is a random number generator set by Epic. But on your island? You’re the god of weather.

In this tutorial, we’re ditching the "Basic Storm Controller" (which is like playing with the difficulty on Easy) and moving straight to the Advanced Storm Controller. This device lets you script the storm’s behavior, shrink it on command, and make sure players don’t just wander off into the void. We’ll teach you how to think about game state using Verse concepts, but we’ll do it by building a storm that actually feels like the real game.

What You'll Learn

• The Scene Graph: How devices live in the world and talk to each other (like players talking in party chat).
• Variables vs. Constants: Why some settings are locked in forever, and others change mid-game.
• The Advanced Storm Controller: How to configure a multi-phase storm that shrinks, moves, and damages.
• Beacons: The secret sauce for customizing specific storm phases.

How It Works

Before we write a single line of code, we need to understand the "Scene Graph." Think of your Fortnite island as a massive, hierarchical tree structure. At the top is the World. Hanging off the World are your islands. Hanging off your island are Entities (anything you place: traps, props, devices).

In Verse, everything is an object. But you don’t just "create" objects in thin air; you reference them.

Variables vs. Constants

Imagine you’re building a trap.

• A Constant is like the damage value of a shotgun. You pick it in the editor, and it never changes during the match. It’s baked in.
• A Variable is like your health. It starts at 100, but if you get shot, it changes. It’s dynamic.

When we build our storm, we’re going to use Variables to track which phase the storm is in, and Constants to define the rules of that phase (like how fast it shrinks).

The Advanced Storm Controller

The Basic Storm Controller is a "set it and forget it" device. The Advanced Storm Controller is the one that listens to signals. It can handle up to 50 phases. Each phase can have a different radius, speed, and damage. To make each phase unique, we use Beacons.

Think of a Beacon as a "phase tag." You tell the Controller: "When you hit Phase 3, look at Beacon A for instructions." Beacon A says, "Shrink to 50 meters and deal 5 damage per second."

Let's Build It

We aren't just going to place a device. We’re going to set up a scenario where the storm behaves exactly how we want. We’ll use the Advanced Storm Controller and link it to a Beacon to create a custom Phase 1.

Step 1: Place the Devices

1. Open your island in UEFN.
2. Go to the Devices tab.
3. Search for Advanced Storm Controller and place it anywhere (it’s invisible, so don’t worry about blocking your view).
4. Search for Advanced Storm Beacon and place it nearby.

Step 2: Configure the Beacon (The "Phase Rules")

Click the Advanced Storm Beacon. In the details panel, you’ll see options.

• Phase Index: Set this to 1. This tells the controller, "This beacon applies to Phase 1."
• Radius: Set this to 500.0 (or whatever size you want for the safe zone).
• Speed: Set how fast it shrinks.

Step 3: Link the Controller

Now, click the Advanced Storm Controller.

• Storm Phase: Leave this on Default for now, or set it to start at Phase 1.
• Beacons: You’ll see a list where you can assign beacons to phases. Add the beacon you just placed to Phase 1.

Step 4: The Verse Logic (The "Brain")

Here is the tricky part. The devices above handle the visuals and physics of the storm. But if you want the storm to start automatically when the match begins, or if you want to trigger a phase change via a button, you need Verse.

Below is a simple Verse script. This script doesn’t "create" the storm (the device does that), but it signals the controller to move to the next phase when a player enters a trigger zone. This is a common pattern: Event -> Logic -> Device Action.

# Import the necessary Fortnite frameworks
using { /Fortnite.com/Devices }
using { /Verse.org/Sim }

# This is our "Main" script. It runs when the game starts.
# Think of it as the "Game Start" event in the device editor.
script() =
    # We need to find our devices in the world.
    # In Verse, we use 'Get' to grab a reference to a device by its name.
    # If you named your controller "MyStormController" in the editor, use that name.
    storm_controller := Get<AdvancedStormControllerDevice>("MyStormController")
    trigger_zone := Get<TriggerVolumeDevice>("MyTriggerZone")

    # This function runs when the game starts
    OnStart() =
        # Print a message to the debug console (F8 in-game)
        Print("Storm is ready. Enter the zone to shrink it!")

    # This function runs when an agent (player) enters the trigger zone
    OnBeginPlay() =
        # Subscribe to the 'OnEnter' event of the trigger zone.
        # This is like saying: "When someone steps here, run this code."
        trigger_zone.OnEnter.Subscribe(OnPlayerEnter)

    # This is the function that runs when a player enters the zone
    OnPlayerEnter(entering_agent: Agent) =
        # Check if the thing entering is actually a player (agent)
        if entering_agent.IsAgent():
            # Signal the storm controller to advance to the next phase.
            # This is the "Variable" changing: Phase 1 -> Phase 2.
            # We use the 'Signal' method to tell the device what to do.
            storm_controller.SignalNextPhase()
            
            # Optional: Play a sound or spawn particles here!
            Print("Storm phase advanced! Good luck.")

Walkthrough of the Code

1. script() =: This is the container for your logic. Everything inside here belongs to this script.
2. Get<AdvancedStormControllerDevice>("MyStormController"): This is how Verse finds your device. Crucial: You must name the device in the UEFN editor exactly what you put in the quotes. If you don’t name it, Verse can’t find it.
3. OnBeginPlay(): This is the "Game Start" event. It’s where you set up your subscriptions.
4. trigger_zone.OnEnter.Subscribe(OnPlayerEnter): This is the core mechanic. We are linking a Device Event (someone entering a zone) to a Function (our code). This is the bridge between the visual world and the code world.
5. storm_controller.SignalNextPhase(): This tells the Advanced Storm Controller, "Hey, stop Phase 1 and start Phase 2." The controller looks at the Beacon assigned to Phase 2 and applies those settings (radius, damage, etc.).

Try It Yourself

Now that you have the basics, here’s a challenge to test your skills:

The Challenge: Modify the script above so that the storm only advances if the player has a specific item (like a Shield Potion) in their inventory. If they don’t have it, print "You need a potion to shrink the storm!"

Hint: You’ll need to use the Agent object’s inventory methods. Look up GetEquippedItems() or similar in the Verse API documentation. You can also use an if statement to check the count of potions.

Recap

• Scene Graph: Your island is a hierarchy. Devices are objects you reference by name.
• Variables: Things that change (like storm phase).
• Advanced Storm Controller: The powerhouse device that handles multi-phase storms.
• Beacons: The customizers that define what each phase looks like.
• Verse: The glue that connects events (like entering a zone) to actions (like advancing the storm).

You now have the tools to make a storm that doesn’t just happen—it reacts. Go make your players sweat.

References

• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-advanced-storm-controller-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-advanced-storm-controller-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/fortnite-glossary
• https://dev.epicgames.com/documentation/en-us/fortnite/storm-wars-in-fortnite-creative
• https://dev.epicgames.com/documentation/fortnite/verse-api/fortnitedotcom/devices