Singleton

using UnityEngine;

namespace Patterns.Creational.Singleton
{
    /// <summary>
    /// A client that needs the GameManager. No Inspector reference:
    /// it simply asks for GameManager.Instance.
    /// </summary>
    public class ScoreClient : MonoBehaviour
    {
        [SerializeField] private int pointsPerPickup = 10;

        private void OnEnable()
        {
            GameManager.Instance.ScoreChanged += OnScoreChanged;
        }

        private void OnDisable()
        {
            // Instance may be null while the application is quitting.
            var gm = GameManager.Instance;
            if (gm != null) gm.ScoreChanged -= OnScoreChanged;
        }

        private void OnTriggerEnter(Collider other)
        {
            if (other.CompareTag("Pickup"))
            {
                GameManager.Instance.AddScore(pointsPerPickup);
                Destroy(other.gameObject);
            }
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.Escape))
                GameManager.Instance.SetPaused(!GameManager.Instance.IsPaused);

            if (Input.GetKeyDown(KeyCode.N))
                GameManager.Instance.LoadLevel("Level2");
        }

        private void OnScoreChanged(int score) => Debug.Log($"Score: {score}");
    }
}

using UnityEngine;

namespace Patterns.Creational.Singleton
{
    /// <summary>
    /// Generic MonoBehaviour singleton. The first access creates the instance
    /// lazily; any duplicate found later destroys itself in Awake.
    /// </summary>
    public abstract class Singleton<T> : MonoBehaviour where T : MonoBehaviour
    {
        private static T instance;
        private static bool quitting;

        public static T Instance
        {
            get
            {
                if (quitting) return null;

                if (instance == null)
                {
                    instance = FindFirstObjectByType<T>();

                    if (instance == null)
                    {
                        var go = new GameObject($"[{typeof(T).Name}]");
                        instance = go.AddComponent<T>();
                    }
                }

                return instance;
            }
        }

        [SerializeField] private bool persistAcrossScenes = true;

        protected virtual void Awake()
        {
            if (instance != null && instance != this)
            {
                Debug.Log($"Duplicate {typeof(T).Name} destroyed.");
                Destroy(gameObject);
                return;
            }

            instance = this as T;

            if (persistAcrossScenes)
                DontDestroyOnLoad(gameObject);
        }

        protected virtual void OnApplicationQuit() => quitting = true;

        protected virtual void OnDestroy()
        {
            if (instance == this) instance = null;
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Patterns.Creational.Singleton
{
    /// <summary>
    /// The one and only game manager. Holds state that must survive
    /// scene loads, such as the score and the pause flag.
    /// </summary>
    public class GameManager : Singleton<GameManager>
    {
        public int Score { get; private set; }
        public bool IsPaused { get; private set; }

        public event Action<int> ScoreChanged;

        protected override void Awake()
        {
            base.Awake();
            Debug.Log($"GameManager ready (id {GetInstanceID()})");
        }

        public void AddScore(int amount)
        {
            Score += amount;
            ScoreChanged?.Invoke(Score);
        }

        public void SetPaused(bool paused)
        {
            IsPaused = paused;
            Time.timeScale = paused ? 0f : 1f;
        }

        public void LoadLevel(string sceneName)
        {
            // This object is marked DontDestroyOnLoad, so Score is kept.
            SceneManager.LoadScene(sceneName);
        }
    }
}