16 posts tagged with "Unity"

It's 3 PM on a Tuesday. Your designer leans over and says, "Hey, can we make the screen shake a little stronger when the player gets hit for more than 50 damage? And add a half-second delay before the hit sound plays? Oh, and the poison effect should tick every 1.5 seconds instead of 2."

Three changes. Maybe fifteen seconds of actual decision-making from the designer's perspective. But here's what actually happens: you close the Scene view. Open your IDE. Wait for it to load. Search for the damage handler. Find the screen shake intensity value buried in a method. Change it. Then find the audio delay -- that's in a different class. Change it. Then find the poison coroutine -- that's in yet another class, and the tick rate is part of a WaitForSeconds call. Change it. Save all three files. Switch back to Unity. Wait for recompilation. Test.

Eight minutes later, the designer says "actually, the shake was better before, and can we try the poison at 1.8 seconds?"

"I only have 5 minutes. Can you just show me how to make the event system work?"

Fair enough. No theory, no architecture deep-dives, no comparisons with other approaches. You want to go from zero to a working event-driven interaction in your Unity project, and you want to do it fast. Let's go.

This guide assumes you have a Unity project open (2021.3 LTS or newer) and about 5 minutes. By the end, you'll have an event that fires when something happens in your game and triggers a response on a completely separate GameObject — with zero direct references between them.

You start a new Unity project. You create ten events. OnPlayerDeath, OnScoreChanged, OnLevelComplete. You name them sensibly, drop them in a folder, and move on. Life is good. You can hold the entire event structure in your head.

Fast forward six months. You've got 200 events. The Project window is a wall of ScriptableObject files. You need OnPlayerHealthDepleted — or was it OnPlayerHPLow? Or OnPlayerHealthZero? You scroll through the list, squinting at names that all start with OnPlayer. After three minutes you give up and create a new one because you're not even sure if the event you want already exists.

This is where every event-driven Unity project lands eventually. And it's not because the event pattern is wrong — it's because nobody built the tooling for managing events at scale. Unity gives you the Animation window, Shader Graph, Timeline, the Input System debugger. Events get... the Project window.

Every single event system plugin on the Unity Asset Store says "high performance" somewhere in its description. It's right there between "easy to use" and "fully documented." But here's the thing — 1ms and 0.001ms are both fast in human terms, yet one is a thousand times slower than the other. When a plugin says "high performance," what does that actually mean? Compared to what? Measured how?

I used to not care about this. Most of us don't. You wire up some events, the game runs fine on your dev machine, you ship it. But then I started working on a mobile project with hundreds of entities each listening to multiple events, and suddenly "high performance" wasn't a marketing checkbox anymore — it was the difference between 60 FPS and a slideshow.

This post is about what "high performance" should actually mean for an event system, why most implementations fall short, and how GES achieves near-zero overhead through Expression Tree compilation. With real numbers, not hand-waving.

You build GameEvent<T>. Clean, type-safe, elegant. You create a GameEvent<float> field for health updates and slap [SerializeField] on it. You switch to the Inspector. The field isn't there. It's just... gone. Unity is staring at you with a blank panel like you asked it to divide by zero.

It's Unity's oldest architectural headache. The serialization system doesn't understand generics. It never has. And every developer who's ever tried to build a type-safe, data-driven event system has walked face-first into this wall.

This isn't a minor inconvenience. It's the kind of limitation that poisons your entire architecture. You either give up type safety, drown in boilerplate, or accept that your beautiful generic design will never touch the Inspector. For years, the community answer has been "just write the concrete classes by hand." But here's the thing — if the boilerplate is 100% predictable, why is a human writing it?

You renamed a method. Just one method — OnPlayerDied became OnPlayerDefeated because your game designer asked you to soften the language. You hit Play. Nothing happens. No compile error. No warning. Ten scene objects that were wired up through the Inspector with UnityEvents just... stopped working. Silently. And you won't find out until QA reports it three days later, or worse, your players do.

If this sounds familiar, congratulations — you've met invisible spaghetti code. It's the kind of technical debt that doesn't show up in your IDE, doesn't trigger compiler warnings, and doesn't appear in any dependency graph. It just sits there, waiting to break at the worst possible moment.

This isn't a skill issue. It's an architectural one. And it's way more common than most Unity developers want to admit.