c# – What’s the proper / idiomatic approach to pause a sport in Unity?

I am making an attempt to implement a sturdy pause system in Unity and I am confused concerning the appropriate method. My first (quite simple) implementation in my earlier venture used a PauseManager with a single bool isPausing, and when paused I did two issues:

Time.timeScale = 0f;
AudioListener.pause = true;

That was “ok” for that venture as a result of all my coroutines relied on WaitForSeconds (which respects timeScale) and Replace() occurred to not do something problematic. However I simply was fortunate. As I dig deeper I found a number of behaviors that make a easy timeScale = 0 method fragile:

• Replace() continues to be known as each body even when Time.timeScale = 0.
• FixedUpdate() does cease (physics loop is tied to scaled time).
• Coroutines are difficult: yield return new WaitForSeconds(...) will block whereas timeScale is 0, however yield return null nonetheless resumes on the following body — so coroutines are usually not absolutely “paused” simply by setting timeScale = 0.

I experimented with a couple of totally different approaches and bumped into limitations:

Method A — Broadcast pause occasion, every script checks a flag

Every script subscribes to a PauseEvent and units an isPausing discipline:

personal void OnEnable() { PauseManager.OnPause += OnPause; }
personal void OnDisable() { PauseManager.OnPause -= OnPause; }

personal void OnPause(bool isPausing) { this.isPausing = isPausing; }

personal void Replace()
{
    if (isPausing) return;
    // regular replace behaviour
}

But it surely’s tedious so as to add that to each script and it would not remedy coroutine conduct (coroutines can nonetheless progress in the event that they use yield return null).
Really, I might do one thing comparable in coroutines, like:

yield return new WaitUntil(() => PauseManager.Occasion.Standing == PauseManager.GameInProgress);

However including that to each single coroutine is sort of tedious.

Method B — Single ScriptPauser that permits/disables a listing of parts

One central script subscribes to the pause occasion and permits/disables a listing of MonoBehaviour parts:

personal void OnEnable() { PauseManager.OnPause += OnPause; }
personal void OnPause(bool isPausing)
{
    foreach (var mb in monoBehavioursToToggle) mb.enabled = !isPausing;
}

However I’ve to manually preserve that listing and furthermore coroutines are usually not stopped in any respect if I disable the script they’re working into.

Method C — Put all gameplay objects below a single mother or father and disable that GameObject

I’ve two top-level GameObjects: ActualGame and PauseManager. When pausing I merely ActualGame.SetActive(false) and present the pause UI.

Nevertheless, animators lose their runtime state until I set animator.keepAnimatorStateOnDisable = true for each animator below the mother or father. Furthermore, coroutines began on parts below that mother or father don’t resume when the GameObject / element is re-enabled.
For the time being, I am following this method and it is working fairly effectively. I believe on this method I needn’t write Time.timeScale = 0f; both.
I am not utilizing coroutines in any respect: as a substitute I created a form of MyCoroutine class that mimics coroutines. Writing coroutines utilizing my class is sort of verbose, however at the least it really works and they are often paused and resumed.

My questions

1) What’s the beneficial / idiomatic sample in Unity for pausing a sport that:

a. Stops gameplay (motion, AI, physics) cleanly

b. Pauses animations and audio correctly (and restores them on resume)

c. Handles coroutines sensibly (both pausing them, or offering a transparent sample to write down pause-aware coroutines)

d. Is maintainable (doesn’t require including plenty of boilerplate to each script)

2) What do you concentrate on the earlier approaches (A, B, C)?