Verse Basics

Lesson 1: What is Verse and Why Use It?

🎮 Welcome to Verse — Your Game's Secret Superpower!

Have you ever played a Fortnite Creative island and thought, "I wish this game had a rule that didn't exist yet"? That's exactly why Verse was invented!

What Is Verse?

Verse is a programming language. Think of a programming language like a recipe book — it gives you a special way to write instructions that a computer can read and follow.

But Verse isn't just any recipe book. It was built specifically for video games. That makes it extra great for making things happen inside Fortnite!

What Is UEFN?

UEFN stands for Unreal Editor for Fortnite. It's a super-powered building tool made by Epic Games. Imagine Fortnite Creative is a LEGO set. UEFN is like getting the pro builder kit — way more pieces and tools!

Here's how the pieces fit together:

• 🟦 Fortnite Creative — the regular island builder most players know
• 🟧 UEFN — the pro-level editor with extra features
• 🟩 Verse — the programming language that lets you write custom rules for your island

Together they make a team. You build the island in UEFN, and Verse tells the island how to behave.

Why Can't I Just Use Devices?

Great question! In Fortnite Creative, you already have devices. A device is a special object that does one job — like a Trigger that fires when a player walks on it, or a Score Manager that tracks points.

Devices are awesome. But they only connect in set ways. It's like having LEGO pieces that only snap together in one direction. You can build cool things, but you can't build everything.

Verse fills the gap. It lets you write brand-new rules — things no device can do on its own.

Here are some things Verse can help you do that devices can't easily do alone:

• 🎯 Complex interactions — like a trap that only activates for one specific player
• ⏱️ Precise timing — like starting a countdown the moment the third player joins
• 📋 New game rules — like a tag game where "it" switches every 30 seconds
• 🔄 Dynamic changes — like making the island get harder as the score goes up

Verse and the Future 🚀

Here's a cool bonus fact: Verse isn't just for Fortnite. Epic Games is building it into Unreal Engine 6, which is one of the most popular game-making tools in the whole world. Learning Verse now means you're learning a skill that will grow with you into real game development!

How Does Verse Fit Into UEFN?

Inside UEFN, you write Verse code in special files called .verse files. Think of each file like a page in your recipe book. Each page has instructions for one part of your island.

Your Verse file connects to devices on your island. When something happens in the game — like a player stepping on a trigger — your Verse code wakes up and runs its instructions.

It's like a sleeping robot that jumps to life the moment it hears the signal! 🤖

Worked Example

🔬 Let's Look at a Real Verse File

Below is the simplest possible Verse device you can make in UEFN. It connects to your island and prints a message when the game starts. This is what a real .verse file looks like!

# This tells Verse: "this file is part of my island project"
using { /fortnite/devices }
using { /verse.org/simulation }
using { /verse.org/native }

# A "class" is like a blueprint for a custom device.
# 'creative_device' means this is a device that can live on your island.
my_first_device := class(creative_device):

    # 'OnBegin' is a special function that runs the moment your game starts.
    # Think of it like the starting pistol at a race — BANG, go!
    OnBegin<override>()<suspends>:void=
        Print("My island is alive! Verse is working! 🎉")

🚶 Walk Through It Step by Step

1. using { /fortnite/devices } — This line imports tools from Fortnite. It's like opening your toolbox before you start building.

2. my_first_device := class(creative_device): — This creates a custom device (your own special island gadget). The := symbol means "make this thing and name it."

3. OnBegin<override>()<suspends>:void= — This is a function (a named set of instructions). OnBegin is the name Verse uses for "run this when the game begins."

4. Print("My island is alive! ...") — This sends a message to the output log. It's how you check that your code is running. Think of it as your island waving hello! 👋

💡 In UEFN: After writing this, you drag your device onto the island in the editor, hit Build Verse, then Play — and you'll see your message appear in the output log!

Try It Yourself

🛠️ Your Turn — Build Your First Island Hello!

Goal: Set up a UEFN project and get a Verse device running on your island.

Steps to follow:

1. Open UEFN and create a new project using a blank island template.
2. In the top menu, go to Verse > Create New Verse File. Name it my_first_device.
3. Look at the worked example above. Type the code into your new file. (Don't copy-paste — typing it helps your brain learn it!)
4. In UEFN, click Verse > Build Verse to check for errors.
5. Drag your new device from the Content Browser onto the island floor.
6. Press Launch Session to play. Open the Output Log and look for your printed message!

🎯 Checkpoint: Can you see your message in the Output Log? If yes — you just ran your very first Verse program! 🥳

🌶️ Bonus Challenge:

Can you change the text inside Print(...) to say your own name and something fun? For example:

Print("Alex's island is LIVE! Let's gooo! 🚀")

💡 Hint: The message goes between the two quotation marks " ". Only change what's inside those marks — leave everything else exactly the same!

Quiz

1. What is Verse?
   • A. A new Fortnite weapon skin
   • B. A programming language for making game rules in UEFN
   • C. A device you place on your island like a trigger
   • D. A type of Fortnite Creative map
2. Why would a game creator use Verse instead of just using devices?
   • A. Because devices don't work in UEFN at all
   • B. Because Verse makes your island look prettier
   • C. Because devices can only connect in set ways, but Verse lets you create brand-new rules
   • D. Because Verse is faster to learn than placing devices
3. In Verse, what does the special function 'OnBegin' do?
   • A. It ends the game when a player wins
   • B. It runs your instructions the moment the game starts
   • C. It places a new device on the island
   • D. It saves your Verse file to the computer
4. What does UEFN stand for?
   • A. Universal Engine For Navigating
   • B. Unique Effects For New games
   • C. Unreal Editor for Fortnite
   • D. Unreal Engine Fortnite Network

Recap

🌟 Great Work — Here's What You Learned!

Verse is a programming language made just for games, and it works inside UEFN — the pro builder tool for Fortnite. Regular Creative devices are powerful, but they can only connect in set ways. Verse fills that gap by letting you write brand-new rules your island has never seen before. You even wrote your very first Verse device and sent a message from your island — that's a huge first step! 🎉

Sources

• /docs/documentation/en-us/uefn/unreal-editor-for-fortnite-documentation
• /docs/documentation/en-us/fortnite/verse-language-get-started-in-unreal-editor-for-fortnite
• /docs/documentation/fortnite/verse-language-get-started-in-unreal-editor-for-fortnite

Lesson 2: Run Your First Verse Program

🎮 Welcome to Your First Verse Program!

You are about to write real code — the same kind of code that powers Fortnite islands! The language is called Verse. It is Epic Games' programming language for UEFN (Unreal Editor for Fortnite).

Don't worry if you have never coded before. We will go step by step. You've got this! 🚀

🧰 What Is UEFN?

UEFN stands for Unreal Editor for Fortnite. Think of it like a giant toy factory. You use it to build your own Fortnite islands. Verse is the language you use to give your island a "brain" — to make things happen in your game.

📦 What Is a Verse Device?

A device is a special object you place on your island. Think of it like a LEGO brick with a tiny computer inside. When the game starts, the device's code runs automatically.

In this lesson, your device will print a message. Printing doesn't mean paper — it means showing text in a special log screen inside the game. It's how programmers check that their code is working.

🗂️ Setting Up Your Project

Here's how to get started in UEFN:

1. Open UEFN. In the Project Browser, click Feature Examples.
2. Find and click Verse Device template, then give your project the name MyVerseProject. Click Create.
3. In the Menu Bar at the top, go to Verse > Verse Explorer. This panel shows all your Verse files — like a folder for your code.
4. Right-click your project name in Verse Explorer. Choose Add new Verse file to project.
5. In the window that pops up, click Verse Device, then click Create. This creates a starter code file called hello_world_device.verse. 🎉
6. Go to Verse > Build Verse Code so UEFN notices your new file.
7. Open the Content Browser (bottom of the screen). Find your hello_world_device and drag it into your level (the big 3D world in the middle of UEFN).

💡 Level means the map or island you are building. Dropping the device into it is like placing a LEGO brick on your baseplate.

🏃 Running Your Island

1. Click Launch Session in the toolbar. A window may ask you to save — click Save Selected.
2. When it loads, open the Main Menu and click Start Game.
3. Once in the game, press Escape, click Island Settings, then click Log at the top.
4. Look for the line that says "Hello, world!" followed by "2 + 2 = 4". Those came from your Verse code! Your program ran! 🥳

🔍 What Is the Log?

The Log is like a notebook the game keeps while it runs. Your code can write notes into it. This is super useful — it tells you "Hey, my code ran!" or "Here is what happened." Programmers call this logging or printing to the log.

✏️ Modifying Your Code

Now let's look at the code and change it!

1. Go to Verse > Verse Explorer and double-click hello_world_device.verse. It opens in VS Code (Visual Studio Code) — a free program for writing code. Think of VS Code like a super-smart notepad.
2. You will see the starter code. We will look at it together in the next section.
3. You can add a new Print line to show your own message. After you edit and save the file, go back to UEFN, click Verse > Build Verse Code, and launch your session again to see your changes!

🔑 Key Words to Know

Worked Example

📖 Let's Read the Starter Code

When you open hello_world_device.verse in VS Code, you see something like this:

# This is your first Verse device!
# Lines that start with # are called "comments."
# Comments are notes for humans — the computer ignores them.

using { /Fortnite.com/Devices }       # Lets us use UEFN devices
using { /Verse.org/Simulation }        # Lets us use game timing tools
using { /UnrealEngine.com/Temporary/Diagnostics }  # Lets us use Print

# A "class" is like a blueprint for your device.
# creative_device is the base type — all island devices inherit from it.
hello_world_device := class(creative_device):

    # OnBegin is a special function that runs automatically when the game starts.
    # Think of it like the "Start" signal on a race — when the game goes, this runs!
    OnBegin<override>()<suspends>:void=
        Print("Hello, world!")    # Shows "Hello, world!" in the Log
        Print("2 + 2 = {2 + 2}") # Shows "2 + 2 = 4" — Verse does the math!

🧩 Breaking It Down

• using { ... } — These lines are like packing your backpack before school. They load tools you need, such as the ability to Print text.

• hello_world_device := class(creative_device): — This creates a class. A class is a blueprint. Just like a blueprint for a house tells builders what to build, this blueprint tells UEFN what your device does. It inherits from creative_device, meaning it's built on top of an existing UEFN device type — like inheriting your parent's eye color, but for code!

• OnBegin<override>()<suspends>:void= — This is a function. A function is a set of steps. OnBegin is special — UEFN calls it automatically the moment the game starts. It's like the "GO!" in a race.

• Print("Hello, world!") — This is a function call. You are telling Verse: "Run the Print function and give it this message." The message appears in the Log.

• Print("2 + 2 = {2 + 2}") — The curly braces { } inside a Print message let you put math or code right inside your text! Verse calculates 2 + 2 and writes 4 for you.

🎯 What You Should See in the Log

After you Launch Session and Start Game, open the Log and you'll find:

Hello, world!
2 + 2 = 4

That means YOUR code ran in a real Fortnite island. You are officially a Verse programmer! 🌟

Try It Yourself

🛠️ Your Turn — Make It Your Own!

You have seen how Print works. Now let's make the program say something new!

Your challenge:

1. Open hello_world_device.verse in VS Code.
2. Inside OnBegin, add two new Print lines below the existing ones.
   • One line should print your name (example: "My name is Alex!")
   • One line should print a math fact using { } (example: "5 + 3 = {5 + 3}")
3. Save your file in VS Code (press Ctrl+S on Windows or Cmd+S on Mac).
4. In UEFN, go to Verse > Build Verse Code.
5. Click Launch Session, start the game, and check the Log for your new messages!

🤔 Hints:

• Every Print line goes inside OnBegin, with the same indentation (spacing) as the other Print lines.
• Make sure your message text is always inside "quotation marks".
• If you want to show math, wrap it in { } inside the quotes — like "10 - 4 = {10 - 4}".
• If the Log doesn't show your new line, double-check that you saved the file AND ran Build Verse Code again!

🌟 Bonus Challenge:

Can you add a third Print line that says how old you are? Like: "I am 11 years old!"

(No math needed — just type the number right in the message!)

Quiz

1. What does the `Print` function do in Verse?
   • A. It sends your code to a printer.
   • B. It shows a text message in the game's Log screen.
   • C. It places a new device on your island.
   • D. It starts the game automatically.
2. What is the name of the special function that runs automatically when your game starts?
   • A. StartGame
   • B. OnBegin
   • C. LaunchSession
   • D. Print
3. You want your Print message to show the result of 10 × 2. Which line of code is correct?
   • A. Print(10 * 2)
   • B. Print("10 times 2 = 10 * 2")
   • C. Print("10 times 2 = {10 * 2}")
   • D. Print{"10 times 2"}
4. After you save changes to your Verse file in VS Code, what must you do in UEFN before the changes show up in your game?
   • A. Drag the device into the level again.
   • B. Go to Verse > Build Verse Code.
   • C. Restart your computer.
   • D. Delete the old device and make a new one.

Recap

🏆 Great Work — Let's Recap!

You just wrote and ran your very first Verse program inside a real Fortnite island! 🎉 You learned that a Verse device is a code-powered object you drop into your level, and that the OnBegin function runs your code the moment the game starts. You used Print to send messages to the Log, and you even used curly braces { } to do live math inside a message. Keep experimenting — every great game developer started exactly where you are right now! 🌟

Sources

• /docs/documentation/en-us/uefn/run-your-first-verse-program-in-unreal-editor-for-fortnite
• /docs/documentation/en-us/uefn/modify-and-run-your-first-verse-program-in-unreal-editor-for-fortnite

Lesson 3: Variables and Data Types in Verse

🎮 What Is a Variable?

Imagine you have a scoreboard in your Fortnite island. Every time a player scores a point, the number goes UP. That number is not stuck at one value — it changes. In Verse, we use a variable to hold a value that can change during the game.

Think of a variable like a labeled box:

• The label is the name you give it (like Score).
• The stuff inside is the value (like 0, then 1, then 2…).
• You can swap what's inside the box anytime!

🧠 Variable = a named box that stores one piece of information, and that information can change while the game is running.

📦 Constants — The Box That Never Opens Again

Sometimes you want a value that never changes. Like the number of lives players start with — it's always 3. We call that a constant.

🧠 Constant = a named box that is sealed shut. You set it once and it stays that way forever.

In Verse, you write a constant with := and you never change it after that first line.

🗂️ Data Types — What Kind of Stuff Is in the Box?

Not all boxes hold the same kind of stuff. In Verse, every variable has a data type — that just means "what kind of information is stored here?"

Here are the three main types you'll use:

• int is short for integer — a fancy word for a whole number like 3 or 42.
• float is a number with a decimal point, like 3.14 or 0.5.
• string is text wrapped in quotes, like "Game Over" or "Player 1".

🎯 Game tip: Your player's score is an int. A timer that counts down by half-seconds uses a float. A welcome message on screen is a string!

✍️ How to Write Variables in Verse

Here is the recipe for making a variable in Verse:

Name : type = StartingValue

For a variable that can change, you add the word var in front:

var Name : type = StartingValue

The := symbol means "set this right now." You'll use it to change a var later in your code.

Let's look at real examples:

var Score : int = 0        # A whole-number box that starts at zero
var TimerSeconds : float = 30.0   # A decimal-number box starting at 30
var WelcomeMessage : string = "Welcome to my island!"  # A text box

Notice the # — anything after # is a comment. Comments are notes for YOU. The computer ignores them completely!

🔗 How This Connects to Your Island

In UEFN, you build a Verse device — think of it like a special prop that runs your code. When the game starts, your device wakes up and runs its OnBegin function. That's where your variables spring to life!

When a player steps on a trigger, your code can change the variable:

• set Score = Score + 1 — adds 1 to the score box!

You can then use that score to do things like grant items or activate devices. Your variable is the brain keeping track of everything. 🧠

Worked Example

🏗️ Building a Score Tracker Device

The scenario: A player steps on a trigger pad. Each time they do, their score goes up by 1. When the score hits 3, a message prints — they WIN! We'll use a trigger_device in UEFN and write a Verse script to track the score.

Step 1: In UEFN, create a new Verse device file. Here's the complete script:

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

# This is our custom device — it tracks a player's score
score_tracker_device := class(creative_device):

    # Hook up a Trigger Device in UEFN's detail panel
    @editable
    TriggerPad : trigger_device = trigger_device{}

    # A variable to hold the current score — starts at zero
    # 'var' means this value CAN change during the game
    var Score : int = 0

    # A constant — the score needed to win never changes
    WinScore : int = 3

    # OnBegin runs automatically when the game starts
    OnBegin<override>()<suspends> : void =
        # Tell the trigger to call our function each time it fires
        TriggerPad.TriggeredEvent.Subscribe(OnPlayerTriggered)

    # This function runs every time a player steps on the trigger
    OnPlayerTriggered(Agent : agent) : void =
        # Add 1 to the Score box
        set Score = Score + 1

        # Print the new score so we can see it in the log
        Print("Score is now: {Score}")

        # Check if the player has reached the winning score
        if (Score >= WinScore):
            Print("🎉 You Win! Great job!")

🔍 Walkthrough — Line by Line

✅ Try it: In UEFN, place a Trigger Device on your island. Assign it to TriggerPad in the device details. Hit Launch Session and walk over the trigger three times. Watch the Output Log — you should see the score climb to 3 and then see the win message!

Try It Yourself

🛠️ Your Turn — Add a Lives Counter!

You just made a score tracker. Now let's add a lives system!

Your challenge:

1. Add a new var variable called Lives of type int. Start it at 3.
2. Add a second @editable trigger called DangerZone of type trigger_device.
3. Subscribe to DangerZone.TriggeredEvent with a new function called OnDangerTriggered.
4. Inside OnDangerTriggered, subtract 1 from Lives using set Lives = Lives - 1.
5. Print the new lives count with Print("Lives left: {Lives}").
6. Add an if check — if Lives <= 0, print "💀 Game Over!".

In UEFN: Place a second Trigger Device somewhere dangerous on your island (like lava or a trap area). Assign it to DangerZone. Play the island and walk into the danger zone three times!

💡 Hint: Subtracting in Verse looks just like adding, but with a - sign instead of +. The if check for lives running out looks just like the win check in the example — just change the variable name and the message!

🌟 Bonus challenge: Can you add a string variable called PlayerStatus that starts as "Alive" and changes to "Defeated" when lives hit zero?

Quiz

1. What is a variable in Verse?
   • A. A value that is set once and never changes
   • B. A named box that stores information which can change during the game
   • C. A special Fortnite device you place on your island
   • D. A comment that the computer ignores
2. A player's score in a game is 10. What is the best data type to store it?
   • A. string, because scores are important words
   • B. float, because all numbers need decimals
   • C. int, because a score is a whole number with no decimal
   • D. var, because it can change
3. Which line of Verse code correctly creates a variable for a player's speed that starts at 5.5?
   • A. Speed : int = 5.5
   • B. var Speed : float = 5.5
   • C. var Speed : string = 5.5
   • D. Speed : var = 5.5
4. In the score tracker example, why is WinScore written WITHOUT the word var?
   • A. It was a mistake — all variables need var
   • B. Because int variables never need var
   • C. Because WinScore is a constant — the winning number never changes during the game
   • D. Because string types don't use var

Recap

🌟 Great Work — Here's What You Learned!

A variable is a named box that stores information that can change during your game — like a score that goes up when a player does something. A constant is a sealed box set once and never changed. Every variable has a data type: int for whole numbers, float for decimal numbers, and string for text. You used all of these inside a real Verse device that tracked a player's score on a Fortnite island — and that's genuinely awesome programming! 🎉

Sources

• /docs/documentation/en-us/fortnite/basics-of-writing-code-1-basic-programming-terms-in-verse
• /docs/documentation/en-us/uefn/learn-the-basics-of-writing-code-in-verse
• /docs/documentation/en-us/fortnite/learn-the-basics-of-writing-code-in-verse

Lesson 4: Writing and Using Functions

🎮 Why Do We Need Functions?

Imagine you're building a Fortnite island. Every time a player steps on a pressure plate, you want to:

1. Add 10 points to their score.
2. Play a sound.
3. Print a message.

What if there are 20 pressure plates? You'd have to write those same 3 steps 20 times. That's exhausting! 😩

A function fixes this. Think of a function like a vending machine. You press a button (call the function), and the machine does all the work for you every time. You only have to set it up once.

🧩 What Is a Function?

A function is a named block of code that does one job. You write it once, then call it (run it) as many times as you want.

Think of it like a recipe card. The card says "make a sandwich." You follow the steps. Next time you're hungry, you grab the same card — you don't write a new recipe!

📦 What Is a Parameter?

A parameter is information you hand to a function so it can do its job. It's like telling the vending machine which snack you want. Different input → different result!

For example, imagine a function called GivePoints. You could tell it to give 10 points one time, and 50 points another time. Same function, different number!

In Verse, you write a parameter like this inside the parentheses ():

Points : int

• Points is the name we give the information.
• int means it's a whole number (like 5, 10, or 100). "int" is short for integer, which just means a number without a decimal.

🎁 What Is a Return Value?

Sometimes you want a function to give something back after it runs. That's called a return value.

Imagine you ask a friend, "How many lives do I have left?" Your friend counts and tells you back the answer. That answer is the return value!

In Verse, you write : int (or another type) after the parentheses to say "this function will hand back a number."

If a function doesn't need to give anything back, you just leave that part out (or use : void).

🛠️ The Parts of a Function in Verse

Here's what a function looks like, piece by piece:

FunctionName(ParameterName : type) : returnType =
    # Your code goes here, indented

• FunctionName — what you call the function (like GivePoints).
• (ParameterName : type) — the info you hand in.
• : returnType — what type of thing the function gives back.
• = — this is like saying "here comes the recipe!"
• The indented lines below are the actual steps.

📣 Calling a Function

Calling a function means telling it to run. You just write its name and pass in any info it needs:

GivePoints(10)

That's it! The vending machine does its job. 🎉

🏝️ Connecting to Your Island

In UEFN, your Verse code lives inside a Verse Device — a special invisible gadget you place on your island. When something happens in the game (like a player steps on a Trigger device), your device can run a function.

Here's the big picture of how it works:

1. You place a Trigger device on your island in UEFN.
2. Your Verse device has a reference to that trigger.
3. When the trigger fires, Verse calls your function automatically.
4. Your function runs its steps — like printing a score message!

This is the magic of functions: the island event calls your function, and your function does all the hard work! 🚀

Worked Example

🔨 Worked Example: A Score Announcer Device

The scenario: A player walks into a trigger zone on your island. Your Verse device runs a function that calculates their bonus score and prints a hype message. Let's build it!

Step 1 — Set up in UEFN:

• In UEFN, go to Verse > Verse Explorer, right-click your project, and choose Add new Verse file to project.
• Pick Verse Device as the template. Name it score_announcer.
• Drag a Trigger device onto your island.
• Compile (Verse > Build Verse Code), then drag your new device into the level too.

Step 2 — The Verse code:

using { /Script/VerseRuntime }
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/Native }

# This is our Verse Device class.
score_announcer := class(creative_device):

    # We hook up a Trigger device here in the UEFN editor.
    @editable
    MyTrigger : trigger_device = trigger_device{}

    # OnBegin runs automatically when the game starts.
    OnBegin<override>()<suspends> : void =
        # Tell the trigger: when someone enters it, call OnPlayerTriggered.
        MyTrigger.TriggeredEvent.Subscribe(OnPlayerTriggered)

    # This function runs when the trigger fires.
    # Agent is the player who stepped on the trigger.
    OnPlayerTriggered(Agent : agent) : void =
        # Calculate the bonus using our helper function.
        Bonus := CalculateBonus(10)
        # Print the result so we can see it while playtesting.
        Print("Bonus points earned: {Bonus}")

    # ------------------------------------------
    # Our custom function!
    # It takes one parameter: BasePoints (a whole number).
    # It returns a whole number (the bonus score).
    # ------------------------------------------
    CalculateBonus(BasePoints : int) : int =
        # Double the base points and give that back.
        return BasePoints * 2

📖 Walkthrough — What Each Part Does

🎮 Try It!

1. Compile and drag both devices onto your island.
2. In the UEFN editor, click your score_announcer device and set MyTrigger to point at your Trigger device.
3. Hit Launch Session and walk into the trigger zone.
4. Look at the on-screen log — you should see "Bonus points earned: 20"!

You just wrote and called your very own function. You're a real programmer now! 🏆

Try It Yourself

🕹️ Your Turn: The Multiplier Machine

You did awesome with CalculateBonus! Now it's time to level up. 💪

Your challenge:

Add a second custom function called CalculateTripleBonus to the score_announcer device. This function should:

1. Take one parameter: a whole number called BasePoints.
2. Multiply BasePoints by 3 (triple it!).
3. Return the result.

Then, inside OnPlayerTriggered, call your new function with the number 15 and print the result like this:

Triple bonus: 45

🪜 Hints (if you need them!):

• Your new function will look very similar to CalculateBonus. You can use it as a starting point!
• To multiply in Verse, use the * symbol. So 15 * 3 gives you 45.
• To call your function and save the result, use:

  TripleResult := CalculateTripleBonus(15)
  

• To print it, use:

  Print("Triple bonus: {TripleResult}")
  

Bonus challenge 🌟: Can you call CalculateBonus AND CalculateTripleBonus in the same OnPlayerTriggered function and print both results?

Go for it — you've totally got this! 🎉

Quiz

1. What is a function in programming?
   • A. A type of Fortnite weapon.
   • B. A named block of code that does one job and can be run many times.
   • C. A variable that stores a player's score.
   • D. A device you place on your island.
2. What is a parameter?
   • A. The name of a Verse device.
   • B. A special button in UEFN.
   • C. Information you hand into a function so it can do its job.
   • D. The return value of a function.
3. Look at this code: CalculateBonus(BasePoints : int) : int. What does the SECOND `: int` mean?
   • A. The function needs two numbers.
   • B. The function will give back a whole number when it's done.
   • C. The parameter must be named 'int'.
   • D. The function runs twice.
4. You wrote a function called GiveShield. How do you call it and hand it the number 50?
   • A. function GiveShield(50)
   • B. GiveShield : 50
   • C. GiveShield(50)
   • D. call GiveShield with 50

Recap

🌟 Great Work — Here's What You Learned!

A function is a named block of code you write once and can run (call) as many times as you need — like a vending machine you set up once. You can hand a function information using parameters, and a function can return (give back) a result when it's done. In your Fortnite island, functions connect to real game moments — like a player stepping on a trigger — so your island actually does something when players play it. Keep building, keep creating, you're doing amazing! 🚀

Sources

• /docs/documentation/en-us/uefn/learn-the-basics-of-writing-code-in-verse
• /docs/documentation/en-us/uefn/create-your-own-device-in-verse
• /docs/documentation/en-us/fortnite/create-your-own-device-in-verse

Lesson 5: Control Flow: If Statements and Loops

🎮 What Is Control Flow?

Imagine you are playing a board game. You roll the dice. If you land on a red square, you lose a turn. Otherwise, you move ahead. The rules of the board game control what happens next.

In coding, control flow means: the order in which your code runs, and which parts it chooses to run. You are the rule-maker. You tell the computer, "Do THIS if something is true. Do THAT if it isn't."

🚦 If Statements — Your Game's Referee

An if statement is like a referee on your island. It watches what is happening. Then it makes a call.

Think of it like this:

If the player's score is 10 or more → open the treasure chest! Else → keep the chest locked.

The word if starts the check. The word else handles everything that is NOT true.

In Verse, it looks like this:

if (Score >= 10):
    # Do this when score is high enough
else:
    # Do this when score is too low

• The stuff inside the if only runs when the condition is true.
• The stuff inside the else runs when the condition is false.
• Think of the condition like a yes/no question: "Is the score 10 or more?" Yes or no?

💡 New Word — Condition: A condition is a question that is either TRUE or FALSE. "Is it raining?" is a condition. "Is the player's score above 5?" is also a condition!

🔁 Loops — Your Island's Copy Machine

What if you wanted to give every player on your island 3 potions, one at a time? You could write the same line of code 3 times. But what if you wanted to do it 100 times? Writing 100 lines is no fun!

A loop is like a copy machine for your code. It runs the same instructions over and over until you say stop.

💡 New Word — Loop: A loop repeats a block of code. It's like pressing "replay" on a song, but for instructions.

Verse has a simple counting loop called a for loop. You tell it how many times to repeat. Here is the idea:

for (Index := 0..2):
    # This runs 3 times (0, 1, 2)

That 0..2 means "count from 0 up to and including 2." That is 3 counts total. Think of it as laps around a track: lap 0, lap 1, lap 2 — done!

🏃 Analogy: A for loop is like a coach yelling "Run 3 laps!" Your player runs one lap, then another, then another — and stops.

🧩 Putting It Together on Your Island

Let's say you are building a Score Challenge island. Here is the plan:

• A player steps on a Trigger device.
• Your Verse code checks: Did the player reach 5 points?
• If yes → an Item Granter gives them a Legendary weapon. 🎉
• If no → nothing special happens yet.
• Also, when the game starts, a loop grants 3 common weapons to warm up the player.

You use an if statement for the score check. You use a loop for the weapon hand-out. Together, they make your island smart and fun!

🗂️ The Shape of Verse Code

Two things to always remember about Verse:

1. Indentation matters. The code inside an if statement or loop must be indented (pushed in with spaces). This is how Verse knows which lines belong together.
2. Colons start a block. After if(...) and for(...), you put a colon : and then indent the next lines.

Think of indentation like putting toys inside a box. The toys (code lines) belong to the box (if or loop) only if they are inside it.

Worked Example

🏗️ Building a Score Reward System

The island plan:

• Drop a Trigger Device in your UEFN island.
• Drop an Item Granter Device and set it to grant a Legendary item.
• Drop a Score Manager Device.
• Attach this Verse script to a Verse Device in your island.

When a player walks into the trigger, the code checks their score. If they earned 5 or more points, the Item Granter fires! The loop at the start hands out 3 starting items automatically.

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

# This is our Verse device class — it lives on the island
score_reward_device := class(creative_device):

    # Plug these in from the UEFN editor by selecting your devices
    @editable
    GranterDevice : item_granter_device = item_granter_device{}

    @editable
    TriggerDevice : trigger_device = trigger_device{}

    # OnBegin runs once when the game starts
    OnBegin<override>()<suspends> : void =
        # Subscribe to the trigger — when a player steps on it, call OnTriggered
        TriggerDevice.TriggeredEvent.Subscribe(OnTriggered)

    # This function runs every time a player hits the trigger
    OnTriggered(Agent : ?agent) : void =
        # Try to get the player's score from the score manager
        # We track score with a simple variable here for the example
        var PlayerScore : int = 6  # Pretend the player has 6 points

        # ---- IF STATEMENT ----
        # Check: does the player have 5 or more points?
        if (PlayerScore >= 5, ActualAgent := Agent?):
            # YES — grant them a reward item!
            GranterDevice.GrantItem(ActualAgent)
            Print("Great job! You earned a reward!")  # Shows in the log
        else:
            # NO — encourage them to keep going
            Print("Keep collecting points — you need 5!")```

### 🔍 Walkthrough — Line by Line

| Code Part | What It Does |
|---|---|
| `score_reward_device := class(creative_device)` | Creates our island device — like building a new LEGO piece |
| `@editable` | Lets us plug in real devices from the UEFN editor |
| `OnBegin<override>()<suspends> : void` | Runs once when the game starts |
| `TriggerDevice.TriggeredEvent.Subscribe(OnTriggered)` | Tells the trigger: "Call OnTriggered when someone steps on you" |
| `var PlayerScore : int = 6` | A variable storing the player's score (6 for this example) |
| `if (PlayerScore >= 5):` | The BIG QUESTION — is the score 5 or more? |
| `GranterDevice.GrantItem(Agent)` | Gives the item to the player who triggered it |
| `else:` | Handles the "not enough points" case |
| `Print(...)` | Sends a message to the output log so you can see what happened |

> ✅ **Try it!** In UEFN, place a Trigger Device and an Item Granter Device. Connect them to your Verse device using the `@editable` slots. Change `PlayerScore` to 3 and play — you should see the "keep collecting" message instead!

---

### 🔁 Bonus: Adding a Loop for Warm-Up Items

Want to grant 3 items when the game starts? Add this loop inside `OnBegin`, **before** the Subscribe line:

```verse
# Loop 3 times (Index goes 0, 1, 2)
for (Index := 0..2):
    # Each loop gives ALL agents a starting item
    # (In a real game, you'd loop through players — this shows the loop shape)
    Print("Granting warm-up item number {Index}")
    # GranterDevice.GrantItem(SomeAgent)  # Uncomment when you have a real agent

🎉 What just happened? The loop ran 3 times on its own. You wrote the Print line once but the computer did it 3 times. That's the magic of loops!

Try It Yourself

🛠️ Your Turn: The Double Score Challenge!

You are going to upgrade the Score Reward System. Here is your challenge:

Goal: Change the if statement so there are THREE outcomes instead of two:

1. If the player's score is 10 or more → print "LEGENDARY reward unlocked!"
2. If the player's score is 5 or more (but less than 10) → print "Nice! Here's a common item!"
3. If the score is below 5 → print "Keep going, you can do it!"

In Verse, you can chain conditions like this using else if:

if (Score >= 10):
    # first case
else if (Score >= 5):
    # second case
else:
    # third case

Steps:

1. Open your Verse file from the worked example above.
2. Change var PlayerScore : int = 6 to different values (like 11, 7, and 3) to test each branch.
3. Update the if/else block to have all three cases using else if.
4. Bonus 🌟: Add a loop that counts from 1 to 5 and prints "Counting: {Index}" each time. Put it inside OnBegin.

💡 Hint: Remember to indent your code inside each if, else if, and else block. Verse is strict about indentation — it's like making sure your toys are inside the box, not next to it!

💪 You've got this! Try changing the score value and see how different branches run. That's real debugging — just like a game developer does!

Quiz

1. What does an if statement do in Verse?
   • A. It runs the same code over and over forever
   • B. It checks a true/false condition and runs different code based on the answer
   • C. It stores a number like a player's score
   • D. It creates a new device on the island
2. In this Verse code: `for (Index := 0..2):` — how many times does the loop run?
   • A. 2 times
   • B. 0 times
   • C. 3 times
   • D. 4 times
3. What happens to the code inside an `else` block?
   • A. It always runs no matter what
   • B. It runs only when the if condition is TRUE
   • C. It runs only when the if condition is FALSE
   • D. It runs before the if statement checks anything
4. Why does indentation matter so much in Verse?
   • A. It makes the code look pretty but doesn't change how it works
   • B. It tells Verse which lines of code belong inside an if statement or loop
   • C. It makes the game run faster
   • D. It is only needed for Print statements

Recap

🌟 Great Work — Here's What You Learned!

Control flow means deciding which code runs and when — just like the rules of a board game. An if statement checks a true/false condition and picks a path, like a referee making a call on your island. A loop repeats code automatically so you don't have to write the same lines over and over. Put them together and your Fortnite island can react to players, check scores, and hand out rewards like a real game designer made it! 🎮

Sources

• /docs/documentation/en-us/uefn/learn-the-basics-of-writing-code-in-verse
• /docs/documentation/en-us/fortnite/learn-the-basics-of-writing-code-in-verse

Lesson 6: Create Your First Verse Device Script

🎮 What Is a Verse Device?

Imagine a remote control car. The car itself sits on the floor of your room — that's like your Fortnite island. The circuit board inside the car is the device. The instructions you program into it tell the car what to do: go forward, turn left, honk!

A Verse device works the same way. It's a little invisible gadget you place on your island. Your Verse code is the instructions inside it. When the game starts, the device follows your instructions and makes things happen!

🛠️ Step 1 — Create a New Verse Device File

First, you need to make the file where you'll write your code. Think of this like getting a blank piece of paper before you draw.

Here's how:

1. Open your project in UEFN (Unreal Editor for Fortnite).
2. In the top menu bar, click Verse, then click Verse Explorer. This is like a file cabinet for all your Verse scripts.
3. In Verse Explorer, right-click your project name. Choose Add new Verse file to project.
4. A window pops up. Click Verse Device as your template. A template is a starter design — like a cookie cutter that already has the basic shape.
5. In the Device Name box, type score_tracker_device. Then click Create.
6. Double-click your new file in Verse Explorer. It opens in Visual Studio Code — that's your coding notebook!

🧱 Step 2 — Understand the Starter Code

When UEFN creates your device file, it gives you some starter code. Here's what the important parts mean:

• using { /Script/FortniteGame } — This line is like saying "borrow tools from Fortnite's toolbox."
• creative_device — This is the special Verse type that makes your script become a real device on your island.
• OnBegin — This is a built-in function. It runs your code the moment the game starts. Think of it like the starting pistol at a race — bang, your code goes!

🔢 Step 3 — Variables: Boxes That Hold Information

A variable is like a labeled box. You put something inside, and you can change what's in it later.

For example:

• A box labeled PlayerScore might hold the number 0 at the start.
• When a player does something cool, you change it to 1, then 2, and so on!

In Verse, you create a variable like this:

var Score : int = 0

• var means "this box can change later."
• Score is the label on the box.
• int means the box holds a whole number (like 0, 1, 5 — no fractions).
• = 0 is the starting value — the number already inside the box.

⚙️ Step 4 — Functions: Named Sets of Instructions

A function is like a recipe. You write it once, give it a name, and you can use it over and over.

Imagine a recipe called "Make Lemonade." Every time you follow it, you get lemonade! A function called AddPoint could say: every time you run it, add 1 to the score.

🔀 Step 5 — Control Flow: Making Decisions

Control flow means your code can make choices. Think of it like a Choose-Your-Own-Adventure book.

If something is true, do this. Else (otherwise), do that.

if (Score >= 3):
    Print("You win! 🎉")
else:
    Print("Keep going!")

• if asks a question: Is Score 3 or more?
• If YES, it prints "You win!"
• If NO, it prints "Keep going!"

📦 Step 6 — Compile and Place Your Device

Compiling means turning your human-readable code into something UEFN can actually run. It's like a translator turning English into Robot Language.

1. In the top menu, click Verse > Build Verse Code.
2. Wait a moment. Your device now appears in the Content Browser under CreativeDevices.
3. Drag and drop your device onto your island — just like placing any other object!
4. Click Launch Session in the toolbar to playtest. Hit Start Game and watch your code run! 🚀

Worked Example

🏆 Worked Example: A Score-Tracking Device

The goal: Make a device that tracks a player's score. When the game starts, it gives the player points one at a time and announces when they win.

Place this code inside your device file in Visual Studio Code:

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

# This tells UEFN that our script is a real device for the island
score_tracker_device := class(creative_device):

    # A variable — like a labeled box — to hold the score.
    # "var" means we can change it later. It starts at 0.
    var Score : int = 0

    # OnBegin runs automatically the moment the game starts.
    # Think of it as the starting pistol for your code!
    OnBegin<override>()<suspends> : void =
        Print("Game started! Score = 0")  # Announce the start

        # Call our custom function to add a point
        AddPoint()
        AddPoint()
        AddPoint()  # Add three points, one at a time

    # This is our custom function — a recipe called "AddPoint"
    AddPoint() : void =
        set Score = Score + 1  # Open the box, add 1, put it back
        Print("Score is now: {Score}")  # Show the new score

        # Control flow: check if the player has won yet
        if (Score >= 3):
            Print("YOU WIN! Amazing job! 🎉")  # Score is 3 or more
        else:
            Print("Keep it up! Almost there!")  # Score is less than 3

📖 Walkthrough

🎮 What You'll See

When you playtest, check the Output Log in UEFN. You'll see messages like:

Game started! Score = 0
Score is now: 1
Keep it up! Almost there!
Score is now: 2
Keep it up! Almost there!
Score is now: 3
YOU WIN! Amazing job! 🎉

Your Verse code is running live inside your Fortnite island! How cool is that? 🌟

Try It Yourself

🎯 Your Turn: Build a Countdown Device!

You just saw a score go up. Now try making it go down — like a countdown!

Your mission:

1. Create a new Verse device called countdown_device.
2. Add a variable called TimeLeft that starts at 5.
3. Write a function called Tick that subtracts 1 from TimeLeft each time it runs. (Hint: subtraction uses the - symbol!)
4. Call Tick five times inside OnBegin.
5. Use an if/else to check: if TimeLeft <= 0, print "Blast off! 🚀". Otherwise, print "Counting down: {TimeLeft}".
6. Compile your code (Verse > Build Verse Code), drag it onto your island, and playtest!

🔑 Hints:

• To subtract, use: set TimeLeft = TimeLeft - 1
• The structure of your function will look very similar to AddPoint() — just change + to - and update the variable name and messages!
• Remember: compile first, THEN drag it to the level!

Bonus challenge 🌟: Can you change the win condition so it prints a special message when TimeLeft reaches exactly 0?

Quiz

1. What does 'compiling' your Verse code do?
   • A. It deletes your code so you can start over.
   • B. It turns your code into something UEFN can actually run on your island.
   • C. It automatically adds your device to the level for you.
   • D. It sends your island to all your friends.
2. In Verse, what does the keyword 'var' tell the computer?
   • A. This value is a secret and will never be shown.
   • B. This is a function that runs automatically.
   • C. This is a box that can hold a value AND that value can change later.
   • D. This line of code should be skipped.
3. When does the 'OnBegin' function run in a Verse device?
   • A. Every single second while the game is running.
   • B. Only when a player walks into a trigger zone.
   • C. Automatically the moment the game starts.
   • D. Only when you manually call it from Verse Explorer.
4. What happens in Verse when an 'if' condition is FALSE?
   • A. The whole program stops and crashes.
   • B. The 'if' block is skipped, and the 'else' block runs instead.
   • C. The 'if' block runs twice to make up for it.
   • D. Verse ignores both the 'if' and 'else' blocks.

Recap

🌟 Great Work — Here's What You Learned!

Today you built your very first custom Verse device from scratch. You learned that a variable is like a labeled box that can hold changing information (like a score), and a function is a reusable recipe of instructions you can call by name. You used control flow (if/else) to make your device make smart decisions. Finally, you compiled your code and dropped your device onto your real Fortnite island — which means YOU just made something that runs live inside a game. That is seriously impressive! 🎉

Sources

• /docs/documentation/en-us/uefn/create-your-own-device-in-verse
• /docs/documentation/en-us/fortnite/create-your-own-device-in-verse
• /docs/documentation/en-us/fortnite/create-your-own-device-using-verse-in-unreal-editor-for-fortnite