• 协同程序

    协同程序

    当调用一个函数时，在它返回之前，会一直运行到完成。这意味着该函数中的任何动作都必须在一帧内完成；函数调用不能包含过程动画或一段时间内的事件序列。例如有这样一个任务，逐渐降低一个对象的 alpha（不透明度）值，直到它完全不可见。

    1. void Fade() {
    2.     for (float f = 1f; f >= 0; f -= 0.1f) {
    3.         Color c = renderer.material.color;
    4.         c.a = f;
    5.         renderer.material.color = c;
    6.     }
    7. }

    实际情况是，函数 Fade 不会实现你期望的效果。为了使渐变过程可见，alpha 必须随着桢序列降低，以渲染显示中间值。但是，该函数将在一帧内完整地执行。你将永远不会看到中间值，对象会立即消失。

    可以把代码添加到 Update 函数中，逐桢地执行淡出，来处理这种情况。不过，更方便的方式是使用协程（协同程序）执行这种任务。

    协程就像一个函数，它能够暂停执行并将控制权返回给 Unity，但是在下一桢时，可以在暂停的位置继续执行。在 C# 中，可以像这样声明协程：

    1. IEnumerator Fade() {
    2.     for (float f = 1f; f >= 0; f -= 0.1f) {
    3.         Color c = renderer.material.color;
    4.         c.a = f;
    5.         renderer.material.color = c;
    6.         yield return null;
    7.     }
    8. }

    协程本质上是一个返回类型被声明为 IEnumerator 的函数，并且在函数体的某处包含 yield return 语句。执行过程在 yield return 行暂停，并在下一桢恢复执行。要让协程运行起来，需要使用 StartCoroutine 函数：

    1. void Update() {
    2.     if (Input.GetKeyDown("f")) {
    3.         StartCoroutine("Fade");
    4.     }
    5. }

    在 UnityScript 中，事情稍微简单一些。任何含有 yield 语句的函数都被认为是一个协程，不需要显示声明返回类型 IEnumerator：

    1. function Fade() {
    2.     for (var f = 1.0; f >= 0; f -= 0.1) {
    3.         var c = renderer.material.color;
    4.         c.a = f;
    5.         renderer.material.color = c;
    6.         yield;
    7.     }
    8. }

    此外，在 UnityScript 中，可以通过直接调用协程来启动它，就像它是一个普通的函数一样：

    1. function Update() {
    2.     if (Input.GetKeyDown("f")) {
    3.         Fade();
    4.     }
    5. }

    你将会注意到，在协程的生命周期内，Fade 函数中的循环计数器一直保持正确的值。实际上，yield 之间的任何变量或属性都将正确地保留。

    默认情况下，协程在 yield 之后的桢中恢复，不过也可以使用 WaitForSeconds 延迟恢复：

    1. IEnumerator Fade() {
    2.     for (float f = 1f; f >= 0; f -= 0.1f) {
    3.         Color c = renderer.material.color;
    4.         c.a = f;
    5.         renderer.material.color = c;
    6.         yield return new WaitForSeconds(.1f);
    7.     }
    8. }

    在 UnityScript 中：

    1. function Fade() {
    2.     for (var f = 1.0; f >= 0; f -= 0.1) {
    3.         var c = renderer.material.color;
    4.         c.a = f;
    5.         renderer.material.color = c;
    6.         yield WaitForSeconds(0.1);
    7.     }
    8. }

    协程可以把某些效果分散在一段时间内，也可以有效地优化性能。游戏中的许多任务需要定期执行，最明显的方式是将它们包含在 Update 函数中执行。但是 Update 函数通常每秒调用多次。当任务不需要如此频繁地重复时，你可以把它放入协程定期更新，而不是每桢都更新。一个例子是在敌人靠近玩家时触发警告。代码看起来可能像这样：

    1. function ProximityCheck() {
    2.     for (int i = 0; i < enemies.Length; i++) {
    3.         if (Vector3.Distance(transform.position, enemies[i].transform.position) < dangerDistance) {
    4.                 return true;
    5.         }
    6.     }
    8.     return false;
    9. }

    如果有很多敌人，每桢都调用该函数可能会带来很大的开销。不过，你可以使用协程每秒调用该函数 10 次：

    1. IEnumerator DoCheck() {
    2.     for(;;) {
    3.         ProximityCheck;
    4.         yield return new WaitForSeconds(.1f);
    5.     }
    6. }

    这将大大减少执行检测的次数，而且不会对游戏性产生任何显著影响。