⏸️ Lesson 4.2: Main Menu & Pause System

Building a Main Menu

A main menu is usually its own scene — say MainMenu — that the game boots into. It's just an Overlay Canvas (from Lesson 4.1) holding a title, a few buttons, and maybe a background image. The buttons don't do anything special; they call methods on a script.

Here's a minimal main-menu controller. Notice it uses SceneManager to load the gameplay scene — we cover scene loading in depth in Module 5, so for now just know LoadScene switches scenes by name (add both scenes to File ▸ Build Profiles ▸ Scene List first).

using UnityEngine;
using UnityEngine.SceneManagement;

public class MainMenu : MonoBehaviour
{
    [SerializeField] string gameplaySceneName = "Game";

    public void PlayGame()
    {
        Time.timeScale = 1f;              // make sure we start unpaused
        SceneManager.LoadScene(gameplaySceneName);
    }

    public void QuitGame()
    {
        Debug.Log("Quit requested");      // visible in the Editor, where Quit does nothing
        Application.Quit();               // only actually quits in a build
    }
}

To connect a button, select it, find its Button ▸ On Click () list in the Inspector, click +, drag in the object holding MainMenu, and pick MainMenu ▸ PlayGame from the dropdown. That's the same event wiring you met in Fundamentals — we'll lean on it again for the pause menu.

The Pause Menu Hierarchy

The pause menu is different from the main menu: it lives inside your gameplay scene, hidden until needed. The trick is to build it as a single parent Panel that you switch on and off. Here's the Hierarchy layout you're aiming for:

The key idea: build the panel once, set it inactive (untick the checkbox at the top-left of its Inspector), and let a script flip it on. Everything inside it — the dim background, the title, the buttons — appears and disappears with the parent.

Freezing the Game with Time.timeScale

Pausing isn't just hiding the game behind a panel — the action underneath has to stop. Unity gives you one global dial for this: Time.timeScale.

• Time.timeScale = 1f → normal speed (the default).
• Time.timeScale = 0f → frozen. Physics stops, Time.deltaTime becomes 0, and anything driven by it halts.
• Time.timeScale = 0.5f → half speed (handy for slow-motion effects).

Setting it to 0 freezes almost everything automatically: Rigidbody motion, most animations, and any code that multiplies by Time.deltaTime (which, if you followed Fundamentals, is most of your movement code). That's why it's the standard pause switch.

Toggling the Pause Panel

Now the controller that ties the panel and the time freeze together. It tracks whether we're paused, shows/hides the panel with SetActive, and drives Time.timeScale. The button methods (Resume, Restart, QuitToMenu) are public so the Inspector's On Click events can call them.

using UnityEngine;
using UnityEngine.SceneManagement;

public class PauseController : MonoBehaviour
{
    [SerializeField] GameObject pauseMenu;   // the PauseMenu panel

    public bool IsPaused { get; private set; }

    public void TogglePause()
    {
        if (IsPaused) Resume();
        else Pause();
    }

    public void Pause()
    {
        IsPaused = true;
        pauseMenu.SetActive(true);           // show the panel
        Time.timeScale = 0f;                 // freeze gameplay
    }

    public void Resume()
    {
        IsPaused = false;
        pauseMenu.SetActive(false);          // hide the panel
        Time.timeScale = 1f;                 // unfreeze
    }

    public void Restart()
    {
        Time.timeScale = 1f;                 // ALWAYS restore before leaving!
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
    }

    public void QuitToMenu()
    {
        Time.timeScale = 1f;                 // ALWAYS restore before leaving!
        SceneManager.LoadScene("MainMenu");
    }
}

Pause from the Input System

In Module 3 you built Input Actions and read them through callbacks. Pausing is a perfect one-shot action. Add an action called Pause to your Action Map (bind it to Escape on keyboard and Start on gamepad), set its Action Type to Button, and subscribe to its performed callback.

Here's the pause controller wired to a PlayerInput-style action reference. Using an InputActionReference keeps the binding editable in the Inspector:

using UnityEngine;
using UnityEngine.InputSystem;

public class PauseInput : MonoBehaviour
{
    [SerializeField] PauseController pause;
    [SerializeField] InputActionReference pauseAction;   // the "Pause" action

    void OnEnable()
    {
        pauseAction.action.performed += OnPause;
        pauseAction.action.Enable();
    }

    void OnDisable()
    {
        pauseAction.action.performed -= OnPause;
    }

    void OnPause(InputAction.CallbackContext ctx)
    {
        pause.TogglePause();     // one press flips between paused and playing
    }
}

Because input polling and action callbacks are driven by real time (not scaled game time), the Pause action keeps firing even when Time.timeScale is 0 — which is exactly what lets the player press Escape again to un-pause. If you had instead read a key inside a deltaTime-based loop, you'd be fine here too, since reading input doesn't depend on deltaTime.

Animating While Paused: Unscaled Time

Here's the gotcha that surprises everyone. You freeze the game with Time.timeScale = 0, then your pause menu's fade-in or button-hover animation… doesn't play. Because the Animator and any Time.deltaTime code are running on scaled time — which you just set to zero.

The fix is unscaled time — a parallel clock that ignores timeScale and always ticks in real seconds:

• In code: use Time.unscaledDeltaTime instead of Time.deltaTime for any animation that must run while paused (a menu fade, a spinner).
• On an Animator: set its Update Mode to Unscaled Time (Animator component ▸ Update Mode dropdown). It will now animate even at timeScale 0.
• On coroutines: yield new WaitForSecondsRealtime(0.3f) instead of WaitForSeconds, which would wait forever at timeScale 0.

A simple unscaled fade for the pause panel's CanvasGroup:

using System.Collections;
using UnityEngine;

public class PanelFade : MonoBehaviour
{
    [SerializeField] CanvasGroup group;
    [SerializeField] float duration = 0.25f;

    public void FadeIn()
    {
        gameObject.SetActive(true);
        StartCoroutine(Fade(0f, 1f));
    }

    IEnumerator Fade(float from, float to)
    {
        float t = 0f;
        while (t < duration)
        {
            t += Time.unscaledDeltaTime;              // real time, ignores the pause
            group.alpha = Mathf.Lerp(from, to, t / duration);
            yield return null;
        }
        group.alpha = to;
    }
}

The whole pause flow, end to end:

Figure 2: The pause state flow. The Pause action toggles between Playing and Paused; any exit path first restores timeScale to 1.

Hands-on Challenge

Summary

🚀 What's Next?

Your menus are done. Now for the UI that changes every frame while you play. In Lesson 4.3: HUD — Health Bars & Live Data you'll build a health bar from a Filled Image, drive it from a health event, and smooth its motion with Lerp so it glides instead of snapping.