Event Management Design Proposal

Event Management Design Proposal

In a Singleton class such as the GameManager, it can be initially useful to handle all events. However, as the game grows, it becomes increasingly problematic for the GameManager to handle every minor event, making the codebase more complex and harder to maintain. At this point, it becomes essential to separate event management into dedicated classes.

Problems with Managing Events in GameManager

When the GameManager handles all events, game logic and UI-related code get mixed together, which makes maintenance difficult. Moreover, as the number of events grows, the GameManager becomes larger and increasingly violates the single responsibility principle. For example, managing bonus score increases, UI updates, player state changes, etc., all within the GameManager, leads to limited scalability and complexity.

The Solution: Dedicated Event Classes

By introducing dedicated event classes, the GameManager no longer needs to manage all events. Instead, we can delegate event handling to classes that handle specific events. Importantly, these event classes can be made static, allowing the GameManager to simply manage the events, while other classes handle the actual event processing.

Real-life examples:

  • PlayerEventManager: Handles player-related events (e.g., score increases, player state changes, etc.)
  • UIEventManager: Handles UI-related events (e.g., button clicks, screen animations, etc.)
  • GameStateEventManager: Handles game state-related events (e.g., game start, game over, etc.)

Event Class Structure Example

// Handling player-related events
public class PlayerEventManager
{
    public static event Action OnScoreIncreased;

    public static void IncreaseScore()
    {
        OnScoreIncreased?.Invoke(); // Trigger score increase event
    }
}

// Handling UI-related events
public class UIEventManager
{
    public static event Action OnGameOver;

    public static void TriggerGameOver()
    {
        OnGameOver?.Invoke(); // Trigger game over event
    }
}

// Handling game state-related events
public class GameStateEventManager
{
    public static event Action OnGameStarted;

    public static void StartGame()
    {
        OnGameStarted?.Invoke(); // Trigger game start event
    }
}

Event Class Usage Example

// GameManager subscribes to and handles events
public class GameManager : MonoBehaviour
{
    void OnEnable()
    {
        PlayerEventManager.OnScoreIncreased += HandleScoreIncreased;
        UIEventManager.OnGameOver += HandleGameOver;
        GameStateEventManager.OnGameStarted += HandleGameStarted;
    }

    void OnDisable()
    {
        PlayerEventManager.OnScoreIncreased -= HandleScoreIncreased;
        UIEventManager.OnGameOver -= HandleGameOver;
        GameStateEventManager.OnGameStarted -= HandleGameStarted;
    }

    private void HandleScoreIncreased()
    {
        Debug.Log("Score Increased");
    }

    private void HandleGameOver()
    {
        Debug.Log("Game Over");
    }

    private void HandleGameStarted()
    {
        Debug.Log("Game Started");
    }
}

Conclusion

Managing all events in the GameManager is fine initially, but as the game grows in complexity, it becomes difficult to maintain and scale. By introducing dedicated event classes, the responsibility for handling events is clearly separated, improving both maintainability and scalability. Using static event classes allows for efficient event management while keeping the GameManager's role limited to event management. This approach ensures that the GameManager does not become overburdened with responsibility, leading to cleaner, more manageable code.

The GameManager no longer needs to handle all events, and each event management class takes responsibility for its specific event, allowing for greater flexibility in the game design.

Popular posts from this blog

Understanding Arrays as Reference Types in C#

Image
Arrays as Reference Types In programming, it's important to understand the behavior of arrays. In most programming languages including C#, arrays are treated as reference types. This article will explore what that means and how to use that knowledge effectively. Value Types vs Reference Types In C#, data types are categorized into two main types: Value types : Store actual values directly. Examples : int , float , bool , struct Reference types : Store memory addresses instead of the actual values. Examples: class , string , array , delegate Arrays, like classes, are reference types. When you assign one array variable to another, you're copying the reference, not the actual data. Example: Arrays as Reference Types using System; class Program { static void Main() { int[] array1 = { 1, 2, 3 }; int[] array2 = array1; // Copy reference array2[0] = 100; Console.WriteLine(array1[0]); // Out...
Read more

Setting Up a Basic Follow Camera with Cinemachine 3.x

Image
Setting Up a Basic Follow Camera with Cinemachine 3.x Cinemachine has been significantly upgraded in version 3.x, introducing new concepts, improved terminology, and a refined workflow. In this post, we’ll go through how to set up a simple follow camera using the latest version. For more advanced examples, be sure to check out the sample scenes provided in the Cinemachine package—they’re very helpful for understanding the system. Install the Cinemachine Package Start by downloading and importing the Cinemachine package from the Unity Package Manager. Check the Main Camera After installation, you'll notice that the Main Camera now has a Cinemachine Brain component attached. Make sure the Live Camera field shows the name of your Cinemachine Camera. Create a Cinemachine Camera In the Hierarchy window, right-click and go to Cinemachine > Cinemachine Camera to create a new virtual camera. Set the Tracking Targe...
Read more

Understanding and Using ? (nullable) in C#

Image
Understanding and Using ? (nullable) in C# In C#, ? is the symbol used to declare a variable as nullable, meaning it can hold a null value. ? (nullable) declaration string text1 = null; string? text2 = null; Both variables are null , but when you call text1.ToString() , a runtime null reference exception will occur. This happens because text1 is null , meaning it points to nothing. Trying to access .ToString() on a null variable results in an exception. To put it into words, asking someone who has no thoughts, "What should we have for lunch?" is similar. The person doesn't have any thoughts, so asking them anything at all would be an error. On the other hand, text2 has been declared with ? , which tells the compiler, "This variable might be null ." However, just informing the compiler doesn't automatically prevent exceptions. You still need to handle it explicitly. ?. (null-conditional operator) Thus, ? ...
Read more