How to Design a Global GameManager in Unity

How to Design a Global GameManager in Unity

When developing a game, you’ll often have data that needs to be accessed globally across multiple classes. That’s when you start thinking: how should I design my GameManager?

This post explores several ways to structure a GameManager in Unity, from static classes to MonoBehaviour-based singletons.

Using a Static Class

In a regular C# project (not Unity), you might use a static class for global data access:

public static class GameManager
{
    public static int score;
}

This allows you to access GameManager.score from anywhere in your code.

Limitations of Static Classes

  • You can't create an instance of a static class.
  • You can’t inherit from MonoBehaviour, which means no Start(), Update(), or DontDestroyOnLoad().
  • You can’t attach it to a GameObject in the scene.

So while static classes are good for storing simple values, they fall short if you want to interact with Unity’s component system.

Using MonoBehaviour

If you need Unity lifecycle methods, define GameManager as a normal MonoBehaviour class:

public class GameManager : MonoBehaviour
{
    public int score;
}

Attach this script to a GameObject in the scene, and you can start using it. But what happens if you change scenes?

Limitations of Regular MonoBehaviour

Changing scenes will destroy the GameManager GameObject. If you only have one scene, that’s fine. But for multi-scene games, it’s a problem.

Using DontDestroyOnLoad()

public class GameManager : MonoBehaviour
{
    void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }
}

This keeps the GameManager alive even when changing scenes. However, it has one problem: duplicates.

The Problem with DontDestroyOnLoad()

If a new GameManager is created in the next scene, you'll end up with multiple copies. To solve this, we need a singleton.

Applying the Singleton Pattern

public class GameManager : MonoBehaviour
{
    public static GameManager Instance;
    public int score;
    public int playerHealth = 100;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

This ensures that only one GameManager exists, even across scenes.

Benefits of Singleton

  • Only one instance persists across scenes.
  • Access globally via GameManager.Instance.
  • Automatically destroys duplicates.

Avoiding .Instance with Static Variables

One downside of the singleton approach is that you have to type .Instance every time. To simplify:

public class GameManager : MonoBehaviour
{
    public static GameManager Instance;
    public static int score;
    public static int playerHealth = 100;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

Now you can access the data directly:

GameManager.score = 10;
Debug.Log(GameManager.score);

It's fine with a single scene, but...

This code works safely in a project with only a single scene.
However, if your project has multiple scenes, the GameManager may be created multiple times across scenes, so you'll need to improve the singleton structure a bit.

In a future post, I’ll show you how to build a more robust singleton pattern that works reliably across multiple scenes,
including how to load the GameManager prefab dynamically from the Resources folder.

Summary

  • Use static class for simple, single-scene projects.
  • Use MonoBehaviour when Unity features like Start() or Update() are needed.
  • Use DontDestroyOnLoad() to persist between scenes.
  • Use the Singleton pattern to ensure only one instance exists.
  • Add static variables if you want to avoid typing .Instance.

In short, use static for simple projects, and use the Singleton pattern for managing game state across scenes.

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