Creating a Metroidvania (like Hollow Knight) — Part 12: Next-Level UI System

This article will be free until the accompanying video is released.

One of the issues that our readers had a lot of bugs for, and a lot of questions on, in our forums, is regarding the scene fading functionality in SceneFader that we’ve made in Part 5. These issues, are in part, due to our Scene Fader GameObject needing to be manually set-up in each of our scenes for the fade-in and fade-out effect to work.

In Part 12, we are building a new, modular and much simpler way of handling UI, as well as of transitioning between the scenes, that will remove a lot of the problems and difficulties associated with managing all of these disparate UI elements.

1. Introducing the UIScreen
   1. The problem with our old UI codes
   2. One UIScreen to rule them all
   3. The UIScreen script explained
2. Updating the Main Menu to use UIScreen
   1. Marking our scripts as obsolete
   2. Updating the Main Menu and Credits UI
   3. Updating the Settings UI
   4. Making the Main Menu responsive
   5. Making the Credits and Options screen responsive
   6. Quality-of-life notification to the UIScreen inspector
3. Redesigning the UIAudio script
   1. Creating the UIAudioFeedbackConfig scriptable object
   2. Integrating with UIScreen
   3. Automating the Event Triggers in UIScreenEditor
   4. Using directional keys for the Menu
   5. Removing UIAudio
4. Rearranging the other Scenes
   1. Subclassing UIManager to UIScreen
   2. Removing SceneFader dependencies
   3. Reorganising the HUD Canvas

1. Introducing the UIScreen

a. The problem with our old UI codes

One of the problems that our older UI system had was that many of our UI scripts were all coded to fix a specific problem that we had:

• The SceneFader was made specifically for us to fade between scenes when we moved from one area to another.
• The MenuFadeController and FadeUI scripts were coded specifically to control the menus that we created in Part 9.

This left us with separate scripts that handled similar functionality across different screens, which is not ideal because it makes our codebase messier.

Because of the way that it was coded, it was prone to creating a lot of Null Reference Exceptions as well.

Also, because all of our scene fading was made by explicitly adding a GameObject to our Canvas, this creates a big black box on the Scene view of our projects, which can get in the way of us editing all of our scenes.

b. One UIScreen to rule them all

To fix all of these problems, in this part, we are going to move all of the logic for our primary UI elements (i.e. in-game UI, as well as UI on the menu screen) into a new script called UIScreen. This script will be used by all of our UI elements in the project, and provide a way for us to handle scene fading in a more centralised and dynamic manner.

In the next part, we will also be extending the UIScreen script to customise it for the UI elements that appear when we pick up items.

Let’s create a new UIScreen script and place them in a new folder under Scripts/UI.

UIScreen.cs

using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[DisallowMultipleComponent]
[RequireComponent(typeof(CanvasGroup))]
public class UIScreen : MonoBehaviour
{
    public enum Transition { none, fade, colorFade, colorFadeAndFade }
    public Transition sceneEntrance;

    public float fadeTime = 1f;
    public Color fadeColor = Color.black;
    [Range(0, 1)] public float crossFade = 0f;
    public float updateFrequency = 0.05f;

    [System.Flags] public enum TimeScaleMode { affectedByGlobalTimeScale = 1, affectedByPause = 2 }
    public TimeScaleMode timeScaleMode = (TimeScaleMode)1;

    protected CanvasGroup group;
    protected float originalAlpha = 1f;
    protected Coroutine currentAnimation;

    protected bool isAnimating = false;
    public bool IsAnimating() { return isAnimating; }

    // Determines what the current time scale should be for this UI element.
    public float GetTimeScale()
    {
        if ((timeScaleMode & TimeScaleMode.affectedByPause) > 0)
        {
            if (GameManager.Instance && GameManager.Instance.isPaused) return 0f;
        }
        if ((timeScaleMode & TimeScaleMode.affectedByGlobalTimeScale) > 0) return Time.timeScale;
        return 1f;
    }

    public static float GetTimeScale(UIScreen target) { return target.GetTimeScale(); }

    public const int COLOR_FADE_PRIORITY = 1000;

    // Start is called before the first frame update
    protected virtual void Awake()
    {
        group = GetComponent<CanvasGroup>();
        originalAlpha = group.alpha;

        switch(sceneEntrance)
        {
            case Transition.fade:
                StartCoroutine(Fade(fadeTime, 1));
                break;
            case Transition.colorFade:
                StartCoroutine(FadeTo(fadeColor, -1,  fadeTime));
                break;
            case Transition.colorFadeAndFade:
                StartCoroutine(ColorFadeAndFade(fadeTime, 1, fadeColor));
                break;
        }
    }

    public void DeactivateAll(float fadeDuration = -1)
    {
        UIScreen[] all = FindObjectsOfType<UIScreen>();
        foreach(UIScreen u in all)
        {
            if (u == this) continue;
            u.Deactivate(fadeDuration);
        }
    }

    public virtual void Activate(bool exclusive = false)
    {
        if (isAnimating) return;

        // If this screen is exclusive, we deactivate all the rest.
        float activationDelay = 0;
        if (exclusive)
        {
            if (crossFade > 0)
            {
                DeactivateAll(fadeTime * crossFade);
                activationDelay = 0;
            }
            else
            {
                activationDelay = fadeTime / 2;
                DeactivateAll(activationDelay);
            }
        }

        gameObject.SetActive(true);
        group.alpha = 0;
        
        StartCoroutine(Activate(activationDelay));
    }

    // Activate function, but with a delay.
    // Meant to be used with a Coroutine.
    public virtual IEnumerator Activate(float delay)
    {
        if (isAnimating) yield break;
        isAnimating = true;
        
        // Creates the delay before the activation happens.
        if (delay >= 0)
        {
            WaitForSecondsRealtime w = new WaitForSecondsRealtime(updateFrequency);
            while(delay > 0)
            {
                yield return w;
                float timeScale = GetTimeScale();
                if (timeScale <= 0) continue;
                delay -= w.waitTime * timeScale;
            }
        }

        // The actual activation.
        gameObject.SetActive(true);
        if (group)
        {
            group.alpha = 0;
            StartCoroutine(Fade(fadeTime, 1));
        }
        
        isAnimating = false;
    }

    public virtual void Deactivate(float fadeDuration = -1)
    {
        if (fadeDuration < 0) fadeDuration = fadeTime;
        if (group)
        {
            group.alpha = originalAlpha;
            StartCoroutine(Fade(fadeDuration, -1));
        }
    }

    // Coroutine that causes a whole Canvas Group to fade in / fade out.
    protected virtual IEnumerator Fade(float duration, int direction = 1, System.Action callback = null)
    {
        WaitForSecondsRealtime w = new WaitForSecondsRealtime(updateFrequency);

        // Don't play as long as another animation is playing on this.
        while (isAnimating) yield return w;

        isAnimating = true;
        float currentDuration = duration;

        group.alpha = direction > 0 ? 0 : originalAlpha;
        group.gameObject.SetActive(true);
        while (currentDuration > 0)
        {
            yield return w;
            float timeScale = GetTimeScale();
            if (timeScale <= 0) continue;
            currentDuration -= w.waitTime * timeScale;
            float ratio = currentDuration / duration;
            group.alpha = (direction > 0 ? 1f - ratio : ratio) * originalAlpha;
        }

        group.alpha = direction > 0 ? originalAlpha : 0;

        if (direction < 0) group.gameObject.SetActive(false);

        isAnimating = false;

        // Perform the callback.
        if (callback != null) callback(); 
    }

    // Instead of fading this element out, we fade this to a color.
    public static IEnumerator FadeTo(Color color, int direction = 1, float duration = 0.5f, System.Action callback = null)
    {
        // Create the fader that we will use to do the fading in / fading out.
        GameObject go = new GameObject("Fader (Temp)");
        RectTransform r = go.AddComponent<RectTransform>();
        Canvas c = go.AddComponent<Canvas>();
        Image img = go.AddComponent<Image>();
        CanvasGroup g = go.AddComponent<CanvasGroup>();
        UIScreen u = go.AddComponent<UIScreen>();

        // Set the default values for all components.
        img.color = color;
        g.alpha = direction > 0 ? 0 : 1;
        g.blocksRaycasts = g.interactable = false;
        c.renderMode = RenderMode.ScreenSpaceOverlay;
        c.sortingOrder = COLOR_FADE_PRIORITY;

        // The actual fading.
        yield return u.Fade(duration, direction);
        Destroy(go, u.updateFrequency);

        // Perform the callback.
        if (callback != null) callback(); 
    }

    protected virtual IEnumerator ColorFadeAndFade(float fadeTime, int direction, Color color)
    {
        group.alpha = 0;
        yield return FadeTo(color, -direction, fadeTime);
        yield return Fade(fadeTime, direction);
    }

    public virtual void LoadScene(int buildIndex)
    {
        StartCoroutine(LoadScene(buildIndex, LoadSceneMode.Single, fadeTime));
    }

    protected virtual IEnumerator LoadScene(int buildIndex, LoadSceneMode loadSceneMode, float fadeDuration = -1)
    {
        if (fadeDuration < 0) fadeDuration = fadeTime;

        // Activate the fade to black.
        yield return FadeTo(fadeColor, 1, fadeDuration);
        group.alpha = 0;

        transform.SetParent(null);
        DontDestroyOnLoad(gameObject);
        SceneManager.LoadScene(buildIndex, loadSceneMode);

        // Clean this object up.
        Destroy(gameObject);
    }

    public virtual void Quit()
    {
        Application.Quit();
    }
}

c. The UIScreen script explained

In essence, the UIScreen script is meant to be attached to any UI element (i.e. GameObjects that are attached to a Canvas and have a RectTransform component) that you need to activate or deactivate during different phases in your game, such as:

1. The Pause Screen
2. The Death Screen
3. The in-game HUD
4. Various scenes in the main menu, like the:
   • Options screen
   • Credits screen
   • Main menu

It is designed to automatically handle a wide variety of UI needs, such as the fading in / out at the start of every scene, or the fading between UI elements in the main menu scene. It can also be configured to either be sped up / slowed down by Time.timeScale, or to run independently from it.

Below is a detailed list of all the properties it has:

Setting	Description
Scene Entrance	This setting controls whether there is a fade in effect that plays when we enter a new Scene with this object. There are 4 possible options for this setting.
	None	This UI element does not apply a fade-in effect when we first enter the Scene.
	Fade	This UI element will be faded in when we enter a new Scene.
	Color Fade	This UI element will fade in from the colour that we set in Fade Color.
	Color Fade and Fade	This UI element will first fade in from Fade Color, then fade itself in using the regular fade effect.
Fade Time	If Scene Entrance is set to a value other than None, this will control how long it takes for the UI to fade in.
Fade Color	If Color Fade or Color Fade and Fade is selected, this will be the colour that the UI fades in from.
Cross Fade	When fading between different screens, this controls how much overlap there is between 2 fading screens.
Update Frequency	This value controls the frame rate of all fading animations associated with the UI screen. With the default value of 0.05, UI screens will animate with a frame rate of 20 (0.05-1 = 20).
Time Scale Mode	This is a flag that allows you to control whether the UI Screen is affected by pauses or the global time scale. Each option can be enabled or disabled independently, as this is a set of bitwise flags.
	Affected By Global Timescale	Controls whether the animations on this UI element are affected by time scale adjustments, such as from the hit stops we made in the previous part.
	Affected by Pause	If this option is flagged, the UI element will not animate when the game is paused.

For reference, here are the 3 different animation options, applied to the main menu UI element:

2. Updating the Main Menu to use UIScreen

To better understand how the UIScreen script works, let’s update the UI elements in our Main Menu Scene to use UIScreen.

a. Marking our scripts as obsolete

The main menu currently consists of 3 sub-UIs (Main Menu, Options and Credits), and is run by a range of scripts:

• FadeUI: Which is responsible for allowing an object to fade in or fade out.
• MenuFadeController: Which controls the fader object in the main menu scene, similar to what SceneFader does for the rest of our Scenes.
• SettingsMenu: A script that allows us to change the audio settings present in the Settings UI menu.
• UIAudio: Which stores a list of sounds to play when different events are fired on our buttons. These have to be manually assigned to each button, which makes it very labour intensive.

With the introduction of the UIScreen, all of the functionality these scripts provided can be handled. Hence, let’s first mark them as obsolete, as we will remove them in future.

UIAudio.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[System.Obsolete]
public class UIAudio : MonoBehaviour
{
    [SerializeField] AudioClip hover, click;
    AudioSource audioSource;

    // Start is called before the first frame update
    void Start()
    {
        audioSource = GetComponent<AudioSource>();
    }

    public void SoundOnHover()
    {
        if(audioSource) audioSource.PlayOneShot(hover);
    }

    public void SoundOnClick()
    {
        if(audioSource) audioSource.PlayOneShot(click);
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

FadeUI.cs

using System.Collections;
using UnityEngine;

[System.Obsolete]
public class FadeUI : MonoBehaviour
{
    CanvasGroup canvasGroup;
    Coroutine fadeCoroutine; // Check whether we are fading now.

    public bool isAnimating { get { return fadeCoroutine != null; } }

    private void Awake()
    {
        canvasGroup = GetComponent<CanvasGroup>();
    }

    public void Fade(float _seconds, bool fadeIn)
    {
        if (fadeIn) FadeUIIn(_seconds);
        else FadeUIOut(_seconds);
    }

    public void FadeUIOut(float _seconds)
    {
        fadeCoroutine = StartCoroutine(FadeOut(_seconds));
    }    
    public void FadeUIIn(float _seconds)
    {
        fadeCoroutine = StartCoroutine(FadeIn(_seconds));
    }

    IEnumerator FadeOut(float _seconds)
    {
        canvasGroup.interactable = false;
        canvasGroup.blocksRaycasts = false;
        canvasGroup.alpha = 1;
        while(canvasGroup.alpha > 0)
        {
            canvasGroup.alpha -= Time.unscaledDeltaTime / _seconds;
            yield return null;
        }
        yield return null;
        fadeCoroutine = null;
    }    
    
    IEnumerator FadeIn(float _seconds)
    {
        canvasGroup.alpha = 0;
        while(canvasGroup.alpha < 1)
        {
            canvasGroup.alpha += Time.unscaledDeltaTime / _seconds;
            yield return null;
        }
        canvasGroup.interactable = true;
        canvasGroup.blocksRaycasts = true;
        yield return null;
        fadeCoroutine = null;
    }

    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

MenuFadeController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

[System.Obsolete]
public class MenuFadeController : MonoBehaviour
{
    private FadeUI fadeUI;
    [SerializeField] private float fadeTime;

    // Start is called before the first frame update
    void Start()
    {
        Time.timeScale = 1f; // Always unpause the game if we are entering the main menu.
        fadeUI = GetComponent<FadeUI>();
        fadeUI.FadeUIOut(fadeTime);
    }

    public void CallFadeAndStartGame(string _sceneToLoad)
    {
        StartCoroutine(FadeAndStartGame(_sceneToLoad));
    }

    IEnumerator FadeAndStartGame(string _sceneToLoad)
    {
        fadeUI.FadeUIIn(fadeTime);
        yield return new WaitForSeconds(fadeTime);
        SceneManager.LoadScene(_sceneToLoad);
    }

    // Update is called once per frame
    void Update()
    {

    }
}

b. Updating the Main Menu and Credits UI

For our Main Menu UI element, we will be removing the FadeUI script, and adding the UIScreen component. We’ll also remove the Image GameObject, which contains the MenuFadeController, and is responsible for the fading between menus—its job will be done by the UIScreen component.

The Color Fade And Fade option above replaces the job of the MenuFadeController of fading the screen in from black, but if you prefer the original effect of fading in from black, you can set Scene Entrance to Color Fade and you will get the same effect as the original. You can also change Fade Color to fade in from a different colour.

We then do the same thing to the Credits Menu—remove the FadeUI and replace it with the UIScreen. In this case, we set the Scene Entrance to None, as we do not want it to play an entrance animation (it will clash with the main menu).

c. Updating the Settings UI

For SettingsMenu, instead of marking it obsolete, I will be renaming it to UIMenuSettings, and moving it into the Scripts/UI folder together with UIScreen.

The reason I renamed the script to UIMenuSettings is so that, in future, if we have multiple menu scripts, I can do a search for “UIMenu” to find all scripts relating to UI menus. Similarly, because my UI scripts are all prefixed with UI, I can search the term “UI” to find all my scripts.

SettingsMenuUIMenuSettings.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Audio;

public class UIMenuSettings : MonoBehaviourUIScreen
{
    [Header("Menu Settings")]
    [SerializeField] AudioMixer audioMixer;

    public void SetVolume(float _volume)
    {
        audioMixer.SetFloat("Volume", _volume);
    }

    public void SetQuality(int _qualityIndex)
    {
        QualitySettings.SetQualityLevel(_qualityIndex);
    }

    public void SetFullScreen(bool _isFullScreen)
    {
        Screen.fullScreen = _isFullScreen;
    }

    public void Quit()
    {
        Application.Quit();
    }

    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

Notice that the Quit() function, which was originally on the settings menu script, has been moved to UIScreen. This enables any of our UI elements to be able to quit the game, instead of just the settings menu script.

d. Making the Main Menu responsive

The last thing we’ll need to do is to make all our screens responsive, because currently…

To rectify this, we will need to split the anchors of our elements, so that their sizes are proportionate to the screen size.

To be precise, instead of manipulating the anchor directly (like above), I’ll be changing the values in the Anchors property of each element instead. For example, instead of setting the Title to have a fixed width, we will set it to have the following Anchor values:

By setting the values in Anchors and setting the Left, Top, Right and Bottom to 0, we are essentially setting the element to take up 70% of the screen horizontally (0.85 – 0.15 = 0.7) and 65% of the screen vertically—this means that varying screen sizing no longer breaks the UI.

For the buttons, we will adopt a similar approach—setting the Anchors and setting all its positioning to 0 except for Bottom, which we will set to 10. This leaves a gap between one button and the next one.

Lastly, we’ll have to head into the Text element inside each button. Make sure that:

1. The Auto Size attribute is set, and;
2. The Anchor is completely split (i.e. both X and Y anchor values are [0, 1]).

Now the main menu screen should be responsive! Depending on how your UI elements are set up, you may need to tweak the settings slightly to get everything to fit properly.

e. Making the Credits and Options screen responsive

The Options and Credits screens are much simpler, since there are fewer elements. For both screens, we set the Back button to take up the top-left corner of the screen, and leave a gap of 10 pixels on the Top and Left corners:

As for the elements, we’ll use the same technique to size them proportionately to the screen.

We will also need to make some changes to the children of each of the UI elements on the right:

1. For the dropdown, make sure the Text element has Auto Size checked. This will ensure the text is not too small.
2. The full screen checkbox will be stretched. You will need to only separate the anchor on the Y-axis, and leave the X-axis in place, and check the Preserve Aspect checkbox on the box.

3. For the Volume slider, make sure the Handle’s Image has Preserve Aspect checked as well. Otherwise, stretching the slider bar will cause the handle to be distorted.

As for the Credit screen, we’ll just let the text take up 80% horizontally and 20% vertically.

f. Quality-of-life notification to the UIScreen inspector

When using the new UIScreen with our different UI screens, we will need to make sure that all of our UI screen objects that are not active are disabled, and their Canvas Group component’s Alpha value is set to 1. This is because the fading functionality in UIScreen saves the initial alpha value of the Canvas Group, so that it knows what transparency value to fade to when fading back in (otherwise everything will always fade back to full transparency).

Since this is something that can potentially cause some frustration if you’re not aware of it-—since it will cause your menu to not show up at all—let’s code a custom editor script for the UIScreen that adds a notice to the UIScreen inspector interface when the Canvas Group’s Alpha is set to 0.

Here is the script for the custom UI for the UIScreen component. Note that the script has to be put inside a folder named Editor (I put it into Scripts/UI/Editor), or it will cause compile errors on your project when building.

UIScreenEditor.cs

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(UIScreen), editorForChildClasses: true)]
public class UIScreenEditor : Editor
{

    UIScreen screen;

    void OnEnable()
    {
        screen = target as UIScreen;
    }

    public override void OnInspectorGUI()
    {
        CanvasGroup group = screen.GetComponent<CanvasGroup>();
        if (group)
        {
            if(Mathf.Approximately(group.alpha, 0))
                EditorGUILayout.HelpBox("Your UI Screen has its Canvas Group Alpha set to 0. This will cause any fading for it to not work, as it will save the UI Screen's original Alpha as 0. Please set the Canvas Group Alpha to a non-zero value, and disable the GameObject if you do not want to display the UI Screen.", MessageType.Warning);

            if(!group.blocksRaycasts || !group.interactable)
                EditorGUILayout.HelpBox("Buttons and other interactable elements in your UI Screen will not work unless the Canvas Group has Interactable and Blocks Raycasts turned on.", MessageType.Warning);
        }
        base.OnInspectorGUI();
    }
}

This is a pretty simple script—the main function you want to look at is the OnInspectorGUI() function, which is responsible for drawing the component’s inspector in Unity.

• The EditorGUILayout.HelpBox() function draws the warning box, but only when the Canvas Group that accompanies our UI Screen has its alpha set to 0.
• Thereafter, base.OnInspectorGUI() draws the rest of the Inspector UI as per normal.

Notice also that we have an attribute on top of a class ([CustomEditor]) that attaches the script to the UIScreen component.

3. Redesigning the UIAudio script

Remember when we marked the UIAudio script obsolete earlier above? This is because there is a better way of attaching audio feedback to all of our buttons.

Previously, the UIAudio script was attached to all of our Canvases, and we then had to manually assign hover and click actions to every button in our Scene to get audio feedback—it’s not the most efficient way to do things, especially if you plan to have many different kinds of UI screens in your game.

a. Creating the UIAudioFeedbackConfig scriptable object

Hence, let’s create a replacement for UIAudio that allows us to automate the process of assigning these sounds to our buttons and other interactables. We will create a new scriptable object to replace UIAudio, and it will store all the audio feedback sound that we want our elements to play. The script will be added to the Scripts/UI/UIAudioData folder:

UIAudioFeedbackConfig.cs

using UnityEngine;

[CreateAssetMenu(fileName = "UI Audio Feedback Config", menuName = "Metroidvania/UI Audio Feedback Config", order = 1000)]
public class UIAudioFeedbackConfig : ScriptableObject
{
    public AudioClip pointerClick, pointerEnter, pointerExit, pointerDown, pointerUp;
    public AudioClip select, deselect, submit;    

    public AudioClip GetSound(string type)
    {
        // Retrieve the field specified by the <type> argument from our feedback data.
        System.Reflection.FieldInfo f = typeof(UIAudioFeedbackConfig).GetField(type);
        if (f != null && f.FieldType == typeof(AudioClip))
        {
            AudioClip result = (AudioClip)f.GetValue(this);
            if (result) return result;
        }

        return null;
    }
}

Upon adding this script to our project, we will be able to create a new kind of asset in our project:

As explained above, this is a scriptable object that will hold all the feedback sounds for all the UI elements, similar to what UIAudio is doing. If you create a copy of it and select it, you will see the following in the Inspector:

b. Integrating with UIScreen

To allow us to play the sounds in the scriptable object, we’ll add a new field to our UIScreen script.

UIScreen.cs

using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[DisallowMultipleComponent]
[RequireComponent(typeof(CanvasGroup))]
public class UIScreen : MonoBehaviour
{
    public enum Transition { none, fade, colorFade, colorFadeAndFade }
    public Transition sceneEntrance;

    public float fadeTime = 1f;
    public Color fadeColor = Color.black;
    [Range(0, 1)] public float crossFade = 0f;
    public float updateFrequency = 0.05f;

    [System.Flags] public enum TimeScaleMode { affectedByGlobalTimeScale = 1, affectedByPause = 2 }
    public TimeScaleMode timeScaleMode = (TimeScaleMode)1;

    protected CanvasGroup group;
    protected float originalAlpha = 1f;
    protected Coroutine currentAnimation;

    protected bool isAnimating = false;
    public bool IsAnimating() { return isAnimating; }

    [Header("UI Feedback")]
    public UIAudioFeedbackConfig feedbackConfig;
    protected AudioSource audioSource;

    // Determines what the current time scale should be for this UI element.
    public float GetTimeScale()
    {
        if ((timeScaleMode & TimeScaleMode.affectedByPause) > 0)
        {
            if (GameManager.Instance && GameManager.Instance.isPaused) return 0f;
        }
        if ((timeScaleMode & TimeScaleMode.affectedByGlobalTimeScale) > 0) return Time.timeScale;
        return 1f;
    }

    public static float GetTimeScale(UIScreen target) { return target.GetTimeScale(); }

    public const int COLOR_FADE_PRIORITY = 1000;

    // Start is called before the first frame update
    protected virtual void Awake()
    {
        // Find an audio source in itself, or a parent object (e.g. Canvas).
        audioSource = GetComponentInParent<AudioSource>();
        if (!audioSource && feedbackConfig)
            Debug.LogWarning($"No Audio Source found in parent! {name} will not have any audio feedback!");

        group = GetComponent<CanvasGroup>();
        originalAlpha = group.alpha;

        switch(sceneEntrance)
        {
            case Transition.fade:
                StartCoroutine(Fade(fadeTime, 1));
                break;
            case Transition.colorFade:
                StartCoroutine(FadeTo(fadeColor, -1,  fadeTime));
                break;
            case Transition.colorFadeAndFade:
                StartCoroutine(ColorFadeAndFade(fadeTime, 1, fadeColor));
                break;
        }
    }

    public void PlayAudioFeedback(string type)
    {
        // Don't play any feedback if there is no audio source or feedback config assigned as well.
        // This prevents NullReferenceExceptions from occurring.
        if (!audioSource || !feedbackConfig) return;

        // Play the sound if we find a valid SFX.
        AudioClip sfx = feedbackConfig.GetSound(type);
        if(sfx) audioSource.PlayOneShot(sfx);
    }

    public void DeactivateAll(float fadeDuration = -1)
    {
        UIScreen[] all = FindObjectsOfType<UIScreen>();
        foreach(UIScreen u in all)
        {
            if (u == this) continue;
            u.Deactivate(fadeDuration);
        }
    }

    public virtual void Activate(bool exclusive = false)
    {
        if (isAnimating) return;

        // If this screen is exclusive, we deactivate all the rest.
        float activationDelay = 0;
        if (exclusive)
        {
            if (crossFade > 0)
            {
                DeactivateAll(fadeTime * crossFade);
                activationDelay = 0;
            }
            else
            {
                activationDelay = fadeTime / 2;
                DeactivateAll(activationDelay);
            }
        }

        gameObject.SetActive(true);
        group.alpha = 0;
        
        StartCoroutine(Activate(activationDelay));
    }

    // Activate function, but with a delay.
    // Meant to be used with a Coroutine.
    public virtual IEnumerator Activate(float delay)
    {
        if (isAnimating) yield break;
        isAnimating = true;
        
        // Creates the delay before the activation happens.
        if (delay >= 0)
        {
            WaitForSecondsRealtime w = new WaitForSecondsRealtime(updateFrequency);
            while(delay > 0)
            {
                yield return w;
                float timeScale = GetTimeScale();
                if (timeScale <= 0) continue;
                delay -= w.waitTime * timeScale;
            }
        }

        // The actual activation.
        gameObject.SetActive(true);
        if (group)
        {
            group.alpha = 0;
            StartCoroutine(Fade(fadeTime, 1));
        }
        
        isAnimating = false;
    }

    public virtual void Deactivate(float fadeDuration = -1)
    {
        if (fadeDuration < 0) fadeDuration = fadeTime;
        if (group)
        {
            group.alpha = originalAlpha;
            StartCoroutine(Fade(fadeDuration, -1));
        }
    }

    // Coroutine that causes a whole Canvas Group to fade in / fade out.
    protected virtual IEnumerator Fade(float duration, int direction = 1, System.Action callback = null)
    {
        WaitForSecondsRealtime w = new WaitForSecondsRealtime(updateFrequency);

        // Don't play as long as another animation is playing on this.
        while (isAnimating) yield return w;

        isAnimating = true;
        float currentDuration = duration;

        group.alpha = direction > 0 ? 0 : originalAlpha;
        group.gameObject.SetActive(true);
        while (currentDuration > 0)
        {
            yield return w;
            float timeScale = GetTimeScale();
            if (timeScale <= 0) continue;
            currentDuration -= w.waitTime * timeScale;
            float ratio = currentDuration / duration;
            group.alpha = (direction > 0 ? 1f - ratio : ratio) * originalAlpha;
        }

        group.alpha = direction > 0 ? originalAlpha : 0;

        if (direction < 0) group.gameObject.SetActive(false);

        isAnimating = false;

        // Perform the callback.
        if (callback != null) callback(); 
    }

    // Instead of fading this element out, we fade this to a color.
    public static IEnumerator FadeTo(Color color, int direction = 1, float duration = 0.5f, System.Action callback = null)
    {
        // Create the fader that we will use to do the fading in / fading out.
        GameObject go = new GameObject("Fader (Temp)");
        RectTransform r = go.AddComponent<RectTransform>();
        Canvas c = go.AddComponent<Canvas>();
        Image img = go.AddComponent<Image>();
        CanvasGroup g = go.AddComponent<CanvasGroup>();
        UIScreen u = go.AddComponent<UIScreen>();

        // Set the default values for all components.
        img.color = color;
        g.alpha = direction > 0 ? 0 : 1;
        g.blocksRaycasts = g.interactable = false;
        c.renderMode = RenderMode.ScreenSpaceOverlay;
        c.sortingOrder = COLOR_FADE_PRIORITY;

        // The actual fading.
        yield return u.Fade(duration, direction);
        Destroy(go, u.updateFrequency);

        // Perform the callback.
        if (callback != null) callback(); 
    }

    protected virtual IEnumerator ColorFadeAndFade(float fadeTime, int direction, Color color)
    {
        group.alpha = 0;
        yield return FadeTo(color, -direction, fadeTime);
        yield return Fade(fadeTime, direction);
    }

    public virtual void LoadScene(int buildIndex)
    {
        StartCoroutine(LoadScene(buildIndex, LoadSceneMode.Single, fadeTime));
    }

    protected virtual IEnumerator LoadScene(int buildIndex, LoadSceneMode loadSceneMode, float fadeDuration = -1)
    {
        if (fadeDuration < 0) fadeDuration = fadeTime;

        // Activate the fade to black.
        yield return FadeTo(fadeColor, 1, fadeDuration);
        group.alpha = 0;

        transform.SetParent(null);
        DontDestroyOnLoad(gameObject);
        SceneManager.LoadScene(buildIndex, loadSceneMode);

        // Clean this object up.
        Destroy(gameObject);
    }

    public virtual void Quit()
    {
        Application.Quit();
    }
}

This will allow us to insert a UIAudioFeedbackConfig into all of our UIScreen components, and let us call PlayAudioFeedback() to play the sounds within the scriptable object.

With this new setup, we can easily assign different sets of sound effects to different UI Screens—we just have to create new UIAudioFeedbackConfig scriptable objects in our project.

For this tutorial however, we will just be using one UIAudioFeedbackConfig scriptable object for all of our UI Screens. If you would like to have different sounds for different UI Screens, you are free to make the necessary configurations on your end.

The image below shows the set-up which I will be using for the rest of this tutorial:

Finally, we’ll need to add an event trigger to each of our buttons, toggles, dropdowns and sliders in all of our screens, so that they play the feedback sound:

c. Automating the Event Triggers in UIScreenEditor

Since there are so many buttons and other interactables in each of our UIScreen objects, instead of manually adding these, we’ll update the UIScreenEditor script so that it will automatically populate the Event Trigger events:

UIScreenEditor.cs

using UnityEditor;
using UnityEditor.Events;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using UnityEngine.Events;
using System.Collections.Generic;
using System.Reflection;

[CustomEditor(typeof(UIScreen), editorForChildClasses: true)]
public class UIScreenEditor : Editor
{

    UIScreen screen;

    void OnEnable()
    {
        screen = target as UIScreen;
    }

    public override void OnInspectorGUI()
    {
        CanvasGroup group = screen.GetComponent<CanvasGroup>();
        if (group)
        {
            if(Mathf.Approximately(group.alpha, 0))
                EditorGUILayout.HelpBox("Your UI Screen has its Canvas Group Alpha set to 0. This will cause any fading for it to not work, as it will save the UI Screen's original Alpha as 0. Please set the Canvas Group Alpha to a non-zero value, and disable the GameObject if you do not want to display the UI Screen.", MessageType.Warning);

            if(!group.blocksRaycasts || !group.interactable)
                EditorGUILayout.HelpBox("Buttons and other interactable elements in your UI Screen will not work unless the Canvas Group has Interactable and Blocks Raycasts turned on.", MessageType.Warning);
        }
        
        base.OnInspectorGUI();

        // Add buttons add / remove event triggers for our feedbackConfig.
        if (screen.feedbackConfig != null)
        {
            if (GUILayout.Button("Add Audio Feedback Events"))
            {
                RemoveAudioFeedbackEvents(false);
                AddAudioFeedbackEvents();
            }
                
            if (GUILayout.Button("Remove Audio Feedback Events"))
                RemoveAudioFeedbackEvents();
        }
    }

    protected virtual void AddAudioFeedbackEvents(bool recordHistory = true)
    {
        // Keep a list of all the objects that have been modified.
        List<GameObject> modifiedObjects = new List<GameObject>();

        foreach (Selectable s in screen.GetComponentsInChildren<Selectable>())
        {
            if(recordHistory) Undo.RecordObject(s.gameObject, "Added Audio Feedback Events.");

            // Get an existing event trigger on the selectable, or add it.
            EventTrigger trigger = s.GetComponent<EventTrigger>() ?? s.gameObject.AddComponent<EventTrigger>();

            FieldInfo[] fields = typeof(UIAudioFeedbackConfig).GetFields();

            foreach (FieldInfo f in fields)
            {
                // Is the variable name suitable?
                EventTriggerType triggerType;
                try
                {
                    triggerType = (EventTriggerType)System.Enum.Parse(typeof(EventTriggerType), f.Name.Substring(0, 1).ToUpper() + f.Name.Substring(1));
                }
                catch (System.Exception)
                {
                    Debug.LogWarning($"UI Audio Feedback Config contains a property {f.Name} which cannot be mapped to an Event Trigger event type.");
                    continue;
                }

                // Is the value inside valid?
                AudioClip audio = (AudioClip)f.GetValue(screen.feedbackConfig);
                if (!audio) continue;

                // Add it to on pointer enter.
                EventTrigger.Entry entry = trigger.triggers.Find(e => e.eventID == triggerType);
                if (entry == null)
                {
                    entry = new EventTrigger.Entry { eventID = triggerType };
                    trigger.triggers.Add(entry);
                }

                // If listener is already added, don't do anything else.
                if (!HasPersistentListener(entry, "PlayAudioFeedback"))
                    UnityEventTools.AddStringPersistentListener(entry.callback, screen.PlayAudioFeedback, f.Name);
                else continue;

                modifiedObjects.Add(s.gameObject);
            }

            // Notify Unity that the Scene has changed.
            EditorUtility.SetDirty(trigger);
        }

        // Select all objects that have been modified.
        Selection.objects = modifiedObjects.ToArray();
    }

    // Remove all the Event Trigger entries in all Selectables that
    // have been added due to the settings in feedbackConfig.
    protected virtual void RemoveAudioFeedbackEvents(bool recordHistory = true)
    {
        // Keep a list of all the objects that have been modified.
        List<GameObject> modifiedObjects = new List<GameObject>();
        foreach (Selectable s in screen.GetComponentsInChildren<Selectable>())
        {
            // Save the action so that it is undoable.
            if(recordHistory) Undo.RecordObject(s.gameObject, "Remove Audio Feedback Events");
            
            // Remove any listener using UIScreen's PlayAudioFeedback function.
            EventTrigger trig = s.GetComponent<EventTrigger>();
            if (trig) RemoveAllPersistentListeners(trig, "PlayAudioFeedback");
            modifiedObjects.Add(s.gameObject);

            // Marks scene content as changed, so that we can save changes in Editor.
            EditorUtility.SetDirty(s.gameObject);
        }

        // Select all modified objects, for UI-friendliness.
        Selection.objects = modifiedObjects.ToArray();
    }

    // Remove all events in an Event Trigger by a certain name.
    void RemoveAllPersistentListeners(EventTrigger t, string methodName, bool removeTriggerIfEmpty = true)
    {
        List<EventTrigger.Entry> emptyEntries = new List<EventTrigger.Entry>();
        foreach (EventTrigger.Entry e in t.triggers)
        {
            RemovePersistentListener(e, methodName);

            // Mark the object for removal afterwards.
            if (e.callback.GetPersistentEventCount() <= 0) emptyEntries.Add(e);
        }

        // Remove all entries that are empty.
        foreach(EventTrigger.Entry e in emptyEntries)
            t.triggers.Remove(e);

        if (t.triggers.Count <= 0) Undo.DestroyObjectImmediate(t);
    }

    // Remove a specific listener in an Event Trigger event type by a certain method name.
    void RemovePersistentListener(EventTrigger.Entry entry, string methodName)
    {
        for (int i = 0; i < entry.callback.GetPersistentEventCount(); i++)
            if (entry.callback.GetPersistentMethodName(i) == methodName)
                UnityEventTools.RemovePersistentListener(entry.callback, i);
    }

    // Check if there is already a listener by a certain name in an EventTrigger entry.
    bool HasPersistentListener(EventTrigger.Entry entry, string methodName)
    {
        for (int i = 0; i < entry.callback.GetPersistentEventCount(); i++)
            if (entry.callback.GetPersistentMethodName(i) == methodName) return true;
        return false;
    }
}

There is a whole lot of code involved in the above. A lot of it has to do with Unity Editor programming, which I will elaborate on in the video.

In summary, this causes the Inspector for UIScreen to show 2 buttons when a valid Feedback Config is assigned:

Clicking on the Add Audio Feedback Events button will automatically find all buttons, toggles, input fields, dropdowns and sliders under your UI Screen, and add an Event Trigger with the appropriate actions to them. Remove Audio Feedback Events does the opposite, removing all previously added actions.

To help you see which are the GameObjects that have been changed, all the updated items will be selected in your Hierarchy:

So, once all that is done, make sure you assign a Feedback Config to every UI Screen in your Main Menu, and click on Add Audio Feedback Events.

After that, test out your Main Menu screen and ensure that everything works.

d. Using directional keys for the Menu

One thing you’ll notice in my Default UI Feedback file is that there is a sound effect assigned for Select, and another assigned for Submit.

This is because it is possible for interactable elements in Unity to interact with Select events as well. To activate this feature, find your Event System GameObject, and assign one of the buttons on your Main Menu to the First Selected property.

This will cause you to be able to navigate your Main Menu (or any other UI screen) using the directional buttons ↑ ↓ ← → and W A S D keys, and get sound effects on selecting or selecting a button (default keys are Enter or Space).

e. Removing UIAudio

One last thing: remember to remove the UIAudio script from your Canvas object in the Main Menu scene! As well as any other copies that may be lying around in your Scene.

4. Rearranging the other Scenes

The hardest parts are over—now we’ll need to retool the UI in the rest of our Scenes, and most of it involves modifying the Canvas prefab that is responsible for our game’s HUD:

a. Subclassing UIManager to UIScreen

The first thing we’ll want to do is remove the Scene Fader GameObject. It is rather cumbersome, since it blocks everything else in our UI.

Since our UIScreen component has fading functionality, let’s subclass UIManager under it, so that we can add an entrance fading animation to it:

UIManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UIManager : MonoBehaviourUIScreen
{
    public SceneFader sceneFader;

    public static UIManager Instance;

    [Header("UI Manager")]
    [SerializeField] GameObjectpublic UIScreen deathScreen;
    public GameObject mapHandler;
    public GameObject inventory;
    [SerializeField] GameObject halfMana, fullMana;

    public enum ManaState
    {
        FullMana,
        HalfMana
    }
    public ManaState manaState;
    privateprotected override void Awake()
    {
        base.Awake();

        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        else
        {
            Instance = this;
        }

        DontDestroyOnLoad(gameObject);
        Instance = this;
        sceneFader = GetComponentInChildren<SceneFader>();
    }
    public void SwitchMana(ManaState _manaState)
    {
        switch(_manaState)
        {
            case ManaState.FullMana:

                halfMana.SetActive(false);
                fullMana.SetActive(true);

                break;

            case ManaState.HalfMana:

                fullMana.SetActive(false);
                halfMana.SetActive(true);

                break;
        }
        manaState = _manaState;
    }
    public IEnumerator ActivateDeathScreen()
    {
        yield return new WaitForSeconds(0.8f);
        StartCoroutine(sceneFader.Fade(SceneFader.FadeDirection.In));

        yield return new WaitForSeconds(0.8f);
        deathScreen.SetActive(true);
    }
    public IEnumerator DeactivateDeathScreen()
    {
        yield return new WaitForSeconds(0.5f);
        deathScreen.SetActive(false);
        StartCoroutine(sceneFader.Fade(SceneFader.FadeDirection.Out));
    }
}

The main changes here are:

1. The removal of the sceneFader, as well as functions that control it, since we’re using the UIScreen now.
2. Converting the deathScreen variable from GameObject to UIScreen, as we’ll be using the UIScreen to control the fading for it.
3. Making the UIManager inherit from UIScreen, so that we can set an entrance animation for it.
4. We have to change the Awake() function to override the parent UIScreen version as well, and call it in our UIManager function using base.Awake(), as it is an important setup function for the UIScreen.

With this change, we will have to update the scripts that previously used ActivateDeathScreen() and DeactivateDeathScreen():

PlayerController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEditor.Build;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    [Header("Horizontal Movement Settings:")]
    [SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
    [Space(5)]

    [Header("Vertical Movement Settings")]
    [SerializeField] private float jumpForce = 45f; //sets how hight the player can jump

    private float jumpBufferCounter = 0; //stores the jump button input
    [SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored

    private float coyoteTimeCounter = 0; //stores the Grounded() bool
    [SerializeField] private float coyoteTime; ////sets the max amount of frames the Grounded() bool is stored

    private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
    [SerializeField] private int maxAirJumps; //the max no. of air jumps
    [SerializeField] private int maxFallingSpeed; //the max no. of air jumps

    private float gravity; //stores the gravity scale at start
    [Space(5)]

    [Header("Wall Jump Settings")]
    [SerializeField] private float wallSlidingSpeed = 2f;
    [SerializeField] private Transform wallCheck;
    [SerializeField] private LayerMask wallLayer;
    [SerializeField] private float wallJumpingDuration;
    [SerializeField] private Vector2 wallJumpingPower;
    float wallJumpingDirection;
    bool isWallSliding;
    bool isWallJumping;
    [Space(5)]

    [Header("Ground Check Settings:")]
    [SerializeField] private Transform groundCheckPoint; //point at which ground check happens
    [SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
    [SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
    [SerializeField] private LayerMask whatIsGround; //sets the ground layer
    [Space(5)]

    [Header("Dash Settings")]
    [SerializeField] private float dashSpeed; //speed of the dash
    [SerializeField] private float dashTime; //amount of time spent dashing
    [SerializeField] private float dashCooldown; //amount of time between dashes
    [SerializeField] GameObject dashEffect;
    private bool canDash = true, dashed;
    [Space(5)]

    [Header("Attack Settings:")]
    [SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
    [SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is

    [SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
    [SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is

    [SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
    [SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is

    [SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of

    [SerializeField] private float timeBetweenAttack;
    private float timeSinceAttack;

    [SerializeField] private float damage; //the damage the player does to an enemy

    [SerializeField] private GameObject slashEffect; //the effect of the slashs

    bool restoreTime;
    float restoreTimeSpeed;
    [Space(5)]

    [Header("Recoil Settings:")]
    [SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
    [SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for

    [SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
    [SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil

    private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
    [Space(5)]

    [Header("Health Settings")]
    public int health;
    public int maxHealth;
    public int maxTotalHealth = 10;
    public int heartShards;
    [SerializeField] GameObject bloodSpurt;
    [SerializeField] float hitFlashSpeed;
    public delegate void OnHealthChangedDelegate();
    [HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;

    float healTimer;
    [SerializeField] float timeToHeal;
    [Space(5)]

    [Header("Mana Settings")]
    [SerializeField] UnityEngine.UI.Image manaStorage;

    [SerializeField] float mana;
    [SerializeField] float manaDrainSpeed;
    [SerializeField] float manaGain;
    public bool halfMana;

    public ManaOrbsHandler manaOrbsHandler;
    public int orbShard;
    public int manaOrbs;
    [Space(5)]

    [Header("Spell Settings")]
    //spell stats
    [SerializeField] float manaSpellCost = 0.3f;
    [SerializeField] float timeBetweenCast = 0.5f;
    [SerializeField] float spellDamage; //upspellexplosion and downspellfireball
    [SerializeField] float downSpellForce; // desolate dive only
    //spell cast objects
    [SerializeField] GameObject sideSpellFireball;
    [SerializeField] GameObject upSpellExplosion;
    [SerializeField] GameObject downSpellFireball;
    float timeSinceCast;
    float castOrHealTimer;
    [Space(5)]

    [Header("Camera Stuff")]
    [SerializeField] private float playerFallSpeedThreshold = -10;
    [Space(5)]

    [Header("Audio")]
    [SerializeField] AudioClip landingSound;
    [SerializeField] AudioClip jumpSound;
    [SerializeField] AudioClip dashAndAttackSound;
    [SerializeField] AudioClip spellCastSound;
    [SerializeField] AudioClip hurtSound;

    [HideInInspector] public PlayerStateList pState;
    [HideInInspector] public Rigidbody2D rb;
    private Animator anim;
    private SpriteRenderer sr;
    private AudioSource audioSource;

    //Input Variables
    private float xAxis, yAxis;
    private bool attack = false;
    bool openMap;
    bool openInventory;

    private bool canFlash = true;

    private bool landingSoundPlayed;

    public static PlayerController Instance;

    //unlocking 
    public bool unlockedWallJump;
    public bool unlockedDash;
    public bool unlockedVarJump;

    public bool unlockedSideCast;
    public bool unlockedUpCast;
    public bool unlockedDownCast;

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
        }
        else
        {
            Instance = this;
        }

        DontDestroyOnLoad(gameObject);
    }


    // Start is called before the first frame update
    void Start()
    {
        pState = GetComponent<PlayerStateList>();

        rb = GetComponent<Rigidbody2D>();
        sr = GetComponent<SpriteRenderer>();

        anim = GetComponent<Animator>();

        manaOrbsHandler = FindObjectOfType<ManaOrbsHandler>();

        audioSource = GetComponent<AudioSource>();

        gravity = rb.gravityScale;

        Mana = mana;
        manaStorage.fillAmount = Mana;

        Health = maxHealth;

        SaveData.Instance.LoadPlayerData();
        if (manaOrbs > 3)
        {
            manaOrbs = 3;
        }

        if (halfMana)
        {
            UIManager.Instance.SwitchMana(UIManager.ManaState.HalfMana);
        }
        else
        {
            UIManager.Instance.SwitchMana(UIManager.ManaState.FullMana);
        }

        if (onHealthChangedCallback != null) onHealthChangedCallback.Invoke();

        if (Health == 0)
        {
            pState.alive = false;
            GameManager.Instance.RespawnPlayer();
        }
    }

    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
        Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
        Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
    }

    // Update is called once per frame
    void Update()
    {
        if (pState.cutscene || GameManager.Instance.isPaused) return;

        if (pState.alive)
        {
            GetInputs();
            ToggleMap();
            ToggleInventory();
        }
        UpdateJumpVariables();

        UpdateCameraYDampForPlayerFall();

        if (pState.dashing) return;
        FlashWhileInvincible();
        if (!pState.alive) return;
        if (!isWallJumping)
        {
            Move();
        }
        Heal();
        CastSpell();
        if (pState.healing) return;
        if (!isWallJumping)
        {
            Flip();
            Jump();
        }

        if (unlockedWallJump)
        {
            WallSlide();
            WallJump();
        }

        if (unlockedDash)
        {
            StartDash();
        }
        Attack();
    }
    private void OnTriggerEnter2D(Collider2D _other) //for up and down cast spell
    {
        if (_other.GetComponent<Enemy>() != null && pState.casting)
        {
            _other.GetComponent<Enemy>().EnemyGetsHit(spellDamage, (_other.transform.position - transform.position).normalized, -recoilYSpeed);
        }
    }

    private void FixedUpdate()
    {
        if (pState.cutscene) return;

        if (pState.dashing || pState.healing) return;
        Recoil();
    }

    void GetInputs()
    {
        //if (GameManager.Instance.isPaused || GameManager.isStopped) return;

        xAxis = Input.GetAxisRaw("Horizontal");
        yAxis = Input.GetAxisRaw("Vertical");
        attack = Input.GetButtonDown("Attack");
        openMap = Input.GetButton("Map");
        openInventory = Input.GetButton("Inventory");

        if (Input.GetButton("Cast/Heal"))
        {
            castOrHealTimer += Time.deltaTime;
        }
    }
    void ToggleMap()
    {
        if (openMap)
        {
            UIManager.Instance.mapHandler.SetActive(true);
        }
        else
        {
            UIManager.Instance.mapHandler.SetActive(false);
        }
    }
    void ToggleInventory()
    {
        if (openInventory)
        {
            UIManager.Instance.inventory.SetActive(true);
        }
        else
        {
            UIManager.Instance.inventory.SetActive(false);
        }
    }

    void Flip()
    {
        if (xAxis < 0)
        {
            transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
            pState.lookingRight = false;
        }
        else if (xAxis > 0)
        {
            transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
            pState.lookingRight = true;
        }
    }

    private void Move()
    {
        if (pState.healing) rb.velocity = new Vector2(0, 0);
        rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
        anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
    }

    void UpdateCameraYDampForPlayerFall()
    {
        //if falling past a certain speed threshold
        if (rb.velocity.y < playerFallSpeedThreshold && !CameraManager.Instance.isLerpingYDamping && !CameraManager.Instance.hasLerpedYDamping)
        {
            StartCoroutine(CameraManager.Instance.LerpYDamping(true));
        }
        //if standing stil or moving up
        if (rb.velocity.y >= 0 && !CameraManager.Instance.isLerpingYDamping && CameraManager.Instance.hasLerpedYDamping)
        {
            //reset camera function
            CameraManager.Instance.hasLerpedYDamping = false;
            StartCoroutine(CameraManager.Instance.LerpYDamping(false));
        }

    }

    void StartDash()
    {
        if (Input.GetButtonDown("Dash") && canDash && !dashed)
        {
            StartCoroutine(Dash());
            dashed = true;
        }

        if (Grounded())
        {
            dashed = false;
        }
    }

    IEnumerator Dash()
    {
        canDash = false;
        pState.dashing = true;
        anim.SetTrigger("Dashing");
        audioSource.PlayOneShot(dashAndAttackSound);
        rb.gravityScale = 0;
        int _dir = pState.lookingRight ? 1 : -1;
        rb.velocity = new Vector2(_dir * dashSpeed, 0);
        if (Grounded()) Instantiate(dashEffect, transform);
        yield return new WaitForSeconds(dashTime);
        rb.gravityScale = gravity;
        pState.dashing = false;
        yield return new WaitForSeconds(dashCooldown);
        canDash = true;
    }

    public IEnumerator WalkIntoNewScene(Vector2 _exitDir, float _delay)
    {
        pState.invincible = true;

        //If exit direction is upwards
        if (_exitDir.y != 0)
        {
            rb.velocity = jumpForce * _exitDir;
        }

        //If exit direction requires horizontal movement
        if (_exitDir.x != 0)
        {
            xAxis = _exitDir.x > 0 ? 1 : -1;

            Move();
        }

        Flip();
        yield return new WaitForSeconds(_delay);
        print("cutscene played");
        pState.invincible = false;
        pState.cutscene = false;
    }

    void Attack()
    {
        timeSinceAttack += Time.deltaTime;
        if (attack && timeSinceAttack >= timeBetweenAttack)
        {
            timeSinceAttack = 0;
            anim.SetTrigger("Attacking");
            audioSource.PlayOneShot(dashAndAttackSound);

            if (yAxis == 0 || yAxis < 0 && Grounded())
            {
                int _recoilLeftOrRight = pState.lookingRight ? 1 : -1;

                Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, Vector2.right * _recoilLeftOrRight, recoilXSpeed);
                Instantiate(slashEffect, SideAttackTransform);
            }
            else if (yAxis > 0)
            {
                Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, Vector2.up, recoilYSpeed);
                SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
            }
            else if (yAxis < 0 && !Grounded())
            {
                Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, Vector2.down, recoilYSpeed);
                SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
            }
        }


    }
    void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilBool, Vector2 _recoilDir, float _recoilStrength)
    {
        Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
        List<Enemy> hitEnemies = new List<Enemy>();

        if (objectsToHit.Length > 0)
        {
            _recoilBool = true;
        }
        for (int i = 0; i < objectsToHit.Length; i++)
        {
            Enemy e = objectsToHit[i].GetComponent<Enemy>();
            if (e && !hitEnemies.Contains(e))
            {
                e.EnemyGetsHit(damage, _recoilDir, _recoilStrength);
                hitEnemies.Add(e);

                if (objectsToHit[i].CompareTag("Enemy"))
                {
                    if (!halfMana && Mana < 1 || (halfMana && Mana < 0.5))
                    {
                        Mana += manaGain;
                    }
                    else
                    {
                        manaOrbsHandler.UpdateMana(manaGain * 3);
                    }
                }
            }
        }
    }
    void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
    {
        _slashEffect = Instantiate(_slashEffect, _attackTransform);
        _slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
        _slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
    }
    void Recoil()
    {
        if (pState.recoilingX)
        {
            if (pState.lookingRight)
            {
                rb.velocity = new Vector2(-recoilXSpeed, 0);
            }
            else
            {
                rb.velocity = new Vector2(recoilXSpeed, 0);
            }
        }

        if (pState.recoilingY)
        {
            rb.gravityScale = 0;
            if (yAxis < 0)
            {
                rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
            }
            else
            {
                rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
            }
            airJumpCounter = 0;
        }
        else
        {
            rb.gravityScale = gravity;
        }

        //stop recoil
        if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
        {
            stepsXRecoiled++;
        }
        else
        {
            StopRecoilX();
        }
        if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
        {
            stepsYRecoiled++;
        }
        else
        {
            StopRecoilY();
        }

        if (Grounded())
        {
            StopRecoilY();
        }
    }
    void StopRecoilX()
    {
        stepsXRecoiled = 0;
        pState.recoilingX = false;
    }
    void StopRecoilY()
    {
        stepsYRecoiled = 0;
        pState.recoilingY = false;
    }
    public void TakeDamage(float _damage)
    {
        if (pState.alive)
        {
            audioSource.PlayOneShot(hurtSound);

            Health -= Mathf.RoundToInt(_damage);
            if (Health <= 0)
            {
                Health = 0;
                StartCoroutine(Death());
            }
            else
            {
                StartCoroutine(StopTakingDamage());
            }
        }

    }
    IEnumerator StopTakingDamage()
    {
        pState.invincible = true;
        GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
        Destroy(_bloodSpurtParticles, 1.5f);
        anim.SetTrigger("TakeDamage");
        yield return new WaitForSeconds(1f);
        pState.invincible = false;
    }

    IEnumerator Flash()
    {
        sr.enabled = !sr.enabled;
        canFlash = false;
        yield return new WaitForSeconds(0.1f);
        canFlash = true;
    }

    void FlashWhileInvincible()
    {
        if (pState.invincible && !pState.cutscene)
        {
            if (Time.timeScale > 0.2 && canFlash)
            {
                StartCoroutine(Flash());
            }
        }
        else
        {
            sr.enabled = true;
        }
    }


    IEnumerator Death()
    {
        pState.alive = false;
        Time.timeScale = 1f;
        GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
        Destroy(_bloodSpurtParticles, 1.5f);
        anim.SetTrigger("Death");

        rb.constraints = RigidbodyConstraints2D.FreezePosition;
        GetComponent<BoxCollider2D>().enabled = false;

        yield return new WaitForSeconds(0.9f);
        StartCoroutine(UIManager.Instance.deathScreen.ActivateDeathScreen());

        yield return new WaitForSeconds(0.1f);
        Instantiate(GameManager.Instance.shade, transform.position, Quaternion.identity);

        SaveData.Instance.SavePlayerData();
    }

    public void Respawned()
    {
        if (!pState.alive)
        {
            rb.constraints = RigidbodyConstraints2D.None;
            rb.constraints = RigidbodyConstraints2D.FreezeRotation;
            GetComponent<BoxCollider2D>().enabled = true;
            pState.alive = true;
            halfMana = true;
            UIManager.Instance.SwitchMana(UIManager.ManaState.HalfMana);
            Mana = 0;
            Health = maxHealth;
            anim.Play("Player_Idle");
        }
    }
    public void RestoreMana()
    {
        halfMana = false;
        UIManager.Instance.SwitchMana(UIManager.ManaState.FullMana);
    }
    public int Health
    {
        get { return health; }
        set
        {
            if (health != value)
            {
                health = Mathf.Clamp(value, 0, maxHealth);

                if (onHealthChangedCallback != null)
                {
                    onHealthChangedCallback.Invoke();
                }
            }
        }
    }
    void Heal()
    {
        if (Input.GetButton("Cast/Heal") && castOrHealTimer > 0.1f && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
        {
            pState.healing = true;
            anim.SetBool("Healing", true);

            //healing
            healTimer += Time.deltaTime;
            if (healTimer >= timeToHeal)
            {
                Health++;
                healTimer = 0;
            }

            //drain mana
            manaOrbsHandler.usedMana = true;
            manaOrbsHandler.countDown = 3f;
            Mana -= Time.deltaTime * manaDrainSpeed;
        }
        else
        {
            pState.healing = false;
            anim.SetBool("Healing", false);
            healTimer = 0;
        }
    }
    public float Mana
    {
        get { return mana; }
        set
        {
            //if mana stats change
            if (mana != value)
            {
                if (!halfMana)
                {
                    mana = Mathf.Clamp(value, 0, 1);
                }
                else
                {
                    mana = Mathf.Clamp(value, 0, 0.5f);
                }

                manaStorage.fillAmount = Mana;
            }
        }
    }

    void CastSpell()
    {
        if (Input.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.1f && timeSinceCast >= timeBetweenCast && Mana >= manaSpellCost)
        {
            pState.casting = true;
            timeSinceCast = 0;
            StartCoroutine(CastCoroutine());
        }
        else
        {
            timeSinceCast += Time.deltaTime;
        }

        if (!Input.GetButton("Cast/Heal"))
        {
            castOrHealTimer = 0;
        }

        if (Grounded())
        {
            //disable downspell if on the ground
            downSpellFireball.SetActive(false);
        }
        //if down spell is active, force player down until grounded
        if (downSpellFireball.activeInHierarchy)
        {
            rb.velocity += downSpellForce * Vector2.down;
        }
    }
    IEnumerator CastCoroutine()
    {
        //side cast
        if ((yAxis == 0 || (yAxis < 0 && Grounded())) && unlockedSideCast)
        {
            audioSource.PlayOneShot(spellCastSound);
            anim.SetBool("Casting", true);
            yield return new WaitForSeconds(0.15f);
            GameObject _fireBall = Instantiate(sideSpellFireball, SideAttackTransform.position, Quaternion.identity);

            //flip fireball
            if (pState.lookingRight)
            {
                _fireBall.transform.eulerAngles = Vector3.zero; // if facing right, fireball continues as per normal
            }
            else
            {
                _fireBall.transform.eulerAngles = new Vector2(_fireBall.transform.eulerAngles.x, 180);
                //if not facing right, rotate the fireball 180 deg
            }
            pState.recoilingX = true;

            Mana -= manaSpellCost;
            manaOrbsHandler.usedMana = true;
            manaOrbsHandler.countDown = 3f;
            yield return new WaitForSeconds(0.35f);
        }

        //up cast
        else if (yAxis > 0 && unlockedUpCast)
        {
            audioSource.PlayOneShot(spellCastSound);
            anim.SetBool("Casting", true);
            yield return new WaitForSeconds(0.15f);

            Instantiate(upSpellExplosion, transform);
            rb.velocity = Vector2.zero;

            Mana -= manaSpellCost;
            manaOrbsHandler.usedMana = true;
            manaOrbsHandler.countDown = 3f;
            yield return new WaitForSeconds(0.35f);
        }

        //down cast
        else if ((yAxis < 0 && !Grounded()) && unlockedDownCast)
        {
            audioSource.PlayOneShot(spellCastSound);
            anim.SetBool("Casting", true);
            yield return new WaitForSeconds(0.15f);

            downSpellFireball.SetActive(true);

            Mana -= manaSpellCost;
            manaOrbsHandler.usedMana = true;
            manaOrbsHandler.countDown = 3f;
            yield return new WaitForSeconds(0.35f);
        }


        anim.SetBool("Casting", false);
        pState.casting = false;
    }

    public bool Grounded()
    {
        if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
            || Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
            || Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    void Jump()
    {
        if (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
        {
            if (Input.GetButtonDown("Jump"))
            {
                audioSource.PlayOneShot(jumpSound);
            }

            rb.velocity = new Vector3(rb.velocity.x, jumpForce);

            pState.jumping = true;
        }

        if (!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump") && unlockedVarJump)
        {
            audioSource.PlayOneShot(jumpSound);

            pState.jumping = true;

            airJumpCounter++;

            rb.velocity = new Vector3(rb.velocity.x, jumpForce);
        }

        if (Input.GetButtonUp("Jump") && rb.velocity.y > 3)
        {
            pState.jumping = false;

            rb.velocity = new Vector2(rb.velocity.x, 0);
        }

        rb.velocity = new Vector2(rb.velocity.x, Mathf.Clamp(rb.velocity.y, -maxFallingSpeed, rb.velocity.y));

        anim.SetBool("Jumping", !Grounded());
    }

    void UpdateJumpVariables()
    {
        if (Grounded())
        {
            if (!landingSoundPlayed)
            {
                audioSource.PlayOneShot(landingSound);
                landingSoundPlayed = true;
            }
            pState.jumping = false;
            coyoteTimeCounter = coyoteTime;
            airJumpCounter = 0;
        }
        else
        {
            coyoteTimeCounter -= Time.deltaTime;
            landingSoundPlayed = false;
        }

        if (Input.GetButtonDown("Jump"))
        {
            jumpBufferCounter = jumpBufferFrames;
        }
        else
        {
            jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
        }
    }

    private bool Walled()
    {
        return Physics2D.OverlapCircle(wallCheck.position, 0.2f, wallLayer);
    }

    void WallSlide()
    {
        if (Walled() && !Grounded() && xAxis != 0)
        {
            isWallSliding = true;
            rb.velocity = new Vector2(rb.velocity.x, Mathf.Clamp(rb.velocity.y, -wallSlidingSpeed, float.MaxValue));
        }
        else
        {
            isWallSliding = false;
        }
    }
    void WallJump()
    {
        if (isWallSliding)
        {
            isWallJumping = false;
            wallJumpingDirection = !pState.lookingRight ? 1 : -1;

            CancelInvoke(nameof(StopWallJumping));
        }

        if (Input.GetButtonDown("Jump") && isWallSliding)
        {
            audioSource.PlayOneShot(jumpSound);
            isWallJumping = true;
            rb.velocity = new Vector2(wallJumpingDirection * wallJumpingPower.x, wallJumpingPower.y);

            dashed = false;
            airJumpCounter = 0;

            pState.lookingRight = !pState.lookingRight;

            float jumpDirection = pState.lookingRight ? 0 : 180;
            transform.eulerAngles = new Vector2(transform.eulerAngles.x, jumpDirection);

            Invoke(nameof(StopWallJumping), wallJumpingDuration);
        }
    }

    void StopWallJumping()
    {
        isWallJumping = false;
        transform.eulerAngles = new Vector2(transform.eulerAngles.x, 0);
    }
}

We make the same update in GameManager as well, and change the pauseMenu variable to use a UIScreen instead of a GameObject (so that we can call Activate() and Deactivate() on it to fade it in and out).

We also add a [DisallowMultipleComponent] attribute to our GameManager, to prevent instances where someone

GameManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

[DisallowMultipleComponent]
public class GameManager : MonoBehaviour
{
    public string transitionedFromScene;

    public Vector2 platformingRespawnPoint;
    public Vector2 respawnPoint;
    [SerializeField] Vector2 defaultRespawnPoint;
    [SerializeField] Bench bench;

    public GameObject shade;

    [SerializeField] private FadeUIUIScreen pauseMenu;
    [SerializeField] private float fadeTime;
    public bool isPaused;
    float lastTimeScale = -1f;
    static Coroutine stopGameCoroutine;
    public static bool isStopped { get { return stopGameCoroutine != null; } }

    public bool THKDefeated = false;

    public static GameManager Instance { get; private set; }
    private void Awake()
    {
        SaveData.Instance.Initialize();

        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
        }
        else
        {
            Instance = this;
        }

        if (PlayerController.Instance != null)
        {
            if (PlayerController.Instance.halfMana)
            {
                SaveData.Instance.LoadShadeData();
                if (SaveData.Instance.sceneWithShade == SceneManager.GetActiveScene().name || SaveData.Instance.sceneWithShade == "")
                {
                    Instantiate(shade, SaveData.Instance.shadePos, SaveData.Instance.shadeRot);
                }
            }
        }

        SaveScene();

        DontDestroyOnLoad(gameObject);

        bench = FindObjectOfType<Bench>();

        SaveData.Instance.LoadBossData();
    }
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.P))
        {
            SaveData.Instance.SavePlayerData();
        }

        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Pause(!isPaused);
        }
    }

    public void Pause(bool b)
    {
        if (b)
        {
            // Save the timescale we will restore to.
            if (lastTimeScale < 0)
                lastTimeScale = Time.timeScale;
            Time.timeScale = 0f;
            pauseMenu.Activate();
        }
        else
        {
            if (!isStopped)
            {
                Time.timeScale = lastTimeScale;
                lastTimeScale = -1;
            }
            pauseMenu.Deactivate();
        }
        pauseMenu.Fade(fadeTime, b);
        isPaused = b;
    }

    public static void Stop(float duration = .5f, float restoreDelay = .1f, float slowMultiplier = 0f)
    {
        if (stopGameCoroutine != null) return;
        stopGameCoroutine = Instance.StartCoroutine(HandleStopGame(duration, restoreDelay, slowMultiplier));
    }

    // Used to create the hit stop effect. 
    // <duration> specifies how long it lasts for.
    // <restoreDelay> specifies how quickly we go back to the original time scale.
    // <stopMultiplier> lets us control how much the stop is.
    static IEnumerator HandleStopGame(float duration, float restoreDelay, float slowMultiplier = 0f)
    {
        if (Instance.lastTimeScale < 0)
            Instance.lastTimeScale = Time.timeScale; // Saves the original time scale for restoration later.

        Time.timeScale = Instance.lastTimeScale * slowMultiplier;

        // Counts down every frame until the stop game is finished.
        WaitForEndOfFrame w = new WaitForEndOfFrame();
        while (duration > 0)
        {
            // Don't count down if the game is paused, and don't loop as well.
            if (Instance.isPaused)
            {
                yield return w;
                continue;
            }

            // Set the time back to zero, since unpausing sets it back to 1.
            Time.timeScale = Instance.lastTimeScale * slowMultiplier;

            // Counts down.
            duration -= Time.unscaledDeltaTime;
            yield return w;
        }

        // Save the last time scale we want to restore to.
        float timeScaleToRestore = Instance.lastTimeScale;

        // Signal that the stop is finished.
        Instance.lastTimeScale = -1;
        stopGameCoroutine = null;

        // If a restore delay is set, restore the time scale gradually.
        if (restoreDelay > 0)
        {
            // Moves the timescale from the value it is set to, to its original value.
            float currentTimeScale = timeScaleToRestore * slowMultiplier;
            float restoreSpeed = (timeScaleToRestore - currentTimeScale) / restoreDelay;
            while (currentTimeScale < timeScaleToRestore)
            {
                // Stop this if the game is paused.
                if (Instance.isPaused)
                {
                    yield return w;
                    continue;
                }

                // End this coroutine if another stop has started.
                if (isStopped) yield break;

                // Set the timescale to the current value this frame.
                currentTimeScale += restoreSpeed * Time.unscaledDeltaTime;
                Time.timeScale = currentTimeScale;

                // Wait for a frame.
                yield return w;
            }
        }

        // Only restore the timeScale if it is not stopped again.
        // Can happen if another stop fires while restoring the time scale.
        if (!isStopped) Time.timeScale = timeScaleToRestore;
    }
    public void SaveScene()
    {
        string currentSceneName = SceneManager.GetActiveScene().name;
        SaveData.Instance.sceneNames.Add(currentSceneName);
    }

    public void SaveGame()
    {
        SaveData.Instance.SavePlayerData();
    }
    public void RespawnPlayer()
    {
        SaveData.Instance.LoadBench();
        if (SaveData.Instance.benchSceneName != null) //load the bench's scene if it exists.
        {
            SceneManager.LoadScene(SaveData.Instance.benchSceneName);
        }

        if (SaveData.Instance.benchPos != null) //set the respawn point to the bench's position.
        {
            respawnPoint = SaveData.Instance.benchPos;
        }
        else
        {
            respawnPoint = defaultRespawnPoint;
        }

        PlayerController.Instance.transform.position = respawnPoint;

        StartCoroutine(UIManager.Instance.deathScreen.DeactivateDeathScreen());
        PlayerController.Instance.Respawned();
    }
}

b. Removing SceneFader dependencies

We will also need to remove the other dependencies on the SceneFader script, since we’ve just removed it from the UIManager. The Spikes that we have in-game, for instance, are now missing a SceneFader (I’m also taking the chance to remove some redundant lines):

Spikes.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Spikes : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {

    }
    public float hitFadeTime = 0.6f;

    private void OnTriggerEnter2D(Collider2D _other)
    {
        if (_other.CompareTag("Player"))
        {
            StartCoroutine(RespawnPoint());
        }
    }

    IEnumerator RespawnPoint()
    {
        PlayerController.Instance.pState.cutscene = true;
        PlayerController.Instance.pState.invincible = true;
        PlayerController.Instance.rb.velocity = Vector2.zero;
        Time.timeScale = 0f;
        StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.In));
        StartCoroutine(UIScreen.FadeTo(Color.black, 1));
        PlayerController.Instance.TakeDamage(1);
        yield return new WaitForSecondsRealtime(1fhitFadeTime);
        Time.timeScale = 1;
        PlayerController.Instance.transform.position = GameManager.Instance.platformingRespawnPoint;
        StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.Out));
        StartCoroutine(UIScreen.FadeTo(Color.black, -1));
        yield return new WaitForSecondsRealtime(UIManager.Instance.sceneFader.fadeTimehitFadeTime);
        PlayerController.Instance.pState.cutscene = false;
        PlayerController.Instance.pState.invincible = false;
    }
}

The SceneTransition script, which we use to transition between Scenes, also use the Scene Fader. Again, we replace it with the equivalent in UIScreen.FadeTo(), which does not require us to have a Scene Fader GameObject in the Scene.

SceneTransition.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneTransition : MonoBehaviour
{
    [SerializeField] private string transitionTo;
    public Color fadeColor = Color.black;
    [SerializeField] private Transform startPoint;

    [SerializeField] private Vector2 exitDirection;

    [SerializeField] private float exitTime;

    // Start is called before the first frame update
    private void Start()
    {
        if(GameManager.Instance.transitionedFromScene == transitionTo)
        {
            PlayerController.Instance.transform.position = startPoint.position;

            StartCoroutine(PlayerController.Instance.WalkIntoNewScene(exitDirection, exitTime));
        }
StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.Out));
        StartCoroutine(UIScreen.FadeTo(fadeColor, 1));
    }

    private void OnTriggerEnter2D(Collider2D _other)
    {
        if (_other.CompareTag("Player"))
        {
            CheckShadeData();

            GameManager.Instance.transitionedFromScene = SceneManager.GetActiveScene().name;

            PlayerController.Instance.pState.cutscene = true;
            PlayerController.Instance.pState.invincible = true;

            StartCoroutine(UIManager.Instance.sceneFader.FadeAndLoadScene(SceneFader.FadeDirection.In, transitionTo));
            StartCoroutine(UIScreen.FadeTo(fadeColor, 1));
        }
    }
    void CheckShadeData()
    {
        GameObject[] enemyObjects = GameObject.FindGameObjectsWithTag("Enemy");

        for (int i = 0; i < enemyObjects.Length; i++)
        {
            if (enemyObjects[i].GetComponent<Shade>() != null)
            {
                SaveData.Instance.SaveShadeData();
            }
        }
    }
}

c. Reorganising the HUD Canvas

Now that everything is sorted, we can reorganise the Canvas in our scenes that is responsible for the HUD. Because it affects all the Scenes, it is best to modify the prefab directly.

We will:

1. Remove the Scene Fader GameObject, since it is no longer needed.
2. Add a UIScreen to both the Pause Screen and Death Screen GameObjects, replacing the old FadeUI element. Remember to add a Feedback Config to them if you want their buttons to have sound feedback!
3. Reassign the Death Screen on the UI Manager component as well.

5. Finally—and most importantly—we will be moving the GameManager component onto the Canvas GameObject and deleting the previous Game Manager object.

The reason we move the GameManager into the Canvas is because our the GameManager has many co-dependencies with the UIManager which cannot be saved in prefab mode.

For example, because the GameManager is on a separate GameObject, the prefab is unable to store the button actions in our Pause Menu buttons, so we have to manually assign them in every Scene, or the buttons won’t work. This can potentially cause issues when you Play-in-Editor from other maps, which are difficult to identify.

By putting the GameManager onto our Canvas, we can now assign the actions for the Resume and Quit to Main Menu buttons in the prefab itself, which means we won’t run into any more button bugs in our other Scenes.

Similarly, we can also assign the Pause Menu of the Game Manager on the prefab itself!

5. Conclusion

That’s it for this part! In the next part, we will be integrating our new UI system with the existing pickup system that we have in our game.

If you are a silver Patron, you will be able to download the project files as well.