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);
}
