internal void _HandleException(CoroutineException e)
{
if (_pCurrentInstruction != null)
{
_pCurrentInstruction.Stop();
_pCurrentInstruction.DecRef();
_pCurrentInstruction = null;
}
_pCoroutineFunc = null;
_state = CoroutineState.Stopped;
if (_onException != null)
{
_onException(this, e);
}
else
{
if (_Parent != null)
{
/// 'Throw up' to parent
_Parent._HandleException(e);
}
else
{
CoroutineMgr._ThrowException(e);
}
}
if (_onStopped != null)
{
_onStopped(this);
_Parent = null;
}
}
private IEnumerator <IYieldInstruction> MockCoroutineOptionalYield(IYieldInstruction yieldInstruction, Func <bool> onStep)
{
while (onStep())
{
yield return(yieldInstruction);
}
}
public bool MoveNext()
{
bool move = asyncInstruction.MoveNext();
yieldInstruction = asyncInstruction.Current == null ? NotWait.notWait : asyncInstruction.Current;
return(move);
}
private IEnumerator <IYieldInstruction> MockCoroutine(IYieldInstruction yieldInstruction, Hangout.Shared.Action onStep)
{
while (true)
{
yield return(yieldInstruction);
onStep();
}
}
public static IEnumerator RepeatFor(float time, Action <float> method, IYieldInstruction yieldInstruction)
{
var current = 0.0f;
while (current < time)
{
yield return(yieldInstruction.Wait());
current += yieldInstruction.Increment();
method(Mathf.Clamp01(current / time));
}
method(1.0f);
}
///--------
private void __doComplete(object returnValue = null)
{
_pCoroutineFunc = null;
if (_pCurrentInstruction != null)
{
_pCurrentInstruction.DecRef();
_pCurrentInstruction = null;
}
if (_onComplete != null)
{
_onComplete(this, returnValue);
}
_doStop();
}
override public void Stop()
{
Debugger.Assert(GetRef() != 0);
Debugger.ConditionalAssert(_bPooled
, !_AutoKill, "You can call pause/resume/stop a pooled coroutine only when AutoKill is false.");
if (_state == CoroutineState.Stopped)
{
return;
}
__bIsManualStopped = true;
_pCoroutineFunc = null;
if (_pCurrentInstruction != null)
{
_pCurrentInstruction.Stop();
_pCurrentInstruction.DecRef();
_pCurrentInstruction = null;
}
_doStop();
}
override public bool IsDone()
{
bool bIsDone = false;
if (_type == _WaitType.All)
{
bIsDone = true;
foreach (var instruction in _arrInstructions)
{
if (!instruction.IsDone())
{
bIsDone = false;
break;
}
}
}
else if (_type == _WaitType.OneOf)
{
foreach (var instruction in _arrInstructions)
{
if (instruction.IsDone())
{
_firstDoneInstruction = instruction;
bIsDone = true;
break;
}
}
}
else if (_type == _WaitType.NumOf)
{
if (_doneInstructions.Count != 0)
{
return(true);
}
else
{
Debugger.Assert(_doneInstructions.Count <= _arrInstructions.Length);
int nNum = 0;
foreach (var instruction in _arrInstructions)
{
if (instruction.IsDone())
{
nNum++;
if (nNum == _number)
{
bIsDone = true;
break;
}
}
}
if (bIsDone)
{
foreach (var instruction in _arrInstructions)
{
if (instruction.IsDone())
{
_doneInstructions.Add(instruction);
}
}
}
}
}
return(bIsDone);
}
private void Yield(IYieldInstruction instruction)
{
State = CoroutineState.Continue;
instruction.Yield(this, YieldReturn);
}
public static IEnumerator DoAfter(Action method, IYieldInstruction yieldInstruction)
{
yield return(yieldInstruction.Wait());
method();
}
private void Yield(IYieldInstruction instruction)
{
State = CoroutineState.Continue;
instruction.Yield(this, YieldReturn);
}
/// Return value indicate whether this coroutine is dead.
internal bool _Update(float fTime)
{
bool bIsDead = false;
try
{
if (_onUpdate != null && state == CoroutineState.Running)
{
_onUpdate(_pCurrentInstruction);
}
}
catch (Exception e)
{
_HandleException(new CoroutineException(e, this));
bIsDead = true;
}
bool bIsComplete = false;
if (_state < CoroutineState.Running)
{
if (_state == CoroutineState.Paused)
{
return(false);
}
else if (_state == CoroutineState.Stopped)
{
bIsComplete = true;
}
else if (_state == CoroutineState.Disposed)
{
/// Occurred when a manual coroutine is Removed.
return(true);
}
else
{
Debugger.Assert(false);
}
}
try
{
_pCoroutineMgr._CoEnterLogStack.Push(this);
if (bIsComplete)
{
if (!__bIsManualStopped)
{
__doComplete();
}
return(true);
}
///-------------------
bIsDead = false;
Debugger.Assert(_pCurrentInstruction != null);
Debugger.DebugSection(() =>
{
if (_pCurrentInstruction.GetInstructionType() == YieldInstructionType.Coroutine)
{
var coroutine = _pCurrentInstruction as Coroutine;
Debugger.ConditionalAssert(coroutine._bPooled, coroutine.state != CoroutineState.Freed);
}
});
if (_pCurrentInstruction.GetInstructionType() == YieldInstructionType.ReturnValue)
{
bIsDead = true;
_ReturnValue pReturnValue = _pCurrentInstruction as _ReturnValue;
__doComplete(pReturnValue.returnValue);
}
else
{
_pCurrentInstruction.Update(fTime);
if (_pCurrentInstruction.IsDone())
{
if (_onYieldDone != null)
{
_onYieldDone(_pCurrentInstruction);
}
if (state != CoroutineState.Stopped)
{
Debugger.Assert(_pCurrentInstruction != null);
_pCurrentInstruction.Stop();
if (!_pCoroutineFunc.MoveNext())
{
_pCurrentInstruction.DecRef();
_pCurrentInstruction = null;
bIsDead = true;
__doComplete();
}
else
{
if (_state != CoroutineState.Stopped)
{
Debugger.Assert(_state != CoroutineState.Freed && _state != CoroutineState.Disposed);
Debugger.Assert(_pCoroutineFunc != null, "Coroutine function is null but still in update, you may be operated on a dead coroutine!!!");
/// Why defRef here? Because MoveNext() may cause current instruction
_pCurrentInstruction.DecRef();
_pCurrentInstruction = _pCoroutineFunc.Current as IYieldInstruction;
if (_pCurrentInstruction == null)
{
throw new UnsupportedYieldInstruction();
}
_pCurrentInstruction.Start(fTime);
_pCurrentInstruction.IncRef();
}
}
}
}
}
}
catch (Exception e)
{
Debugger.Assert(!(e is CoroutineException));
_HandleException(new CoroutineException(e, this));
bIsDead = true;
}
finally
{
Debugger.Assert(_pCoroutineMgr._CoEnterLogStack.Peek() == this);
_pCoroutineMgr._CoEnterLogStack.Pop();
}
return(bIsDead);
}
internal void _Start(IEnumerator pCoroutineFunc)
{
Debugger.Assert(GetRef() != 0);
_Parent = _pCoroutineMgr.Current();
if (_Parent != null)
{
_Parent._DoChildCoStart(this);
}
Debugger.Assert(_state != CoroutineState.Disposed);
if (_state == CoroutineState.Running || _state == CoroutineState.Paused)
{
Stop();
}
try
{
_pCoroutineMgr._CoEnterLogStack.Push(this);
if (!_bInQueue)
{
CoroutineMgr._Instance._AddToQueue(this);
}
_pCoroutineFunc = pCoroutineFunc;
if (_onStart != null)
{
_onStart(this);
}
_state = CoroutineState.Running;
if (_pCoroutineFunc.MoveNext())
{
/// 如果子Coroutine的第一行代码抛出异常，_state会被设置为Stopped
if (_state != CoroutineState.Stopped)
{
Debugger.Assert(_state != CoroutineState.Disposed && _state != CoroutineState.Freed);
_pCurrentInstruction = _pCoroutineFunc.Current as IYieldInstruction;
if (_pCurrentInstruction == null)
{
throw new UnsupportedYieldInstruction();
}
_pCurrentInstruction.Start(scalable ? _pCoroutineMgr._Time : _pCoroutineMgr._RealTime);
_pCurrentInstruction.IncRef();
}
}
else
{
/// When coroutine has the 'yield break' at first line, will reach here.
/// The onStop will be called at next _Update.
_state = CoroutineState.Stopped;
}
}
catch (Exception e)
{
if (e is CoroutineException)
{
_HandleException(e as CoroutineException);
}
else
{
_HandleException(new CoroutineException(e, this));
}
}
finally
{
Debugger.Assert(_pCoroutineMgr._CoEnterLogStack.Peek() == this);
_pCoroutineMgr._CoEnterLogStack.Pop();
}
}