使用协程进行倒计时

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 actionDic = newDictionary();

public void RegisterAction(Action action, float time)

{

actionDic.Add(action,time);

}

public void ClearActions()

{

actionDic.Clear();

}

public void CallActions()

{

List theActionList= new List(actionDic.Keys);

List theTimeList = new List(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(Listlist,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);

}