Refactoring Tight Coupling with Event Aggregators

Learners will replace direct class references with event-driven communication channels to ensure systems remain independent and scalable during complex gameplay scenarios.

In this lesson, you will learn how to replace rigid class-to-class dependencies with a centralized Event Aggregator to keep your systems completely unaware of one another.

The Problem: The "Spaghetti" Trap

When your PlayerController directly calls UIManager.UpdateHealth() or AudioSystem.PlaySound(), you have created tight coupling. If you ever decide to remove the AudioSystem or change how the UI works, your PlayerController breaks. This is a maintenance nightmare in complex projects.

The Solution: The Event Aggregator

An Event Aggregator acts as a "communication hub." Instead of systems talking to each other directly, they talk to the hub. A system "publishes" an event (like OnPlayerTookDamage), and any other system that cares simply "subscribes" to that event. The publisher doesn't need to know who is listening, or even if anyone is listening.

For this pattern, we often use Action delegates wrapped in a ScriptableObject or a global Service to act as the channel.

// The Event Channel (The Hub)
[CreateAssetMenu]
public class DamageEventChannel : ScriptableObject
{
    public event Action<int> OnDamageTaken;
    public void RaiseEvent(int amount) => OnDamageTaken?.Invoke(amount);
}

Now, your Player script only needs a reference to the DamageEventChannel:

public class Player : MonoBehaviour 
{
    public DamageEventChannel damageChannel;

    public void TakeDamage(int amount) 
    {
        // Player doesn't care who hears this. No UI or Audio reference needed!
        damageChannel.RaiseEvent(amount);
    }
}

Why This Works

The Player remains lean and focused solely on gameplay logic. The UIManager and AudioSystem can subscribe to damageChannel independently. If you want to add a "Screen Shake" effect later, you just create a new component that listens to the damageChannel—you don’t have to touch a single line of your Player script. This isolation allows you to swap, remove, or update individual systems without triggering a cascade of compiler errors.

Key Takeaway: By using an Event Aggregator, you transform your architecture from a fragile web of direct dependencies into a flexible, plug-and-play ecosystem where systems communicate through anonymous channels rather than rigid class references.