using UnityEngine;
using UnityEngine.Events;

public class CustomWait : CustomYieldInstruction
{
    private UnityAction m_IntervalCallback;
    private float m_StartTime;
    private float m_LastTime;
    private float m_Interval;
    private float m_Time;
    
    public CustomWait(float time, float interval, UnityAction callback)
    {
        m_StartTime = Time.time;
        m_LastTime = Time.time;
        m_Interval = interval;
        m_Time = time;
        m_IntervalCallback = callback;
    }

    //判断协成是否继续等待 false为协成结束
    public override bool keepWaiting
    {
        get
        {
            if (Time.time - m_StartTime >= m_Time)
            {
                return false;
            }
            else if (Time.time - m_LastTime >= m_Interval)
            {
                m_LastTime = Time.time;
                m_IntervalCallback();
            }
            return true;
        }
    }
}

public class TestCustomWait : MonoBehaviour {
    
    IEnumerator Start () {
        yield return new CustomWait(10f, 1f, delegate ()
        {
            Debug.LogError("自定义的协成等待");
        });
    }
}

继承CustomYieldInstruction，实现keepWaiting接口，根据具体情况返回状态。

cube t:prefab  搜索名字为cube，类型为prefab的物体

20 t:sprite  搜索名字为20，类型为sprite的物体

l:paths 搜索标签为paths的物体

在手机上，Unity的主线程好像并不能够后台运行的，但是其他线程却可以的。例如接收socket网络包的线程是正常运作的，它把包一个一个的加到队列中，当切换回来游戏的时候，主线程运作就会把一个个网络包取出然后运行起来，这些包一股脑的一下子运行起来，如果有很多个协成特别是会冲突的协成就会一股脑的运行起来，从而造成各种图形错乱逻辑错误的问题。

using System.Collections;
using System.Collections.Generic;
using System.Threading;
using UnityEngine;

public class TestBackRunning : MonoBehaviour {

    Transform go;
    //模拟网络收包
    Queue<Vector3> q = new Queue<Vector3>();

    void Awake () {
        go = GameObject.Find("Cube").transform;
        Application.runInBackground = false; //设置为后台不运行，模拟手机上的情况
        Thread t = new Thread(RunThread);
        t.Start();
    }

    void RunThread()
    {
        //在一个线程中往队列里添加网路包
        q.Enqueue( Vector3.up );
        Thread.Sleep(5000);
        q.Enqueue( Vector3.down);
        Thread.Sleep(3000);
        q.Enqueue( Vector3.left );
        Thread.Sleep(1000);
        q.Enqueue(Vector3.up);
    }

    IEnumerator Up()
    {
        Debug.LogError("运行上");
        int frame = 10;
        for (int i = 0; i < frame; i++)
        {
            transform.position = new Vector3(transform.position.x, transform.position.y + 0.1f, transform.position.z);
            yield return new WaitForEndOfFrame();
        }
    }

    IEnumerator Down()
    {
        Debug.LogError("运行下");
        int frame = 20;
        for (int i = 0; i < frame; i++)
        {
            transform.position = new Vector3(transform.position.x, transform.position.y - 0.1f, transform.position.z);
            yield return new WaitForEndOfFrame();
        }
    }

    IEnumerator Left()
    {
        Debug.LogError("运行左");
        int frame = 10;
        for (int i = 0; i < frame; i++)
        {
            transform.position = new Vector3(transform.position.x + 0.1f, transform.position.y, transform.position.z);
            yield return new WaitForEndOfFrame();
        }
    }

    private void Update()
    {
        while (q.Count > 0)
        {
            Vector3 dir = q.Dequeue();
            if (dir == Vector3.up)
            {
                StartCoroutine(Up());
            }
            else if (dir == Vector3.down)
            {
                StartCoroutine(Down());
            }
            else if (dir == Vector3.left)
            {
                StartCoroutine(Left());
            }
        }
    }
}

在这个测试脚本中，使用一个线程往一个队列里面添加一些命令，然后在Update(主线程中)去取出包来执行，每一个命令都会运行一个协成并且是操作的同一个对象。运行游戏，然后切换到其他窗口，等几秒钟回来之后就会一下子调用三个协成，物体就会往左上方向走，这其实就是已经错乱了，本意是一个协成接一个协成运行的，现在一下子全部运行起来就不行了。

我所想到的方法就是，在后台运行时所需要执行的协成都不执行，都直接运行到协成的结束状态。回来的时候才允许调用协成动画（注意要延迟一帧设置这个允许状态，因为在回来那一帧中，所有的协成（后台运行时需要执行的）都是不允许调用的，一股脑太多的异步会造成混乱，所有都是直接到目标状态的话就变成一个队列的线性执行了，这样就不会造成混乱了）。当然，这样子做的话会造成时间上的不对应，但是也比回来时逻辑错乱的强得多。

private void OnApplicationPause(bool pause)
{
    if (pause)
    {
        isShowCoroutine = false;
        //将当前播放的协成到最终状态，并停止协成的运作
        switch (currentCorState)
        {
            case CoroutineState.Start:
                EndStartCoroutine();
                break;
            case CoroutineState.HSZ_CHANGE:
                EndHSZChangCoroutine();
                break;
        }
    }
    else
    {
        //可能是暂停了，回来的时候就继续执行，所以延迟设为true
        StartCoroutine(EnableShowCoroutine());
    }
}

//恢复可以播放动画了
IEnumerator EnableShowCoroutine()
{
    yield return null;//一帧之后在将允许播放协成切换回来
    isShowCoroutine = true;
    ChangeCoroutineState( CoroutineState.OTHER );
}

if (isShowCoroutine)//允许播放协成的情况下
{
    StartCoroutine(GiveCardAni(MyCardCount, cbSiceFirst, cbSiceSecond));
    ChangeCoroutineState(CoroutineState.Start);
}
else
{
    //不然直接设置到目标
    EndStartCoroutine(false);
}

有些情况我们需要使用自定义的宏来做一些东西的开关，例如测试AssetBundle的加载等

private void Awake()
{
    #if TEST_HONG  //如果定义了这个宏，就会调用
            Debug.LogError("hahaha");
    #endif
}

定义这个宏，打开File/Build Settings/PlayerSettings/Other Settings/Scripting Define Symbols下的输入框输入宏，用;好区分多个控，按回车键确定，注意你要在哪个平台定义

有时候，我们需要public一个二维数组来赋值，就例如很多类型的声音，每种类型又有很多的子声音，这时候就需要二维数组来解决了，可是public的二维数组并不会显示在Inspector中，就不能拖拉式的赋值了。剩下就只能Resource了，或则远程了。

其实我们可以用一个类来充当数据结构，然后声明为可序列化的，里面的数据为数组，而在客户端中声明这个数据结构类为数组，这样就完美解决了。

[Serializable]
public class MajiangSAudio {
    public AudioClip[] audios;
    public AudioClip[] localAudios;
}

//使用
public MajiangSAudio[] _ManSound = new MajiangSAudio[40];