internal Coroutine(Processor proc)
{
Type = CoroutineType.Coroutine;
m_Processor = proc;
m_Processor.AssociatedCoroutine = this;
OwnerScript = proc.GetScript();
}
internal void MarkClrCallbackAsDead()
{
if (Type != CoroutineType.ClrCallback)
{
throw new InvalidOperationException("State must be CoroutineType.ClrCallback");
}
Type = CoroutineType.ClrCallbackDead;
}
public ReCoroutine(IEnumerator <float> e, CoroutineType type)
{
this.e = e;
this.coroutineType = type;
this.currentTime = 0;
this.untilTime = 0;
this.isDone = false;
this.id = currentId++;
}
private ReCoroutine _AddCoroutine(IEnumerator <float> e, CoroutineType type = CoroutineType.Update)
{
var cor = new ReCoroutine(e, type);
if (type == CoroutineType.Update)
{
updateIEnumeratorList.Add(cor);
}
else if (type == CoroutineType.LateUpdate)
{
lateUpdateIEnumeratorList.Add(cor);
}
else if (type == CoroutineType.FixedUpdate)
{
fixedUpdateIEnumeratorList.Add(cor);
}
return(cor);
}
/// <summary>
/// 获得等待类型
/// </summary>
/// <param name="coroutineType"></param>
/// <param name="time"></param>
/// <returns></returns>
public static IEnumerator GetIEnumerator(CoroutineType coroutineType, float time)
{
switch (coroutineType)
{
case CoroutineType.WaitForEndOfFrame:
yield return(WaitForEndOfFrame);
break;
case CoroutineType.WaitForFixedUpdate:
yield return(WaitForFixedUpdate);
break;
case CoroutineType.WaitForSeconds:
yield return(new WaitForSeconds(time));
break;
case CoroutineType.WaitFrame:
if (time == 0)
{
time = 1;
}
for (float i = time; i > 0; i--)
{
yield return(null);
}
break;
case CoroutineType.WaitNull:
break;
default:
break;
}
}
/// <summary>
/// 添加新协程
/// </summary>
/// <param name="e"></param>
/// <param name="type"></param>
/// <returns></returns>
public static ReCoroutine AddCoroutine(IEnumerator <float> e, CoroutineType type = CoroutineType.Update)
{
return(Instance._AddCoroutine(e, type));
}
internal Coroutine(CallbackFunction function)
{
Type = CoroutineType.ClrCallback;
m_ClrCallback = function;
OwnerScript = null;
}
IEnumerator Coroutine(Func <bool> condition, Action action, Action cleanup, float deltaTime, CoroutineType type)
{
while (condition())
{
action();
if (type == CoroutineType.REAL_TIME)
{
yield return(new WaitForSecondsRealtime(deltaTime));
}
else if (type == CoroutineType.SCALED_TIME)
{
yield return(new WaitForSeconds(deltaTime));
}
}
cleanup();
}
internal Coroutine(Processor proc)
{
Type = CoroutineType.Coroutine;
m_Processor = proc;
m_Processor.AssociatedCoroutine = this;
}
internal Coroutine(CallbackFunction function)
{
Type = CoroutineType.ClrCallback;
m_ClrCallback = function;
}
private IEnumerator StartCoroutineFunction(CoroutineType coroutineType, float time, Action callback)
{
yield return(GetIEnumerator(coroutineType, time));
callback();
}
/// <summary>
/// 开启单个协程
/// </summary>
/// <param name="coroutineType"></param>
/// <param name="time"></param>
/// <param name="callback"></param>
public static void StartSingleCoroutine(CoroutineType coroutineType, float time, Action callback)
{
Instance.StartCoroutine(Instance.StartCoroutineFunction(coroutineType, time, callback));
}
public SingleCoroutine(CoroutineType coroutineType, float time, Action action)
{
this.action = action;
this.daly = GameTimer.GetIEnumerator(coroutineType, time);
}
internal DynValue Recycle(Processor mainProcessor, Closure closure)
{
Type = CoroutineType.Recycled;
return(m_Processor.Coroutine_Recycle(mainProcessor, closure));
}
