Unity时间相关

使用协程进行倒计时

    privatevoid Start()
    {
     StartCoroutine(TimeFunc(3));//开启协程
    }
    privateIEnumerator TimeFunc(float TimeCount)
    {
     do{
         print(TimeCount);
         yieldreturn new WaitForSecond(1);//在每帧update之后进行等待一秒
         TimeCount-= 1;
     }while(TimeCount > 0)
     print("时间到");
    }       

协程

    private void Start()
    {
        //第一种方式协程的开启与停止
        StartCoroutine("changeState01");
        StopCoroutine("changeState01");
        //第二种方式协程的开启与停止，传参的时候只能使用第二种方式进行定义
        IEnumerator ie = changeState02();
        StartCoroutine(ie);
        StopCoroutine(ie);
        //停掉所有协程
        StopAllCoroutines();
    }
        //携程定义
    IEnumerator changeState01()
    {
        yield return newWaitForSeconds(1);
        Debug.Log("可以连续写多个返回值");
        yield return null;
        Debug.Log("1");
        yield return new WaitForSeconds(1);
        Debug.Log("2");
        yield return null;
    }

• 使用 StartCoroutine(函数()); 形式开启的，只能用接收返回值的形式去停止；【不限制参数个数】

• 使用 StartCoroutine(“函数名”); 形式开启的，可以使用 StopCoroutine(“函数名”); 形式停止，也可使用接收返回值的形式去停止。【缺点：只可以传递一个参数】

• 两种开启形式均受到StopAllCoroutines() 控制。StopAllCoroutines() 可以停止当前脚本中所有协程。

• gameObject.SetActive(false); 可停掉所有此GameObject上的所有协程，且再次激活时协程不会继续。

• StopCoroutine(函数()); 脚本.enabled = false; 不可停掉协程。

清爽延时代码

功能函数代码

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ActionController :MonoBehaviour
{
   public static ActionController Instance;
   private void Awake()
    {
       Instance = this;
    }
   //延时事件流
   public static Dictionary<Action, float> actionDic = newDictionary<Action, float>();
   public void RegisterAction(Action action, float time)
    {
       actionDic.Add(action,time);
    }
   public void ClearActions()
    {
       actionDic.Clear();
    }
   public void CallActions()
    {
       List<Action> theActionList= new List<Action>(actionDic.Keys);
       List<float> theTimeList = new List<float>(actionDic.Values);
       theActionList[0]();
       for (int i = 1; i < theActionList.Count; i++)
       {
           StartCoroutine(DelayToCallEnumerator(theActionList[i], Sum(theTimeList,i - 1)));
       }
    }
   public void CallActions(bool IsClear)
    {
       CallActions();
       if (IsClear)
       {
           ClearActions();
       }
    }
   float Sum(List<float>list,int index)
    {
       float x = 0;
       for (int i = 0; i < list.Count; i++)
       {
           if (i <= index)
           {
                x += list[i];
           }
       }
       return x;
    }

   public void DelayToCall(Action action, float time)
    {
       StartCoroutine(DelayToCallEnumerator(action, time));
    }
  
   private IEnumerator DelayToCallEnumerator(Action action,float time)
    {
       yield return new WaitForSeconds(time);
       action();
    }
 
}

调用

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Diaoyong : MonoBehaviour
{
   // //第一种调用方式
   // void Start()
   // {
   //    ActionController.Instance.DelayToCall(Change,2);
   // }
   //
   // void Change()
   // {
   //    transform.localScale=Vector3.one*3;
   // }
    
   //第二种调用方式
   private void Start()
    {
       ActionController.Instance.DelayToCall(() => {transform.localScale=Vector3.one*3;transform.localPosition=Vector3.zero;},2);
    }
}

一定时间能生成一定数目的物体

    public Animator cubeAnimator;
    private int cubeCount=5;
    private int cubeNum=0;
    private void Start()
    {
        StartCoroutine("CreateCube");
    }
    IEnumerator CreateCube()
    {
        while (true)
        {
            if (cubeNum >= cubeCount)
            {
                yield break;//携程通过这种方法跳出循环
            }
           Instantiate(cubeAnimator.gameObject);//生成带有cubeAnimator的物体
            Debug.Log(cubeNum);
            cubeNum++;
           yield return new WaitForSeconds(2);
        }
    }

Invoke延时

调用

    public Animator cubeAnimator;
    private void Start()
    {
        Invoke("CreateCube01",1);//多少秒之后调用哪一个函数
       InvokeRepeating("CreateCube02",1, 2);//在1s内调用函数，然后每两秒调用一次,个人感觉不如协程好用
    }
    void CreateCube01()
    {
        Instantiate(cubeAnimator.gameObject);//生成带有cubeAnimator的物体
    }
    void CreateCube02()
    {
        Instantiate(cubeAnimator.gameObject);//生成带有cubeAnimator的物体
    }

停止使用

//Invoke延时调用  
    public GameObject cube;
    public GameObject sphere;
    private void Start()
    {
        //开启
        InvokeRepeating("CreateCube", 1, 1);
        InvokeRepeating("CreateSphere",1, 1);
        //停止使用
        CancelInvoke("CreateCube");//开始就关闭了，只执行一次
    }
 
    private void Update()
    {
        print(IsInvoking("CreateCube"));//判断CreateCube这个是否在运行
        print(IsInvoking());//只要是存在Invoke就返回true
    }
 
    void CreateCube()
    {
        Instantiate(cube);
    }
 
    void CreateSphere()
    {
        Instantiate(sphere);
    }