public static void StopIfNotNull(this CoroutineClass t) { if (t != null) { t.Stop(); } }
/// <summary> /// dictionary에 reason을 멈춤원인으로 하는 코루틴을 등록 /// </summary> /// <param name="reason"></param> /// <param name="cc"></param> void Add(object reason, CoroutineClass cc) { if (reason == null) { reason = CoroutineClass.null_key; } if (cc.key_of_mylist == reason) { return; } else { RemoveThis(cc); } List <CoroutineClass> lsCC = Get(reason); if (lsCC == null) { lsCC = new List <CoroutineClass>(); dicTotalCoroutines.Add(reason, lsCC); } lsCC.Add(cc); cc.key_of_mylist = reason; cc.mylist = lsCC; }
/// <summary> /// cc에 의해 중지중인 모든 코루틴을 찾아낸다 /// post-ordering 임 /// seed 자기자신 미포함임 /// </summary> /// <param name="cc"></param> /// <param name="usethis"></param> /// <returns></returns> public List <CoroutineClass> GetAllStuckedBy(CoroutineClass cc, List <CoroutineClass> usethis = null) { if (usethis == null) { usethis = new List <CoroutineClass>(); } object key = null; if (cc == null) { key = CoroutineClass.null_key; } else { key = cc.coroutine.Current; } var lsCC = Get(key); foreach (var v in lsCC) { GetAllStuckedBy(v, usethis); } usethis.Add(Get(cc)); return(usethis); }
public CoroutineClass Scale(float MaximumScaleAdder = 0.2f, float time = 0.2f, float period = 0.1f) { if (lefttime < time) { Stop(); shaker = scCoroutine.Instance.Begin(scaler(MaximumScaleAdder, time, period)); } return(shaker); }
public CoroutineClass Shake(Vector2 axis, float BeginAmplitude = CameraShakeBasicAmplitude, float time = CameraShakeBasicTime, float period = CameraShakeBasicPeriod) { if (lefttime < time) { Stop(); shaker = scCoroutine.Instance.Begin(shake(axis, BeginAmplitude, time, period)); } return(shaker); }
/// <summary> /// cc가 기다리고 있는 모든 코루틴을 연쇄적으로 중단 /// cc를 기다리고 있는 모든 코루틴을 연쇄적으로 중단 /// </summary> /// <param name="cc"></param> public void StopRecusively(CoroutineClass cc) { if (cc != null) { var ls = GetAllStuckedBy(cc); foreach (var v in ls) { v.Stop(); } cc.StopIfNotNull(); } }
/// <summary> /// 만들어진 코루틴의 첫실행. /// 내부적으로만 호출 /// </summary> /// <param name="cc"></param> void coroutineFirstRun(CoroutineClass cc) { do { cc.MoveNext(true); }while ( //아직 안 끝났으며, 코루틴에 의해 막혔는데, 그 코루틴이 노딜레이로 끝났다면 계속함 cc.br && cc.coroutine.Current is CoroutineClass && !((CoroutineClass)cc.coroutine.Current).br ); //내가 끝났다면 노딜레이 피니시 if (!cc.br) { cc.RunFinishFunction(); } else { #region commantations //노 딜레이로 끝나지 않음 = 바로 안 끝났다는 이야기 //케이스 : // 0. 내가 끝났는데 나를 기다리게 하는놈이 있을 수 없음. // 1. 난 아직 안 끝났고, 나를 기다리게 한 게 함수이고, 그놈이 nodelayfinish라면 -> 앞에서 이미 체크됨 // 2. 난 아직 안 끝났고, 나를 기다리게 한 게 함수이고, 그놈이 delayed-finish라면 -> ... 여기서 그럴수가 있나? 걍 리턴 (불가능한 case이므로) // 3. 난 아직 안 끝났고, 나를 기다리게 한 게 함수이고, 그놈이 not yet finished 라면 -> 내가 이미 실행됐으므로 return // 4. 난 아직 안 끝났고, 나를 기다리게 한 게 null이면 -> return /* * //3 : * if(cc.coroutine.Current is CoroutineClass) * { * Add(cc.coroutine.Current, cc); * return cc; * } * else * //4 : 아직 안 끝남 * if (cc.coroutine.Current == null) * { * Add(cc.coroutine.Current, cc); * return cc; * } */ //3과 4는 처리방식이 동일하므로 그냥 이렇게 처리. 그러나 위쪽에 로직을 남겨놓는 이유는 legacy를 위하여 #endregion Add(cc.coroutine.Current, cc); } }
/// <summary> /// waiter_list 에 자기자신을 포함한, 자기가 기다리는 대기열의 모든 리스트를 내보내준다. /// </summary> /// <param name="waiter_list"></param> /// <returns></returns> public void MakeWaiterList(List <CoroutineClass> waiter_list) { waiter_list.Clear(); object waiter = coroutine.Current; waiter_list.Add(this); while (waiter != null && waiter.GetType() == typeof(CoroutineClass)) { CoroutineClass c_waiter = (CoroutineClass)waiter; waiter_list.Add(c_waiter); waiter = c_waiter.coroutine.Current; } }
/// <summary> /// dictionary에 등록되있던 코루틴 제거 : 이 코루틴에 의해 stuck 되어있던 애들의 실행은 보장하지 않는다. /// </summary> /// <param name="cc"></param> void RemoveThis(CoroutineClass cc) { if (cc.key_of_mylist == null) { return; } cc.mylist.Remove(cc); if (cc.mylist.Count == 0) { dicTotalCoroutines.Remove(cc.key_of_mylist); } cc.mylist = null; cc.key_of_mylist = null; }
public CoroutineClass Begin_Dangled(GameObject mb, IEnumerator wanna_run, CoroutineClass.WhenDangledNotAcitve dangledisbleAction, int tag = 0) { CoroutineClass cc = new CoroutineClass(this, wanna_run); cc.myCoroutine = this; cc.tag = tag; if (mb != null) { //dangling cc.DangledGameobject = mb; cc.is_dangled_with_gameobject = true; } cc.DangledDisabledAction = dangledisbleAction; coroutineFirstRun(cc); return(cc); }
/// <summary> /// standalone begin /// </summary> /// <param name="wanna_run"></param> /// <param name="tag"></param> /// <returns></returns> public CoroutineClass Begin(IEnumerator wanna_run, int tag = 0) { try { CoroutineClass cc = new CoroutineClass(this, wanna_run); cc.myCoroutine = this; cc.tag = tag; coroutineFirstRun(cc); return(cc); } catch (System.Exception e) { Util.LogError(e); return(null); } }
bool moveNext() { //실행은 한 틱에 한 번만! //Util.Log("br is" + br+"/last_runn:"+last_runned_tick+"/curr:"+current_tick); if (last_runned_tick < myCoroutine.CurrentTick) { last_runned_tick = myCoroutine.CurrentTick; //MoveNext할 수 있는지 체크 if (coroutine.Current == null) { bool t_br = coroutine.MoveNext(); if (br) { br = t_br; } if (!br) { RunFinishFunction(); } } else if (coroutine.Current is CoroutineClass) { //쉰다. CoroutineClass waitCoroutine = (CoroutineClass)coroutine.Current; //만약 waitCoroutine이 끝나있는 상황이라면.. if (!waitCoroutine.br) { bool t_br = coroutine.MoveNext(); if (br) { br = t_br; } if (!br) { RunFinishFunction(); } } } return(br); } return(br); }