public void RunningACoroutineFromEverywhereShouldPropagateExceptions()
{
var coroutine = new ExeCoRoutine();
coroutine.Enumerable = ExecuteAndThrowAfterInitialization().GetEnumerator();
var target = new CoroutinesManager();
target.TestInitialize();
RunnerFactory.Initialize(() => target);
target.Start();
var parent = Task.Run(() =>
{
var task = CoroutineResult.WaitForCoroutine(coroutine);
task.Wait();
});
Exception expected = null;
try
{
parent.Wait();
}
catch (Exception ex)
{
expected = ex;
}
target.Stop();
Assert.IsNotNull(expected);
}
/// <summary>
/// 从 ali 云 获取热更新版本号
/// </summary>
/// <param name="onComplete"></param>
public static void GetVersionUpdateControl(System.Action <int> onComplete)
{
MonoBehaviour mono = null;
CoroutineResult result = new CoroutineResult();
IEnumerator enumerator = result.WWWReConnect(Constants.UpdateVersionControlUrl, () =>
{
int InstantUpdate_UpdateVersionControlCode = 0;
if (result._wwwResult != null && result._wwwResult.error == null)
{
int.TryParse(result._wwwResult.text, out InstantUpdate_UpdateVersionControlCode);
}
if (onComplete != null)
{
onComplete(InstantUpdate_UpdateVersionControlCode);
}
});
if (Application.isPlaying)
{
mono = GetGameManager();
mono.StartCoroutine(enumerator);
}
else
{
while (enumerator.MoveNext())
{
;
}
}
}
private IEnumerator joinRoom(CoroutineResult <bool> isSuccess)
{
SCJoinMatch response = null;
_ui.IsJoiningMsgEnabled = true;
NetworkManager.Instance.SendMessage <CSJoinMatch, SCJoinMatch>(
MessageType.cs_join_match, new CSJoinMatch {
nickname = _nickname
},
MessageType.sc_join_match, res => response = res);
while (response == null)
{
yield return(null);
}
if (response.result != extichu_messages.ErrorCode.EC_OK)
{
isSuccess.Set(false);
yield break;
}
_ui.IsJoiningMsgEnabled = false;
this.setNameTags(
response.room_state.nickname_1,
response.room_state.nickname_2,
response.room_state.nickname_3,
response.room_state.nickname_4);
}
static int CheckTimeOut(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 4);
WWW arg0 = (WWW)LuaScriptMgr.GetNetObject(L, 1, typeof(WWW));
Action arg1 = null;
LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
if (funcType2 != LuaTypes.LUA_TFUNCTION)
{
arg1 = (Action)LuaScriptMgr.GetNetObject(L, 2, typeof(Action));
}
else
{
LuaFunction func = LuaScriptMgr.GetLuaFunction(L, 2);
arg1 = () =>
{
func.Call();
};
}
CoroutineResult arg2 = (CoroutineResult)LuaScriptMgr.GetNetObject(L, 3, typeof(CoroutineResult));
float arg3 = (float)LuaScriptMgr.GetNumber(L, 4);
IEnumerator o = StaticUtils.CheckTimeOut(arg0, arg1, arg2, arg3);
LuaScriptMgr.Push(L, o);
return(1);
}
public static async Task <bool> MoveTo(Vector3 destination, int distance, bool straightLinePath = false, [CallerMemberName] string caller = "", [CallerFilePath] string callerPath = "")
{
//destination.Z = AdvDia.MainGridProvider.GetHeight(destination.ToVector2());
if (_navigationCoroutine == null || _moveToDestination != destination || _moveToDistance != distance)
{
AdvDia.Navigator.Clear();
_navigationCoroutine = new NavigationCoroutine(destination, distance, straightLinePath);
Core.Logger.Debug($"Created Navigation Task for {destination}, within a range of (specified={distance}, actual={_navigationCoroutine._distance}). ({callerPath.Split('\\').LastOrDefault()} > {caller} )");
_moveToDestination = destination;
_moveToDistance = distance;
}
LastDestination = _moveToDestination;
if (await _navigationCoroutine.GetCoroutine())
{
LastResult = _navigationCoroutine.State == States.Completed ? CoroutineResult.Success : CoroutineResult.Failure;
if (_navigationCoroutine.State == States.Failed)
{
Core.Logger.Debug($"NavigationCoroutine failed for {destination} Distance={destination.Distance(ZetaDia.Me.Position)}, within a range of (specified={distance}, actual={_navigationCoroutine._distance}). ({callerPath.Split('\\').LastOrDefault()} > {caller} )");
return(true);
}
_navigationCoroutine = null;
return(true);
}
return(false);
}
public IEnumerable <ICoroutineResult> CoroutineWaitingForTask(int wait = 100)
{
_taskRun = false;
_taskStarted = false;
_completed = false;
var completed = false;
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.RunTask(Task.Factory.StartNew(() =>
{
_taskStarted = true;
Thread.Sleep(wait);
_taskRun = true;
}), "CoroutineWaitingForTask")
.OnComplete(() =>
{
completed = true;
}).AndWait());
if (completed)
{
_completed = true;
}
}
public IEnumerable <ICoroutineResult> CoroutineWaitingHavingTimeoutNotExploding()
{
_taskRun = false;
_taskStarted = false;
_completed = false;
var completed = false;
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.RunTask(Task.Factory.StartNew(() =>
{
_taskStarted = true;
Thread.Sleep(100);
_taskRun = true;
}), "CoroutineWaitingHavingTimeoutNotExploding")
.OnComplete(() =>
{
completed = true;
})
.WithTimeout(1000)
.AndWait());
if (completed)
{
_completed = true;
}
}
static int WWWReConnect(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 5);
CoroutineResult arg0 = (CoroutineResult)LuaScriptMgr.GetNetObject(L, 1, typeof(CoroutineResult));
string arg1 = LuaScriptMgr.GetLuaString(L, 2);
Action arg2 = null;
LuaTypes funcType3 = LuaDLL.lua_type(L, 3);
if (funcType3 != LuaTypes.LUA_TFUNCTION)
{
arg2 = (Action)LuaScriptMgr.GetNetObject(L, 3, typeof(Action));
}
else
{
LuaFunction func = LuaScriptMgr.GetLuaFunction(L, 3);
arg2 = () =>
{
func.Call();
};
}
float arg3 = (float)LuaScriptMgr.GetNumber(L, 4);
int arg4 = (int)LuaScriptMgr.GetNumber(L, 5);
IEnumerator o = StaticUtils.WWWReConnect(arg0, arg1, arg2, arg3, arg4);
LuaScriptMgr.Push(L, o);
return(1);
}
public IEnumerable <ICoroutineResult> CoroutineWaitingForSeveralItems(int waitCount = 1)
{
_coroutineResultsCount = 0;
_completed = false;
var result = 0;
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.ForEachItem(ReturnSeveralItemsAndWaitInBetween(waitCount), "ReturnSeveralItemsAndWaitInBetween")
.Do((r) =>
{
Console.Write(" _");
_partialCoroutineResultsCount++;
result++;
return true;
})
.OnComplete(() =>
{
Console.WriteLine(" X");
_completed = true;
})
.WithTimeout(TimeSpan.FromDays(10))
.AndWait());
Console.WriteLine("U");
if (_completed)
{
_coroutineResultsCount = result;
}
}
IEnumerator Co3(CoroutineResult <long> resulter, object param)
{
for (var i = 0; i < 100; i++)
{
yield return(i);
}
resulter.Result = long.MaxValue;
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
var operation = _operations.Call(rule, index, out result);
// accumulate step counts of called child rules
result.OnResolve += value => { stepCount += value.StepCount; };
return(operation);
}
IEnumerator Co3(CoroutineResult<long> resulter, object param)
{
for (var i = 0; i < 100; i++)
{
yield return i;
}
resulter.Result = long.MaxValue;
}
public IEnumerable <ICoroutineResult> WaitAndReturnSingleValue(int waitCount)
{
while (waitCount > 0)
{
yield return(CoroutineResult.Wait);
waitCount--;
}
yield return(CoroutineResult.Return("RESULT"));
}
public IEnumerable <ICoroutineResult> NotWaitingWaitForReturnValue(int waitCount)
{
while (waitCount > 0)
{
yield return(CoroutineResult.Wait);
waitCount--;
}
yield return(CoroutineResult.Return("RESULT"));
}
public IEnumerable <ICoroutineResult> NotWaitingCoroutineWaitingForSingleResult(int waitCount = 1)
{
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.RunAndGetResult(NotWaitingWaitForReturnValue(waitCount), "NotWaitingWaitForReturnValue")
.OnComplete <string>((r) =>
{
_coroutineSingleResult = r;
}));
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
var state = new RuleState <TNode>(rule, index, this, _parser._ruleStack.Peek());
result = state.Result;
return(() =>
{
DebugHooks.OnBeforeCall(state, rule, index);
_parser._ruleStack.Push(state);
});
}
IEnumerator Co2(CoroutineResult<string> result, object arg)
{
for (var i = 0; i < 100; i++)
{
yield return i;
}
result.Result = "TestString";
var co = Coroutine2.Start<long>(Co3);
yield return co;
Assert.AreEqual(long.MaxValue, co.Result);
}
public void Resolving_Result_ShouldTriggerOnResolveHook()
{
var resolveValue = "42";
var onResolveCalled = false;
var result = new CoroutineResult <string>();
result.OnResolve += (value) => { onResolveCalled = true; value.Should().Be(resolveValue); };
result.Resolve(resolveValue);
onResolveCalled.Should().BeTrue();
result.Value.Should().Be(resolveValue);
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
// Make sure that each "nested" call gets its own result
result = new CoroutineResult <RuleResult>();
_results.Push(result);
var context = new RuleContext(rule, index, this);
rule.Grab(context).ToList();
return(_noOpRuleOperation);
}
IEnumerator CoTestCoroutineGeneric(CoroutineResult<int> result, object arg)
{
// 25 tick
for (var i = 0; i < 25; i++)
{
yield return i;
}
var co2 = Coroutine2.Start<string>(Co2);
yield return co2;
Assert.AreEqual("TestString", co2.Result);
result.Result = 100;
}
public override IEnumerable <ICoroutineResult> OnCycle()
{
if (NoRun)
{
yield break;
}
Called.Add("OnCycle");
if (Throws != null)
{
throw Throws;
}
yield return(CoroutineResult.YieldReturn(DateTime.UtcNow));
}
private IEnumerator waitForNicknameInput()
{
Func <string, bool> isValidNickname = source =>
!!!string.IsNullOrEmpty(source) && source.Length >= 2 && source.Length <= 8;
var nickname = new CoroutineResult <string>();
yield return(_ui.WaitForNicknameInput(isValidNickname, nickname));
this._nickname = nickname;
_ui.IsNicknameInputEnabled = false;
}
public IEnumerable <ICoroutineResult> ReturnSeveralItemsAndWaitInBetween(int waitCount)
{
int results = 0;
while (waitCount > 0)
{
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.YieldReturn(results));
waitCount--;
results++;
}
}
IEnumerator Co2(CoroutineResult <string> result, object arg)
{
for (var i = 0; i < 100; i++)
{
yield return(i);
}
result.Result = "TestString";
var co = Coroutine2.Start <long>(Co3);
yield return(co);
Assert.AreEqual(long.MaxValue, co.Result);
}
public IEnumerable <ICoroutineResult> CoroutineWaitingForSingleResult(int waitCount = 1)
{
string result = null;
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.RunAndGetResult(WaitAndReturnSingleValue(waitCount), "WaitAndReturnSingleValue")
.OnComplete <string>((r) =>
{
result = r;
}).AndWait());
_coroutineSingleResult = result;
}
public IEnumerable <ICoroutineResult> GetAllItems(int waitCount)
{
int results = 0;
while (waitCount > 0)
{
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.YieldReturn(results));
waitCount--;
results++;
}
}
public override IEnumerable <ICoroutineResult> OnCycle()
{
if (!Enumerable.MoveNext())
{
yield return(CoroutineResult.YieldBreak());
TerminateElaboration();
}
else
{
Cycles++;
yield return(Enumerable.Current);
}
}
public RuleOperationsMock Evaluate(IRule rule)
{
// Capture result of the initial rule call
var result = new CoroutineResult <RuleResult>();
result.OnResolve += r => _result = r;
_results.Push(result);
var context = new RuleContext(new SimpleRef(rule), _index, this);
// In order to fully execute the rule, we have to iterate completely through the returned
// rule operations, simulating the execution of the called coroutines.
rule.Grab(context).ToList();
return(this);
}
IEnumerator CoTestCoroutineGeneric(CoroutineResult <int> result, object arg)
{
// 25 tick
for (var i = 0; i < 25; i++)
{
yield return(i);
}
var co2 = Coroutine2.Start <string>(Co2);
yield return(co2);
Assert.AreEqual("TestString", co2.Result);
result.Result = 100;
}
public static async Task <bool> MoveTo(Vector3 destination, int distance)
{
if (_navigationCoroutine == null || _moveToDestination != destination || _moveToDistance != distance)
{
_navigationCoroutine = new NavigationCoroutine(destination, distance);
_moveToDestination = destination;
_moveToDistance = distance;
}
if (await _navigationCoroutine.GetCoroutine())
{
LastResult = _navigationCoroutine.State == States.Completed ? CoroutineResult.Success : CoroutineResult.Failure;
_navigationCoroutine = null;
return(true);
}
return(false);
}
public static async Task<bool> MoveTo(Vector3 destination, int distance)
{
if (_navigationCoroutine == null || _moveToDestination != destination || _moveToDistance != distance)
{
_navigationCoroutine = new NavigationCoroutine(destination, distance);
_moveToDestination = destination;
_moveToDistance = distance;
}
if (await _navigationCoroutine.GetCoroutine())
{
LastResult = _navigationCoroutine.State == States.Completed ? CoroutineResult.Success : CoroutineResult.Failure;
_navigationCoroutine = null;
return true;
}
return false;
}
static int _CreateCoroutineResult(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
CoroutineResult obj = new CoroutineResult();
LuaScriptMgr.PushObject(L, obj);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: CoroutineResult.New");
}
return(0);
}
public static IEnumerator wrapperCoroutine(IEnumerator co, CoroutineFinProc finishDelegate)
{
while (true)
{
System.Object current = null;
try
{
if (!co.MoveNext())
{
if (finishDelegate != null)
{
CoroutineResult result = new CoroutineResult();
finishDelegate(result);
}
yield break;
}
current = co.Current;
if ((current != null) && (current.GetType() == typeof(CoroutineResult)))
{
CoroutineResult result = (CoroutineResult)current;
if (finishDelegate != null)
{
finishDelegate(result);
}
yield break;
}
}
catch (System.Exception e)
{
if (finishDelegate != null)
{
CoroutineResult result = new CoroutineResult();
result.strErrMsg = e.Message;
Debug.LogError("Coroutine Exceprion:" + e);
finishDelegate(result);
}
yield break;
}
yield return(current);
}
}
public IEnumerable <ICoroutineResult> NotWaitingForTask()
{
_notWaitingStarted = true;
yield return(CoroutineResult.Wait);
yield return(CoroutineResult.RunTask(Task.Factory.StartNew(() =>
{
_taskStarted = true;
Thread.Sleep(100);
_taskRun = true;
}), "NotWaitingForTask")
.OnComplete(() =>
{
_completedTaks = true;
}));
_notWaitingCompleted = true;
}
