Unity：对MonoBehavior进行简单的扩展

1、延迟 x 秒后调用

    /// <summary>
    /// 延迟（秒）
    /// </summary>
    public static Coroutine SetTimeOut(this MonoBehaviour mono, 
        float sec, 
        UnityAction callback)
    {
        return mono.StartCoroutine(SetTimeOut(callback, sec));
    }


    private static IEnumerator SetTimeOut(UnityAction callback, float sec)
    {
        yield return new WaitForSeconds(sec);
        callback?.Invoke();
    }

2. 每隔 x 秒调用一次

    /// <summary>
    /// 每隔一定时间调用一次
    /// </summary>
    public static Coroutine SetInterval(this MonoBehaviour mono, 
        UnityAction action, 
        float timeInterval)
    {
        return mono.StartCoroutine(SetInterval(action, timeInterval));
    }

    private static IEnumerator SetInterval(UnityAction action, float timeInterval)
    {
        while (true)
        {
            yield return new WaitForSeconds(timeInterval);
            action?.Invoke();
        }
    }

3.等待 条件达成 再调用

    /// <summary>
    /// 等待直到func()==true
    /// </summary>
    public static Coroutine WaitUtil(this MonoBehaviour mono, 
        Func<bool> func, 
        UnityAction callback, 
        float timeInterval = 0.1f)
    {
        return mono.StartCoroutine(WaitUtil(func, callback, timeInterval));
    }

    private static IEnumerator WaitUtil(Func<bool> func, 
        UnityAction callback, 
        float timeInterval)
    {
        do
        {
            yield return new WaitForSeconds(timeInterval);
        } while (!func());

        callback?.Invoke();
    }

4. Promise方式

    /// <summary>
    /// 延迟（秒）
    /// </summary>
    public static IPromise SetTimeOutPromise(this MonoBehaviour mono, float sec)
    {
        Promise p = new();
        mono.StartCoroutine(SetTimeOutPromise(sec, p));
        return p;
    }

    private static IEnumerator SetTimeOutPromise(float sec, Promise p)
    {
        yield return new WaitForSeconds(sec);
        if (p.CurState == PromiseState.Pending)
            p.Resolve();
    }

    
    /// <summary>
    /// 等待直到func()==true
    /// </summary>
    public static IPromise WaitUtilPromise(this MonoBehaviour mono, 
        Func<bool> func, float timeInterval = 0.1f)
    {
        Promise p = new();
        mono.StartCoroutine(WaitUtilPromise(func, timeInterval, p));
        return p;
    }

    private static IEnumerator WaitUtilPromise(Func<bool> func, 
        float timeInterval, Promise p)
    {
        do
        {
            yield return new WaitForSeconds(timeInterval);
        } while (!func());

        if (p.CurState == PromiseState.Pending)
            p.Resolve();
    }