新学到的过程函数思路

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
//using IMIForUnity;

public delegate void function_f(float a);
public delegate void function();
//public delegate void function_ImiSkeleton(ImiSkeleton[] sk);

public class FunctionDelegate : MonoBehaviour
{
    public static FunctionDelegate Instance;
    public function Function;
    //public function_ImiSkeleton SkFunction;
    //public bool IsGetImiSkeleton = false;
    //public List<SkeletonFunction> SkFunctionList;

    void Awake()
    {
        Instance = this;
        //SkFunctionList = new List<SkeletonFunction>();
    }

    void Update()
    {
        if (Function != null) 
            Function();
    }
}


public class ProcessFunction
{
    int i;
    float m_start;
    float m_end;
    float m_current;
    float m_speed;
    function m_funcEnd;
    function m_keep;
    function m_funcDur;
    function_f m_funcf;
    float m_delayTime;

    /// <summary>
    /// 持续执行Update函数
    /// </summary>
    /// <param name="func"></param>
    public ProcessFunction(function func)
    {
        m_keep = func;
        //Debug.Log("开启检测");
        FunctionDelegate.Instance.Function += KeepUpdate; 
    }

    void KeepUpdate()
    {
        m_keep();
    }

    public void StopKeepUpdate()
    {
        //Debug.Log("关闭检测");
        FunctionDelegate.Instance.Function -= KeepUpdate;
    }

    /// <summary>
    /// 浮点型函数-过程函数
    /// </summary>
    /// <param name="delaytime"></param>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <param name="time"></param>
    /// <param name="funcf"></param>
    /// <param name="funcEnd"></param>
    public ProcessFunction(float delaytime, float start, float end, float time, function_f funcf, function funcEnd)
    {
        m_delayTime = delaytime;
        m_start = start;
        m_current = start;
        m_end = end;
        m_funcEnd = funcEnd;
        m_funcf = funcf;
        m_speed = (end - start) / time;
        FunctionDelegate.Instance.Function += AddUpdatef;
    }


    void AddUpdatef()
    {
        if (m_delayTime > 0)
        {
            m_delayTime -= Time.deltaTime;
        }
        else
        {
            m_delayTime = 0;
            m_current += m_speed * Time.deltaTime;
            if ((m_current - m_start) * (m_current - m_end) > 0)
            {
                m_current = m_end;
                m_funcf(m_current);
                FunctionDelegate.Instance.Function -= AddUpdatef;
                if (m_funcEnd != null)
                {
                    m_funcEnd();
                }
            }
            else
            {
                m_funcf(m_current);
            }
        }
    }


    /// <summary>
    /// 无传值-过程函数
    /// </summary>
    /// <param name="delaytime"></param>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <param name="time"></param>
    /// <param name="funcDur"></param>
    /// <param name="funcEnd"></param>
    public ProcessFunction(float delaytime, float start, float end, float time, function funcDur, function funcEnd)
    {
        m_delayTime = delaytime;
        m_start = start;
        m_current = start;
        m_end = end;
        m_funcDur = funcDur;
        m_funcEnd = funcEnd;
        m_speed = (end - start) / time;
        FunctionDelegate.Instance.Function += AddUpdate;
    }


    void AddUpdate()
    {
        if (m_delayTime > 0)
        {
            m_delayTime -= Time.deltaTime;
        }
        else
        {
            m_delayTime = 0;
            m_current += m_speed * Time.deltaTime;
            if ((m_current - m_start) * (m_current - m_end) > 0)
            {
                m_current = m_end;
                m_funcDur();
                FunctionDelegate.Instance.Function -= AddUpdate;
                if (m_funcEnd != null)
                {
                    m_funcEnd();
                }
            }
            else
            {
                m_funcDur();
            }
        }
    }


    /// <summary>
    /// 前后两回，执行单次，无传值-过程函数  直接执行funcOnce，到time执行funcEnd
    /// </summary>
    /// <param name="delaytime">延迟执行函数1的时间，delaytime小于-0.1则立即开始</param>
    /// <param name="time">函数1结束（time）时间后执行函数2,time=0,立即开始执行函数2</param>
    /// <param name="funcOnce">函数1</param>
    /// <param name="funcEnd">函数2</param>
    public ProcessFunction(float delaytime, float time, function funcOnce, function funcEnd)
    {
        m_delayTime = delaytime;
        m_funcDur = funcOnce;
        m_speed = time;
        m_funcEnd = funcEnd;
        FunctionDelegate.Instance.Function += AddOnceUpdate;
    }
    void AddOnceUpdate()
    {
        if (m_delayTime > 0)
        {
            m_delayTime -= Time.deltaTime;
        }
        else if (m_delayTime == 0)
        {
            m_speed -= Time.deltaTime;
            if (m_speed <= 0)
            {
                if (m_funcEnd != null)
                {
                    m_funcEnd();
                }
                m_delayTime = -0.05f;
                FunctionDelegate.Instance.Function -= AddOnceUpdate;
            }
        }
        else if (m_delayTime < 0)
        {
            m_delayTime = 0;
            m_funcDur();
        }
    }


    public void StopUpdatef()
    {
        FunctionDelegate.Instance.Function -= AddUpdatef;
    }

    public void StopUpdate()
    {
        FunctionDelegate.Instance.Function -= AddUpdate;
    }
}

对于一些动画效果，或者需要延时的方法都很有用。