示例#1
0
    private void LateUpdate()
    {
        for (int i = 0; i < activeTimeInvokes.Count; i++)
        {
            TimeInvoke timeInvoke = activeTimeInvokes[i];

            if (timeInvoke.CanInvoke())
            {
                activeTimeInvokes.RemoveAt(i);
                timeInvokePool.Add(timeInvoke);

                timeInvoke.enumerator.MoveNext();
            }
            else
            {
                break;
            }
        }

        for (int i = 0; i < activeUnscaledTimeInvokes.Count; i++)
        {
            TimeInvoke unscaledTimeInvoke = activeUnscaledTimeInvokes[i];

            if (Time.unscaledTime >= unscaledTimeInvoke.endTime)
            {
                activeUnscaledTimeInvokes.RemoveAt(i);
                unscaledTimeInvokePool.Add(unscaledTimeInvoke);

                unscaledTimeInvoke.enumerator.MoveNext();
            }
            else
            {
                break;
            }
        }

        for (int i = 0; i < activeFrameInvokes.Count; i++)
        {
            FrameInvoke frameInvoke = activeFrameInvokes[i];

            if (frameInvoke.CanInvoke())
            {
                activeFrameInvokes.RemoveAt(i);
                frameInvokePool.Add(frameInvoke);

                frameInvoke.enumerator.MoveNext();
            }
            else
            {
                break;
            }
        }

        if (activeTimeInvokes.Count == 0 &&
            activeFrameInvokes.Count == 0 &&
            activeUnscaledTimeInvokes.Count == 0)
        {
            enabled = false;
        }
    }
示例#2
0
    private static void CancelMethod(MethodInfo method, object target)
    {
        if (Instance == null || isQuitting)
        {
            return;
        }

        for (int i = 0; i < Instance.activeTimeInvokes.Count; i++)
        {
            TimeInvoke timeInvoke = Instance.activeTimeInvokes[i];

            if (timeInvoke.methodInfo == method &&
                timeInvoke.target == target)
            {
                Instance.activeTimeInvokes.RemoveAt(i--);
                Instance.timeInvokePool.Add(timeInvoke);
                // Not breaking so we get every matching method
            }
        }

        for (int i = 0; i < Instance.activeUnscaledTimeInvokes.Count; i++)
        {
            TimeInvoke unscaledTimeInvoke = Instance.activeUnscaledTimeInvokes[i];

            if (unscaledTimeInvoke.methodInfo == method &&
                unscaledTimeInvoke.target == target)
            {
                Instance.activeUnscaledTimeInvokes.RemoveAt(i--);
                Instance.unscaledTimeInvokePool.Add(unscaledTimeInvoke);
                // Not breaking so we get every matching method
            }
        }

        for (int i = 0; i < Instance.activeFrameInvokes.Count; i++)
        {
            FrameInvoke frameInvoke = Instance.activeFrameInvokes[i];

            if (frameInvoke.methodInfo == method &&
                frameInvoke.target == target)
            {
                Instance.activeFrameInvokes.RemoveAt(i--);
                Instance.frameInvokePool.Add(frameInvoke);
                // Not breaking so we get every matching method
            }
        }
    }
示例#3
0
    static void AddInvokeWithFrame(MethodInfo methodInfo, object target, IEnumerator enumerator, int endFrame)
    {
        if (Instance == null || isQuitting)
        {
            return;
        }

        if (Instance.frameInvokePool.Count == 0)
        {
            Debug.LogError("TimeManager's FrameInvokePool is empty. Something is very wrong", Instance);
            return;
        }

        Instance.enabled = true;

        FrameInvoke frameInvoke = Instance.frameInvokePool[0];

        frameInvoke.endFrame   = endFrame;
        frameInvoke.enumerator = enumerator;
        frameInvoke.methodInfo = methodInfo;
        frameInvoke.target     = target;

#if UNITY_EDITOR
        frameInvoke.name = methodInfo.Name;
#endif

        Instance.frameInvokePool.RemoveAt(0);

        for (int i = 0; i < Instance.activeFrameInvokes.Count; i++)
        {
            FrameInvoke compareFrameInvoke = Instance.activeFrameInvokes[i];
            if (endFrame < compareFrameInvoke.endFrame)
            {
                Instance.activeFrameInvokes.Insert(i, frameInvoke);
                return;
            }
        }

        Instance.activeFrameInvokes.Add(frameInvoke);
    }