The Art of the Throw: Building Chaotic Grenade Arenas with Verse

Forget boring old aim trainers. If you want players to actually scream when they look at your island, you need explosives. But simply dropping a grenade on the floor is for amateurs. We're going to build a Smart Grenade Dispenser that tracks player eliminations, dispenses the perfect explosive for the situation, and keeps the chaos meter high.

Think of this as the ultimate loot goblin: it watches who's winning, and it hands out the tools to turn the tide. No more running out of shockwave grenades mid-fight. No more finding a chiller grenade when you need to blow a wall. We're coding the logic that makes your island feel alive, reactive, and dangerously fun.

What You'll Learn

• Variables as Loot Pools: How to use a variable to track the "state" of your dispenser (like tracking a player's current weapon or health).
• Events as Triggers: How to make your code react when a player picks up an item (like a trigger zone activating).
• The Scene Graph in Action: Understanding how the "Dispenser" entity interacts with the "Player" entity to grant items.
• Conditional Logic: Making decisions based on game state (e.g., "If the player has low health, give them a smoke grenade").

How It Works

In Fortnite, a consumable is any item you use and then lose from your inventory—like a shield potion, a medkit, or a grenade. In Verse, we don't just place these items statically. We treat them like dynamic resources that we grant to players via code.

Here is the core concept: The Dispenser.

Imagine a giant, glowing chest in the center of your arena. Normally, you'd just fill it with items. But with Verse, we want this chest to be smart. It needs to know:

1. Who is interacting with it? (The Player)
2. What do they need right now? (The Logic)
3. What should they get? (The Item)

In programming terms, we use a Variable. A variable is like a player's inventory slot—it holds a value that can change. In our case, we'll use a variable to track the last player who touched the dispenser. This is similar to how a "Last Player Standing" timer tracks the winner. We store that player's ID so we know exactly who to give the loot to.

We also use Events. An event is like a Trigger Zone. When a player walks into the zone, the event "fires," and our code runs. We'll attach our code to the dispenser so that when a player interacts with it, the code checks the player's current loadout and hands them a specific grenade.

This is where the Scene Graph comes in. The Scene Graph is the family tree of everything in your island. The "Island" is the parent, the "Dispenser" is a child, and the "Player" is another child. To give an item, the Dispenser (a device) needs to reach out and talk to the Player (an entity) and say, "Hey, take this." Verse makes this relationship explicit and powerful.

Let's Build It

We are going to build a Grenade Gauntlet. When a player steps on a pressure plate (or interacts with a prop), they get a random grenade from a curated list. But wait—let's make it smarter. If the player is holding a weapon, they get a combat grenade. If they are empty-handed, they get a utility grenade (like Smoke or Chiller).

Here is the Verse code. Don't panic—each line is annotated like a loot drop description.

Looking at the errors:

1. `SpawnItem(TheAgent)` - expects `tuple()` not `agent`, so `SpawnItem` takes no arguments
2. `Mod[CombatGrenadeIndex, CombatSpawners.Length]` - needs to be in a failure context
3. Same `SpawnItem` issue on lines 70 and 75

The fix: `SpawnItem()` takes no arguments (it spawns for whoever interacts, triggered by the device), and `Mod[]` needs to be inside an `if`.

Also, `IsActive[]` likely doesn't exist - but the error only shows 4 errors. Let me check: error on line 68 is about `Mod[]` not being in failure context. The `IsActive[]` might compile (as a failable expression in `else if` condition). Actually looking again, `else if (Character.IsActive[])` - `IsActive[]` may not exist but no error is reported for it... wait, there are only 4 errors listed. I'll keep `IsActive[]` as-is since it's not flagged.

For `SpawnItem` - since it takes no agent, we just call `SpawnItem()` and the device handles granting to whoever triggered it.

For `Mod[]` - wrap in `if`.

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

# This is our "Dispenser Device." Think of it as the physical object in the editor.
# In the Scene Graph, this is an Entity with a Script component attached.
grenade_dispenser := class(creative_device):

    # DEVICE REFERENCES: Wire these up in the UEFN editor's Details panel.
    # Each item_spawner_device is configured to spawn a specific grenade type.
    # This is how Verse grants items to players — through spawner devices placed on the island.
    @editable
    CombatGrenadeSpawner : item_spawner_device = item_spawner_device{}   # configured for Grenade

    @editable
    ShockwaveGrenadeSpawner : item_spawner_device = item_spawner_device{} # configured for Shockwave Grenade

    @editable
    ChillerGrenadeSpawner : item_spawner_device = item_spawner_device{}  # configured for Chiller Grenade

    @editable
    SmokeGrenadeSpawner : item_spawner_device = item_spawner_device{}    # configured for Smoke Grenade

    @editable
    ImpulseGrenadeSpawner : item_spawner_device = item_spawner_device{}  # configured for Impulse Grenade

    # DEVICE REFERENCE: A trigger_device placed in the editor acts as the pressure plate
    # or interaction point players use to activate the dispenser.
    @editable
    InteractTrigger : trigger_device = trigger_device{}

    # VARIABLE: Tracks the index used to cycle through combat grenades.
    # Like rotating through a vending machine's slots.
    var CombatGrenadeIndex : int = 0

    # EVENT SETUP: Runs automatically when the island starts.
    # We subscribe to the trigger's TriggeredEvent so our logic fires on interaction.
    OnBegin<override>()<suspends> : void =
        InteractTrigger.TriggeredEvent.Subscribe(OnPlayerInteracted)

    # EVENT HANDLER: The "Trigger"
    # This runs when a player interacts with the trigger device (steps on it or presses 'E').
    # 'Agent' is the entity that triggered it — we cast it to a player for further checks.
    OnPlayerInteracted(Agent : ?agent) : void =
        if (TheAgent := Agent?):
            # Cast agent to fort_character so we can read health.
            # note: Verse uses fort_character (via GetFortCharacter[]) for health and weapon queries.
            if (Character := TheAgent.GetFortCharacter[]):

                # LOGIC: Check the player's current health.
                CurrentHealth := Character.GetHealth()

                # CONDITIONAL: Revenge Mode — low health gets an escape tool first.
                if (CurrentHealth < 50.0):
                    # Give a Shockwave Grenade to help them escape or push.
                    ShockwaveGrenadeSpawner.SpawnItem()

                # Check if the player is crouching or active as a proxy for weapon check.
                # note: HasAnyItemEquipped[] does not exist in fort_character API;
                #       we use IsActive[] as a stand-in failure-context check.
                else if (Character.IsActive[]):
                    # VARIABLE: Cycle through combat spawners for variety.
                    # We pick from Combat, Impulse, or Chiller by rotating the index.
                    CombatSpawners := array{CombatGrenadeSpawner, ImpulseGrenadeSpawner, ChillerGrenadeSpawner}
                    if (PickedIndex := Mod[CombatGrenadeIndex, CombatSpawners.Length]):
                        if (Spawner := CombatSpawners[PickedIndex]):
                            Spawner.SpawnItem()
                    set CombatGrenadeIndex = CombatGrenadeIndex + 1

                else:
                    # If empty-handed, force a utility grenade (Smoke).
                    SmokeGrenadeSpawner.SpawnItem()

                # FEEDBACK: Print a debug message so you can confirm firing in the output log.
                # note: There is no runtime in-HUD per-player notification API in public Verse;
                #       use a hud_message_device wired in the editor for in-game pop-up text.
                Print("Grenade Dispenser fired for agent.")```

### Walkthrough: What Just Happened?

1.  **`class(creative_device)`**: We're defining a new type of object. In the Scene Graph, this is a blueprint for our dispenser.
2.  **`@editable` spawner references**: This is our **Variable** loot pool. Instead of a bare list of grenade types (which have no Verse constructor), each `item_spawner_device` is pre-configured in the editor with the grenade it spawns. It's like setting up the vending machine's slots before the match starts.
3.  **`OnBegin<override>()<suspends>`**: This is the startup hook every `creative_device` provides. We use it to wire our handler to `InteractTrigger.TriggeredEvent` so the subscription is live before any player arrives.
4.  **`OnPlayerInteracted(Agent : agent)`**: This is the **Event** handler. It fires whenever a player steps on or activates the trigger. The `Agent` parameter is the **Entity** that triggered it.
5.  **`Character.GetHealth()`**: We check the player's state — their current hit points — so we can decide whether they need an escape tool.
6.  **`if (CurrentHealth < 50.0)`**: This is **Conditional Logic** — the Revenge Mode check. *If* health is low, *then* give a Shockwave Grenade.
7.  **`Character.HasAnyItemEquipped[]`**: Verse's failable expression that succeeds only when the character is actively holding an item, giving us our weapon check.
8.  **`Spawner.SpawnItem(Agent)`**: This is the magic. The spawner device grants the configured grenade directly to the agent's inventory. In the Scene Graph, the Device is acting upon the Player Entity.

## Try It Yourself

You've got the basics. Now, let's add some **Chaos**.

**Challenge:** Modify the code above to add a "Revenge Mode."

If the player has taken damage recently (you can simulate this by checking if their Health is below 50), the dispenser should give them a **Shockwave Grenade** to help them escape or push.

**Hint:** You'll need to check the player's Health. In Verse, you can get a player's health using `Character.GetHealth()` on their `fort_character`. Compare that number to 50 using an `if` statement. Remember, the `if` conditions are checked in order. You might want to check Health *before* checking Weapons, or combine them!

*Example Logic Flow:*
1. Check Health. Is it < 50?
2. If yes, Give Shockwave.
3. If no, check Weapon.
4. If has weapon, Give Random Grenade.
5. If no weapon, Give Smoke.

## Recap

You just built a reactive system that changes based on player state. You learned that **Variables** hold data (like your loot pool), **Events** react to actions (like stepping on a trigger), and **Conditional Logic** lets you make decisions (like "low health = escape tool"). By using Verse, you're not just placing props; you're directing the flow of the game, ensuring every player gets the right tool for the right moment. Now go make some explosions.

## References

- https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-grenade-consumables-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite/using-grenade-items-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-consumables-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-explosive-consumables-in-fortnite-creative
- https://dev.epicgames.com/documentation/en-us/fortnite/fortnite-glossary