2f107db...5202af9

Barotrauma/BarotraumaShared/Source/CoroutineManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace Barotrauma
 {
@@ -16,7 +17,9 @@ namespace Barotrauma
 
         public Exception Exception;
 
-        public CoroutineHandle(IEnumerator<object> coroutine, string name = "")
+        public Thread Thread;
+
+        public CoroutineHandle(IEnumerator<object> coroutine, string name = "", bool useSeparateThread = false)
         {
             Coroutine = coroutine;
             Name = string.IsNullOrWhiteSpace(name) ? coroutine.ToString() : name;
@@ -32,10 +35,24 @@ namespace Barotrauma
 
         public static float UnscaledDeltaTime, DeltaTime;
 
-        public static CoroutineHandle StartCoroutine(IEnumerable<object> func, string name = "")
+        public static CoroutineHandle StartCoroutine(IEnumerable<object> func, string name = "", bool useSeparateThread = false)
         {
             var handle = new CoroutineHandle(func.GetEnumerator(), name);
-            Coroutines.Add(handle);
+            lock (Coroutines)
+            {
+                Coroutines.Add(handle);
+            }
+
+            handle.Thread = null;
+            if (useSeparateThread)
+            {
+                handle.Thread = new Thread(() => { ExecuteCoroutineThread(handle); })
+                {
+                    Name = "Coroutine Thread (" + handle.Name + ")",
+                    IsBackground = true
+                };
+                handle.Thread.Start();
+            }
 
             return handle;
         }
@@ -79,33 +96,82 @@ namespace Barotrauma
         {
             Coroutines.RemoveAll(c => c == handle);
         }
-        private static bool IsDone(CoroutineHandle handle)
+
+        public static void ExecuteCoroutineThread(CoroutineHandle handle)
         {
-            try
+            while (true)
             {
                 if (handle.Coroutine.Current != null)
                 {
                     WaitForSeconds wfs = handle.Coroutine.Current as WaitForSeconds;
                     if (wfs != null)
                     {
-                        if (!wfs.CheckFinished(UnscaledDeltaTime)) return false;
+                        Thread.Sleep((int)(wfs.TotalTime * 1000));
                     }
                     else
                     {
                         switch ((CoroutineStatus)handle.Coroutine.Current)
                         {
                             case CoroutineStatus.Success:
-                                return true;
+                                return;
 
                             case CoroutineStatus.Failure:
                                 DebugConsole.ThrowError("Coroutine \"" + handle.Name + "\" has failed");
-                                return true;
+                                return;
                         }
                     }
                 }
 
-                handle.Coroutine.MoveNext();
-                return false;
+                Thread.Yield();
+                if (!handle.Coroutine.MoveNext()) return;
+            }
+        }
+
+        private static bool IsDone(CoroutineHandle handle)
+        {
+#if !DEBUG
+            try
+            {
+#endif
+                if (handle.Thread == null)
+                {
+                    if (handle.Coroutine.Current != null)
+                    {
+                        WaitForSeconds wfs = handle.Coroutine.Current as WaitForSeconds;
+                        if (wfs != null)
+                        {
+                            if (!wfs.CheckFinished(UnscaledDeltaTime)) return false;
+                        }
+                        else
+                        {
+                            switch ((CoroutineStatus)handle.Coroutine.Current)
+                            {
+                                case CoroutineStatus.Success:
+                                    return true;
+
+                                case CoroutineStatus.Failure:
+                                    DebugConsole.ThrowError("Coroutine \"" + handle.Name + "\" has failed");
+                                    return true;
+                            }
+                        }
+                    }
+
+                    handle.Coroutine.MoveNext();
+                    return false;
+                }
+                else
+                {
+                    if (handle.Thread.ThreadState.HasFlag(ThreadState.Stopped))
+                    {
+                        if ((CoroutineStatus)handle.Coroutine.Current == CoroutineStatus.Failure)
+                        {
+                            DebugConsole.ThrowError("Coroutine \"" + handle.Name + "\" has failed");
+                        }
+                        return true;
+                    }
+                    return false;
+                }
+#if !DEBUG
             }
             catch (Exception e)
             {
@@ -113,6 +179,7 @@ namespace Barotrauma
                 handle.Exception = e;
                 return true;
             }
+#endif
         }
         // Updating just means stepping through all the coroutines
         public static void Update(float unscaledDeltaTime, float deltaTime)
@@ -128,11 +195,14 @@ namespace Barotrauma
   
     class WaitForSeconds
     {
+        public readonly float TotalTime;
+
         float timer;
 
         public WaitForSeconds(float time)
         {
             timer = time;
+            TotalTime = time;
         }
 
         public bool CheckFinished(float deltaTime)