From f199112d9985ac0d2523c6fc3c73a573c1685563 Mon Sep 17 00:00:00 2001
From: Ellpeck <megamaximal@gmail.com>
Date: Sat, 13 Jun 2020 03:02:11 +0200
Subject: [PATCH] allow coroutine handler instancing. Actually solves #2

---
 Coroutine/CoroutineHandler.cs         | 44 +++---------------
 Coroutine/CoroutineHandlerInstance.cs | 65 +++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 37 deletions(-)
 create mode 100644 Coroutine/CoroutineHandlerInstance.cs

diff --git a/Coroutine/CoroutineHandler.cs b/Coroutine/CoroutineHandler.cs
index 01cfa21..7acbe67 100644
--- a/Coroutine/CoroutineHandler.cs
+++ b/Coroutine/CoroutineHandler.cs
@@ -5,60 +5,30 @@ using System.Linq;
 namespace Coroutine {
     public static class CoroutineHandler {
 
-        private static readonly List<ActiveCoroutine> TickingCoroutines = new List<ActiveCoroutine>();
-        private static readonly List<ActiveCoroutine> EventCoroutines = new List<ActiveCoroutine>();
+        private static readonly CoroutineHandlerInstance Instance = new CoroutineHandlerInstance();
 
         public static ActiveCoroutine Start(IEnumerable<Wait> coroutine) {
-            return Start(coroutine.GetEnumerator());
+            return Instance.Start(coroutine);
         }
 
         public static ActiveCoroutine Start(IEnumerator<Wait> coroutine) {
-            var inst = new ActiveCoroutine(coroutine);
-            if (inst.MoveNext()) {
-                if (inst.IsWaitingForEvent()) {
-                    EventCoroutines.Add(inst);
-                } else {
-                    TickingCoroutines.Add(inst);
-                }
-            }
-            return inst;
+            return Instance.Start(coroutine);
         }
 
         public static void InvokeLater(Wait wait, Action action) {
-            Start(InvokeLaterImpl(wait, action));
+            Instance.InvokeLater(wait, action);
         }
 
         public static void Tick(double deltaSeconds) {
-            for (var i = TickingCoroutines.Count - 1; i >= 0; i--) {
-                var coroutine = TickingCoroutines[i];
-                if (coroutine.Tick(deltaSeconds)) {
-                    TickingCoroutines.RemoveAt(i);
-                } else if (coroutine.IsWaitingForEvent()) {
-                    TickingCoroutines.RemoveAt(i);
-                    EventCoroutines.Add(coroutine);
-                }
-            }
+            Instance.Tick(deltaSeconds);
         }
 
         public static void RaiseEvent(Event evt) {
-            for (var i = EventCoroutines.Count - 1; i >= 0; i--) {
-                var coroutine = EventCoroutines[i];
-                if (coroutine.OnEvent(evt)) {
-                    EventCoroutines.RemoveAt(i);
-                } else if (!coroutine.IsWaitingForEvent()) {
-                    EventCoroutines.RemoveAt(i);
-                    TickingCoroutines.Add(coroutine);
-                }
-            }
+            Instance.RaiseEvent(evt);
         }
 
         public static IEnumerable<ActiveCoroutine> GetActiveCoroutines() {
-            return TickingCoroutines.Concat(EventCoroutines);
-        }
-
-        private static IEnumerator<Wait> InvokeLaterImpl(Wait wait, Action action) {
-            yield return wait;
-            action();
+            return Instance.GetActiveCoroutines();
         }
 
     }
diff --git a/Coroutine/CoroutineHandlerInstance.cs b/Coroutine/CoroutineHandlerInstance.cs
new file mode 100644
index 0000000..a55760c
--- /dev/null
+++ b/Coroutine/CoroutineHandlerInstance.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Coroutine {
+    public class CoroutineHandlerInstance {
+
+        private readonly List<ActiveCoroutine> tickingCoroutines = new List<ActiveCoroutine>();
+        private readonly List<ActiveCoroutine> eventCoroutines = new List<ActiveCoroutine>();
+
+        public ActiveCoroutine Start(IEnumerable<Wait> coroutine) {
+            return this.Start(coroutine.GetEnumerator());
+        }
+
+        public ActiveCoroutine Start(IEnumerator<Wait> coroutine) {
+            var inst = new ActiveCoroutine(coroutine);
+            if (inst.MoveNext()) {
+                if (inst.IsWaitingForEvent()) {
+                    this.eventCoroutines.Add(inst);
+                } else {
+                    this.tickingCoroutines.Add(inst);
+                }
+            }
+            return inst;
+        }
+
+        public void InvokeLater(Wait wait, Action action) {
+            this.Start(InvokeLaterImpl(wait, action));
+        }
+
+        public void Tick(double deltaSeconds) {
+            for (var i = this.tickingCoroutines.Count - 1; i >= 0; i--) {
+                var coroutine = this.tickingCoroutines[i];
+                if (coroutine.Tick(deltaSeconds)) {
+                    this.tickingCoroutines.RemoveAt(i);
+                } else if (coroutine.IsWaitingForEvent()) {
+                    this.tickingCoroutines.RemoveAt(i);
+                    this.eventCoroutines.Add(coroutine);
+                }
+            }
+        }
+
+        public void RaiseEvent(Event evt) {
+            for (var i = this.eventCoroutines.Count - 1; i >= 0; i--) {
+                var coroutine = this.eventCoroutines[i];
+                if (coroutine.OnEvent(evt)) {
+                    this.eventCoroutines.RemoveAt(i);
+                } else if (!coroutine.IsWaitingForEvent()) {
+                    this.eventCoroutines.RemoveAt(i);
+                    this.tickingCoroutines.Add(coroutine);
+                }
+            }
+        }
+
+        public IEnumerable<ActiveCoroutine> GetActiveCoroutines() {
+            return this.tickingCoroutines.Concat(this.eventCoroutines);
+        }
+
+        private static IEnumerator<Wait> InvokeLaterImpl(Wait wait, Action action) {
+            yield return wait;
+            action();
+        }
+
+    }
+}
\ No newline at end of file