Decoupling Systems with Events: Keeping a Big Game From Collapsing

You can now listen to events and broadcast your own. This final lesson is about why that matters once your game grows past a few devices. The word for the idea is decoupling, and it is the single most valuable habit you can build as a Verse developer.

The tangle you are avoiding

<!-- section-art:the-tangle-you-are-avoiding -->

Event Decoupling

Imagine a round ends and four things must happen: the scoreboard updates, victory music plays, the loot spawner restocks, and a "Round Over" sign lights up. The tempting way is to make the timer's handler do all four directly:

# The TANGLED way — one handler reaching into everything.
    OnRoundEnded(Agent : ?agent) : void =
        Scoreboard.Enable()
        VictoryMusic.Play()
        LootSpawner.Enable()
        RoundOverSign.Enable()

This works — today. But the timer handler now has to know about four other systems. Add a fifth reaction next week and you edit this function again. Remove the music and you risk breaking the line next to it. Everything is coupled — glued together. One change ripples everywhere. This is how a fun project turns into a fragile one.

The decoupled way: announce once, let listeners react

Instead, the timer announces one thing — "the round ended" — and each system listens for itself:

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

round_manager := class(creative_device):

    @editable
    RoundTimer : timer_device = timer_device{}

    # Our own announcement: "the round is over."
    RoundEndedEvent : event() = event(){}

    OnBegin<override>()<suspends> : void =
        # When the timer succeeds, we'll announce the round ended.
        RoundTimer.SuccessEvent.Subscribe(OnTimerDone)

    # The timer's SuccessEvent carries an optional agent (?agent).
    OnTimerDone(Agent : ?agent) : void =
        Print("Round timer finished.")
        # Make ONE announcement. We don't touch any other system.
        RoundEndedEvent.Signal()

event() is an event carrying no payload — a bare "it happened." (It is shorthand for event(tuple()).) The timer handler's only job now is to translate "timer finished" into "round ended" and shout it. It knows nothing about scoreboards or music.

Each system minds its own business

Now every reaction subscribes to RoundEndedEvent on its own. If these lived in the same device, OnBegin would simply subscribe each handler:

Look at what you gained:

• Adding a reaction = one new Subscribe line + one new handler. You never touch OnTimerDone.
• Removing a reaction = delete its Subscribe line. Nothing else notices.
• Each handler does one small job and knows nothing about the others.

The broadcaster (OnTimerDone) and the listeners no longer depend on each other. That is decoupling: the timer shouts into the air; whoever cares, reacts. Change one without fear of the others.

How to spot coupling in your own code

A quick smell test as your game grows:

If one handler is reaching into five different devices, ask: should this be one announcement that five things listen for instead?

When the answer is yes — and it usually is once more than two systems react to the same moment — reach for an event. Your future self, adding feature six, will thank you.

The payoff for the whole series

<!-- section-art:the-payoff-for-the-whole-series -->

Event Network

Step back and see what you have built across two series. Devices gave you the machines and the remotes. Events gave you the nervous system that connects them — without gluing them together. With references, OnBegin, Subscribe, Signal, and your own events, you have the complete toolkit to build a real, growable Fortnite game in Verse.

Why this helps you direct an AI

The most valuable instruction you can give a helper is an architecture, not a pile of actions: "When the round timer succeeds, signal a RoundEndedEvent; have the scoreboard, music, and loot systems each subscribe to it separately." That produces code that is clean today and easy to grow tomorrow — the mark of a developer who understands events, not just one who can wire two devices together.

Quick recap

• Coupling = systems glued together; one change ripples everywhere. Avoid it.
• Decoupling = one announcement, many independent listeners.
• Translate a device moment into your own event, then Signal it once.
• Each reaction Subscribes on its own — add/remove freely, never touch the broadcaster.
• event() carries no payload — perfect for a bare "it happened."
• Smell test: one handler reaching into many devices → make it an event.

That completes Events & Subscribables — and, with the Devices series, your foundation for building real Verse games. From here, explore the Verse Scene Graph series for the modern entity-and-component way to build.

References

• Using Events in Verse
• timer_device — Verse API Reference
• Verse Language Reference
• Part of the Events & Subscribables series.