Singleton Pattern

namespace Singleton.Code {
    /// <summary>
    /// Singleton class from https://wiki.unity3d.com/index.php/Singleton
    /// 
    /// Inherit from this base class to create a singleton.
    /// e.g. public class MyClassName : Singleton<MyClassName> {}
    /// </summary>
    public abstract class Singleton<T> : MonoBehaviour where T : MonoBehaviour {
        // Check to see if we're about to be destroyed.
        private static bool m_ShuttingDown = false;
        private static object m_Lock = new object();
        private static T m_Instance;

        /// <summary>
        /// Access singleton instance through this propriety.
        /// </summary>
        public static T Instance {
            get {
                if (m_ShuttingDown) {
                    Debug.LogWarning("[Singleton] Instance '" + typeof(T) +
                                     "' already destroyed. Returning null.");
                    return null;
                }

                lock (m_Lock) {
                    if (m_Instance == null) {
                        // Search for existing instance.
                        m_Instance = (T) FindObjectOfType(typeof(T));

                        // Create new instance if one doesn't already exist.
                        if (m_Instance == null) {
                            // Need to create a new GameObject to attach the singleton to.
                            var singletonObject = new GameObject();
                            m_Instance = singletonObject.AddComponent<T>();
                            singletonObject.name = typeof(T).ToString() + " (Singleton)";

                            // Make instance persistent.
                            DontDestroyOnLoad(singletonObject);
                        }
                    }

                    return m_Instance;
                }
            }
        }


        private void OnApplicationQuit() {
            m_ShuttingDown = true;
        }


        private void OnDestroy() {
            m_ShuttingDown = true;
        }
    }
}

namespace Singleton.Code {
    // inherit from singleton to have global access
    public class GameManagerSingleton : Singleton<GameManagerSingleton> {
        // player preference key
        private const string HighScorePref = "HighScore";

        // score
        public int Score { get; private set; } = 0;

        // high score cached variable
        private int _highScore = 0;

        // high score getter which checks if current score should overwrite.
        public int HighScore {
            get {
                if (Score <= _highScore) {
                    return _highScore;
                }

                _highScore = Score;
                PlayerPrefs.SetInt(HighScorePref, HighScore);

                return _highScore;
            }
        }

        private void Start() {
            // get last saved high score from player preferences
            _highScore = PlayerPrefs.GetInt(HighScorePref);
        }

        // returns new score
        public int AddScore() {
            Score++;
            return Score;
        }

        // resets score to 0
        public void ResetScore() {
            Score = 0;
        }
    }
}

namespace Singleton.Code {
    public class GameFacade : MonoBehaviour {
        // text prefixes
        private const string ScoreText = "Score: ";
        private const string HighScoreText = "HighScore: ";

        ...
        [SerializeField] private Text _scoreText;
        [SerializeField] private Text _highScoreText;

        // game started boolean to prevent updates on initial call
        private bool _gameStarted = false;
        ...

        private void Start() {
            // initializing objects
            ...

            // initialize texts
            _scoreText.text = ScoreText + GameManagerSingleton.Instance.Score;
            _highScoreText.gameObject.SetActive(false);

            ...
        }
      
        ...

        private void OnEnemySurvived() {
            _foodMenu.EnableButtons();
            
            // added check so score does not update while game hasn't been fully initialized.
            if (_gameStarted) {
                _scoreText.text = ScoreText + GameManagerSingleton.Instance.AddScore();
            }

            // to make sure score doesn't get updated on first call
            _gameStarted = true;
        }

        private void OnEnemyDied() {
            // enable reset button when enemy died
            _reset.gameObject.SetActive(true);

            // refresh highscore text
            _highScoreText.text = HighScoreText + GameManagerSingleton.Instance.HighScore;
            // enable highscore text
            _highScoreText.gameObject.SetActive(true);
        }

        private void Reset() {
            // remove listeners
            sorcerer.OnSurvived -= RandomTarget;
            sorcerer.OnDied -= OnEnemyDied;

            // reset current scene and score
            GameManagerSingleton.Instance.ResetScore();
            SceneManager.LoadScene(SceneManager.GetActiveScene().name);
        }
    }
}