Implement pause logic for coroutine types

src/Coroutines/AwaitCoroutine.cs

@@ -16,7 +16,7 @@ public AwaitCoroutine(Task<T> task)
         this.Task = task;
     }
 
-    protected override void OnEnter()
+    protected override void OnStart()
     {
         // As the CoroutineManager class is not thread safe, ensure that Kill()
         // is executed on the main Godot thread.
@@ -39,7 +39,7 @@ public AwaitCoroutine(Task task)
         this.Task = task;
     }
 
-    protected override void OnEnter()
+    protected override void OnStart()
     {
         // As the CoroutineManager class is not thread safe, ensure that Kill()
         // is executed on the main Godot thread.

src/Coroutines/Coroutine.cs

@@ -21,7 +21,6 @@ public Coroutine(IEnumerator routine)
 
     public Coroutine(Func<Coroutine, IEnumerator> creator)
     {
-        // TODO: Only create the coroutine OnEnter() (e.g. Sequence of Wait and Coroutine)?
         this.routine = creator(this);
     }
 
@@ -30,9 +29,11 @@ protected override void OnEnter()
         if (routine == null)
         {
             Kill();
-            return;
         }
+    }
 
+    protected override void OnStart()
+    {
         EnableUpdates();
     }
 
@@ -56,9 +57,9 @@ public override void Update()
         // coroutine is finished.
         if (obj is CoroutineBase childCoroutine)
         {
-            // It's important to pause before starting the child coroutine.
+            // It's important to disable updates before starting the child coroutine.
             // Otherwise, if the child coroutine instantly terminates, which would
-            // lead to this coroutine resuming, it would pause this coroutine.
+            // lead to this coroutine resuming updates, it would disable updates to this coroutine.
             // That would not be correct.
             DisableUpdates();
             StartCoroutine(childCoroutine);

src/Coroutines/ParallelCoroutine.cs

@@ -17,9 +17,11 @@ protected override void OnEnter()
         if (coroutines.Length == 0)
         {
             Kill();
-            return;
         }
-
+    }
+
+    protected override void OnStart() 
+    {
         foreach (CoroutineBase coroutine in coroutines)
         {
             StartCoroutine(coroutine);

src/Coroutines/RepeatCoroutine.cs

@@ -14,6 +14,10 @@ public class RepeatCoroutine : CoroutineBase
 
     private bool IsInfinite => repeatTimes == -1;
 
+    // If the coroutine that is being repeated completes while the game is paused, it is not instantly restarted.
+    // Instead, it is restarted once the game is resumed, which is indicated by this flag.
+    private bool isRepeatPending;
+
     public RepeatCoroutine(int repeatTimes, Func<RepeatCoroutine, CoroutineBase> coroutineCreator)
     {
         this.repeatTimes = repeatTimes;
@@ -25,9 +29,11 @@ protected override void OnEnter()
         if (repeatTimes == 0)
         {
             Kill();
-            return;
         }
+    }
 
+    protected override void OnStart()
+    {
         Repeat();
     }
 
@@ -48,6 +54,27 @@ protected override void OnChildStopped(CoroutineBase child)
             return;
         }
 
-        Repeat();
+        TryRepeat();
+    }
+
+    private void TryRepeat()
+    {
+        if (IsRunning)
+        {
+            Repeat();
+        }
+        else
+        {
+            isRepeatPending = true;
+        }
+    }
+
+    protected override void OnResume()
+    {
+        if (isRepeatPending)
+        {
+            isRepeatPending = false;
+            Repeat();
+        }
     }
 }

src/Coroutines/SequentialCoroutine.cs

@@ -8,6 +8,10 @@ public class SequentialCoroutine : CoroutineBase
 {
     private readonly CoroutineBase[] coroutines;
     private int idx = 0;
+
+    // If one of the steps completes while the game is paused, the next step is not instantly run.
+    // Instead, it is only run once the game is resumed again, which is indicated by this flag.
+    private bool isSwitchToNextCoroutinePending = false;
 
     public SequentialCoroutine(params CoroutineBase[] coroutines)
     {
@@ -19,9 +23,11 @@ protected override void OnEnter()
         if (coroutines.Length == 0)
         {
             Kill();
-            return;
         }
+    }
 
+    protected override void OnStart()
+    {
         StartCoroutine(coroutines[0]);
     }
 
@@ -32,11 +38,32 @@ protected override void OnChildStopped(CoroutineBase child)
         idx += 1;
         if (idx < coroutines.Length)
         {
-            StartCoroutine(coroutines[idx]);
+            TryStartNextCoroutine();
         }
         else
         {
             Kill();
         }
     }
+
+    private void TryStartNextCoroutine()
+    {
+        if (IsRunning)
+        {
+            StartCoroutine(coroutines[idx]);
+        }
+        else
+        {
+            isSwitchToNextCoroutinePending = true;
+        }
+    }
+
+    protected override void OnResume()
+    {
+        if (isSwitchToNextCoroutinePending)
+        {
+            isSwitchToNextCoroutinePending = false;
+            StartCoroutine(coroutines[idx]);
+        }
+    }
 }

src/Coroutines/TweenCoroutine.cs

@@ -18,7 +18,7 @@ public TweenCoroutine(Func<Tween> createTween)
         this.createTween = createTween;
     }
 
-    protected override void OnEnter()
+    protected override void OnStart()
     {
         tween = createTween();
 

src/Coroutines/WaitDelayCoroutine.cs

@@ -14,6 +14,7 @@ public WaitDelayCoroutine(float delay)
 
     protected override void OnEnter()
     {
+        // TODO: Implement pause logic.
         Manager.GetTree().CreateTimer(delay).Timeout += Kill;
     }
 }

src/Coroutines/WaitUntilCoroutine.cs

@@ -14,7 +14,7 @@ public WaitUntilCoroutine(Func<Boolean> condition)
         this.condition = condition;
     }
 
-    protected override void OnEnter()
+    protected override void OnStart()
     {
         CheckCondition();
         if (IsAlive) EnableUpdates();

src/Coroutines/WaitWhileCoroutine.cs

@@ -14,7 +14,7 @@ public WaitWhileCoroutine(Func<Boolean> condition)
         this.condition = condition;
     }
 
-    protected override void OnEnter()
+    protected override void OnStart()
     {
         CheckCondition();
         if (IsAlive) EnableUpdates();