void GoStartCoroutine(PausableCoroutine coroutine)
        {
            if (!coroutine_dict.ContainsKey(coroutine.routine_unique_hash))
            {
                List <PausableCoroutine> new_coroutine_list = new List <PausableCoroutine>();
                coroutine_dict.Add(coroutine.routine_unique_hash, new_coroutine_list);
            }

            coroutine_dict[coroutine.routine_unique_hash].Add(coroutine);

            if (!coroutine_owner_dict.ContainsKey(coroutine.owner_unique_hash))
            {
                Dictionary <string, PausableCoroutine> new_coroutine_dict = new Dictionary <string, PausableCoroutine>();
                coroutine_owner_dict.Add(coroutine.owner_unique_hash, new_coroutine_dict);
            }

            // If the method from the same owner has been stored before, it doesn't have to be stored anymore,
            // One reference is enough in order for "StopAllCoroutines" to work
            if (!coroutine_owner_dict[coroutine.owner_unique_hash].ContainsKey(coroutine.routine_unique_hash))
            {
                coroutine_owner_dict[coroutine.owner_unique_hash].Add(coroutine.routine_unique_hash, coroutine);
            }

            MoveNext(coroutine);
        }
Example #2
0
        public static PausableCoroutine StartPausableCoroutine(MonoBehaviour monoBehaviour,
                                                               IEnumerator toStartEnumerator)
        {
            PausableCoroutine result =
                PausableCoroutineManager.instance.StartCoroutine(toStartEnumerator, monoBehaviour);

            return(result);
        }
        bool MoveNext(PausableCoroutine coroutine)
        {
            if (coroutine.routine.MoveNext())
            {
                return(Process(coroutine));
            }

            return(false);
        }
 void GoStopActualRoutine(PausableCoroutine routine)
 {
     if (!coroutine_dict.ContainsKey(routine.routine_unique_hash))
     {
         return;
     }
     coroutine_owner_dict[routine.owner_unique_hash].Remove(routine.routine_unique_hash);
     coroutine_dict.Remove(routine.routine_unique_hash);
 }
Example #5
0
        public static PausableCoroutine StopAndStartCachePausableCoroutine(MonoBehaviour monoBehaviour,
                                                                           string enumeratorName,
                                                                           IEnumerator toStartEnumerator)
        {
            Dictionary <string, PausableCoroutine> pausableCoroutineDict = monoBehaviour.GetCachePausableCoroutineDict();
            PausableCoroutine saveEnumerator =
                pausableCoroutineDict.GetOrAddDefault2 <PausableCoroutine>(enumeratorName);

            pausableCoroutineDict[enumeratorName] =
                monoBehaviour.StopAndStartPausableCoroutine(ref saveEnumerator, toStartEnumerator);
            return(pausableCoroutineDict[enumeratorName]);
        }
        PausableCoroutine GoStartCoroutine(IEnumerator routine, object this_reference)
        {
            if (routine == null)
            {
                Debug.LogException(new Exception("IEnumerator is null!"), null);
            }

            PausableCoroutine coroutine = CreateCoroutine(routine, this_reference);

            GoStartCoroutine(coroutine);
            return(coroutine);
        }
Example #7
0
        public static PausableCoroutine StopAndStartPausableCoroutine(MonoBehaviour monoBehaviour,
                                                                      ref PausableCoroutine saveEnumerator, IEnumerator toStartEnumerator)
        {
            if (saveEnumerator != null)
            {
                PausableCoroutineManager.instance.StopCoroutine(saveEnumerator.routine, monoBehaviour);
            }
            PausableCoroutine result =
                PausableCoroutineManager.instance.StartCoroutine(toStartEnumerator, monoBehaviour);

            saveEnumerator = result;
            return(result);
        }
        void GoStopAllCoroutines(object this_reference)
        {
            PausableCoroutine coroutine = CreateCoroutine(null, this_reference);

            if (!coroutine_owner_dict.ContainsKey(coroutine.owner_unique_hash))
            {
                return;
            }
            foreach (var couple in coroutine_owner_dict[coroutine.owner_unique_hash])
            {
                coroutine_dict.Remove(couple.Value.routine_unique_hash);
            }

            coroutine_owner_dict.Remove(coroutine.owner_unique_hash);
        }
        // returns false if no next, returns true if OK
        bool Process(PausableCoroutine coroutine)
        {
            object current = coroutine.routine.Current;

            if (current == null)
            {
                coroutine.current_yield = new YieldDefault();
            }
            else if (current is WaitForSeconds)
            {
                coroutine.current_yield = new YieldWaitForSeconds(current.GetFieldValue <float>("m_Seconds"));
            }
            else if (current is CustomYieldInstruction customYield)
            {
                coroutine.current_yield = new YieldCustomYieldInstruction(customYield);
            }
            else if (current is WWW)
            {
                coroutine.current_yield = new YieldWWW((WWW)current);
            }
            else if (current is WaitForFixedUpdate || current is WaitForEndOfFrame)
            {
                coroutine.current_yield = new YieldDefault();
            }
            else if (current is AsyncOperation asyncOperation)
            {
                coroutine.current_yield = new YieldAsync(asyncOperation);
            }
            else if (current is PausableCoroutine co)
            {
                coroutine.current_yield = new YieldNestedCoroutine(co);
            }
            else
            {
                Debug.LogException(
                    new Exception("<" + coroutine.method_name + "> yielded an unknown or unsupported type! (" +
                                  current.GetType() +
                                  ")"),
                    null);
                coroutine.current_yield = new YieldDefault();
            }

            return(true);
        }
Example #10
0
 public static PausableCoroutine StopAndStartPausableCoroutine(this MonoBehaviour self,
                                                               ref PausableCoroutine saveCo, IEnumerator toStartIE)
 {
     return(MonoBehaviourUtil.StopAndStartPausableCoroutine(self, ref saveCo, toStartIE));
 }
Example #11
0
        void Update()
        {
            //      LogCat.log("ggggg");
            float deltaTime = Time.deltaTime;

#if UNITY_EDITOR
            if (!EditorApplication.isPlayingOrWillChangePlaymode)
            {
                deltaTime = Time.realtimeSinceStartup - previousTimeSinceStartup;
                previousTimeSinceStartup = Time.realtimeSinceStartup;
            }
#endif
            if (this.is_paused)
            {
                return;
            }
            if (deltaTime == 0f)
            {
                return;
            }
            if (coroutine_dict.Count == 0)
            {
                return;
            }

            temp_coroutine_list.Clear();
            foreach (var pair in coroutine_dict)
            {
                temp_coroutine_list.Add(pair.Value);
            }

            for (var i = temp_coroutine_list.Count - 1; i >= 0; i--)
            {
                List <PausableCoroutine> coroutines = temp_coroutine_list[i];

                for (int j = coroutines.Count - 1; j >= 0; j--)
                {
                    PausableCoroutine coroutine = coroutines[j];

                    if (coroutine.is_paused)
                    {
                        continue;
                    }

                    if (!coroutine.current_yield.IsDone(deltaTime))
                    {
                        continue;
                    }

                    if (!MoveNext(coroutine))
                    {
                        coroutines.RemoveAt(j);
                        coroutine.current_yield = null;
                        coroutine.isFinished    = true;
                    }

                    if (coroutines.Count == 0)
                    {
                        coroutine_dict.Remove(coroutine.owner_unique_hash);
                    }
                }
            }
        }