public void Start()
{
if(StartOnStart)
{
coroutine = StartCoroutine(DestroyOnDelay());
}
}
/// <summary>
/// Creates a TrackedCoroutine attached to a new container object that will destroy itself when finished.
/// </summary>
/// <param name="routine">Coroutine to run; if arguments are needed, pass an anonymous wrapper</param>
/// <param name="name">Name of the container object</param>
/// <param name="parent">Parent of the container object</param>
/// <returns>Created TrackedCoroutine instance</returns>
public static TrackedCoroutine Create(Coroutine routine, string name = "TrackedCoroutine", GameObject parent = null)
{
var instance = GameObjectUtils.InstantiateNewSingle<TrackedCoroutine>(name, parent);
instance.Routine = routine;
instance.DestroyOnComplete = true;
return instance;
}
public Idle(Customer customer, float seconds = 5)
: base(customer)
{
// Think about being idle
customer.Think(supermarket.IdleIcon);
delay = customer.StartCoroutine(Delay(seconds));
}
/// <summary>
/// 开始滚动显示;
/// </summary>
public void StartScroll(bool wait)
{
if (IsNeedScroll() && scrollCoroutineHandle == null)
{
scrollCoroutineHandle = StartCoroutine(ScrollCoroutine(wait));
}
}
public void LookAt(Vector2 target)
{
if (lookAtCoroutine != null)
StopCoroutine(lookAtCoroutine);
lookAtCoroutine = StartCoroutine(_LookAtTarget(target));
}
public void StartCompetitionMode(float distance)
{
if(!competitionStarting)
{
competitionRoutine = StartCoroutine(DogfightCompetitionModeRoutine(distance/2));
}
}
/// <summary>
/// Invoke4s the lua.
/// </summary>
/// <param name="callbakFunc">Callbak func.lua函数</param>
/// <param name="orgs">Orgs.参数</param>
/// <param name="sec">Sec.等待时间</param>
public UnityEngine.Coroutine invoke4Lua(object callbakFunc, object orgs, float sec, bool onlyOneCoroutine)
{
if (!gameObject.activeInHierarchy)
{
return(null);
}
if (callbakFunc == null)
{
Debug.LogError("callbakFunc is null ......");
return(null);
}
try {
UnityEngine.Coroutine ct = null;
if (onlyOneCoroutine)
{
cleanCoroutines(callbakFunc);
}
int index = getCoroutineIndex(callbakFunc);
ct = StartCoroutine(doInvoke4Lua(callbakFunc, sec, orgs, index));
setCoroutine(callbakFunc, ct, index);
return(ct);
} catch (System.Exception e) {
Debug.LogError("[" + gameObject.name + "]" + callbakFunc + ":" + e);
return(null);
}
}
private IEnumerator internalExplosion()
{
int currentIndex = 0;
var sprites = MapManager.Instance.SpriteManager.CurrentUsingSetting.Explosion;
while (true)
{
Renderer.SetTexture(sprites[currentIndex].texture, new Vector2(currentIndex * (1f / 6f), 0f));
currentIndex++;
if (currentIndex < sprites.Length)
yield return new WaitForSeconds(1f / 12f);
else
break;
}
mExplosionRoutine = null;
this.gameObject.SetActive(false);
if (null != Item)
{
Item.gameObject.SetActive(true);
MapManager.Instance.GenerateItem(this.transform.position, Item);
}
mIsAlive = false;
}
public override void Explosion()
{
if (null != mExplosionRoutine)
return;
mExplosionRoutine = StartCoroutine(internalExplosion());
}
public static void Stop(UnityEngine.Coroutine c)
{
if (c != null)
{
Instance.StopCoroutine(c);
}
}
private IEnumerator fadeTo(float targetOpacity, float duration, Action onFinish)
{
// remember the current callback in case this fade is exited early
_currentOnFinish = onFinish;
// remember initial state
float startOpacity = _fadeImage.color.a;
Color color = _fadeImage.color;
float t = 0;
while (t < duration)
{
t += Time.deltaTime;
// calculate the blend factor
float blend = Mathf.Clamp01(t / duration);
// blend
color.a = Mathf.Lerp(startOpacity, targetOpacity, blend);
_fadeImage.color = color;
yield return(null);
}
_currentOnFinish = null;
_currentFade = null;
onFinish?.Invoke();
}
static int WaitForFrame(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
Lit.Unity.LitBehaviour obj = (Lit.Unity.LitBehaviour)ToLua.CheckObject(L, 1, typeof(Lit.Unity.LitBehaviour));
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
Lit.Unity._D_Void arg1 = null;
LuaTypes funcType3 = LuaDLL.lua_type(L, 3);
if (funcType3 != LuaTypes.LUA_TFUNCTION)
{
arg1 = (Lit.Unity._D_Void)ToLua.CheckObject(L, 3, typeof(Lit.Unity._D_Void));
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 3);
arg1 = DelegateFactory.CreateDelegate(typeof(Lit.Unity._D_Void), func) as Lit.Unity._D_Void;
}
UnityEngine.Coroutine o = obj.WaitForFrame(arg0, arg1);
ToLua.PushObject(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
void Update()
{
if (co == null && Input.GetMouseButtonDown(0))
{
co = StartCoroutine(CreateEntityFromAnotherWorld());
}
}
public static IEnumerator ToUnity(this WaitCommand waitCommand, StartRoutine startRoutine)
{
if (waitCommand.IsRoutine)
{
var runningRoutines = new UnityEngine.Coroutine[waitCommand.RoutineCount];
for (int i = 0; i < waitCommand.RoutineCount; i++)
{
var routine = waitCommand.GetRoutine(i).ToUnity(startRoutine);
var runningRoutine = startRoutine(routine);
runningRoutines[i] = runningRoutine;
}
for (int i = 0; i < runningRoutines.Length; i++)
{
var runningRoutine = runningRoutines[i];
yield return(runningRoutine);
}
}
else
{
if (waitCommand.Duration.Value.Seconds > 0f)
{
yield return(new WaitForSeconds(waitCommand.Duration.Value.Seconds));
}
else
{
for (int i = 0; i < waitCommand.Duration.Value.FrameCount; i++)
{
yield return(null);
}
}
}
}
override protected void onFall()
{
if (this._playFallSfx == null)
{
this._playFallSfx = this.StartCoroutine(this.playFallSfx());
}
}
public static IEnumerator WaitThenCallback(float _time, Action _callback, UnityEngine.Coroutine _self = null)
{
yield return(new WaitForSecondsRealtime(_time));
_callback();
_self = null;
}
internal void ClearAllJobs()
{
this.StopAllCoroutines();
this._coroutines.Clear();
this._threadPointer = null;
this._theadAlive = false;
}
private void StartAutomaticRunCoroutine()
{
if (_automaticRunCoroutine == null)
{
_automaticRunCoroutine = StartCoroutine(AutomaticRunCoroutine());
}
}
public UIShowHideController(GameObject go, Component panel)
{
this.panel = panel;
this.animator = (go != null) ? go.GetComponent<Animator>() : null;
if (animator == null && panel != null) animator = panel.GetComponent<Animator>();
this.animCoroutine = null;
}
private void CancelCurrentAnim()
{
if (animCoroutine != null) {
DialogueManager.Instance.StopCoroutine(animCoroutine);
animCoroutine = null;
}
}
static int QPYX_StopCoroutine_YXQP(IntPtr L_YXQP)
{
try
{
int QPYX_count_YXQP = LuaDLL.lua_gettop(L_YXQP);
if (QPYX_count_YXQP == 2 && TypeChecker.CheckTypes <UnityEngine.Coroutine>(L_YXQP, 2))
{
UnityEngine.MonoBehaviour QPYX_obj_YXQP = (UnityEngine.MonoBehaviour)ToLua.CheckObject <UnityEngine.MonoBehaviour>(L_YXQP, 1);
UnityEngine.Coroutine QPYX_arg0_YXQP = (UnityEngine.Coroutine)ToLua.ToObject(L_YXQP, 2);
QPYX_obj_YXQP.StopCoroutine(QPYX_arg0_YXQP);
return(0);
}
else if (QPYX_count_YXQP == 2 && TypeChecker.CheckTypes <System.Collections.IEnumerator>(L_YXQP, 2))
{
UnityEngine.MonoBehaviour QPYX_obj_YXQP = (UnityEngine.MonoBehaviour)ToLua.CheckObject <UnityEngine.MonoBehaviour>(L_YXQP, 1);
System.Collections.IEnumerator QPYX_arg0_YXQP = (System.Collections.IEnumerator)ToLua.ToObject(L_YXQP, 2);
QPYX_obj_YXQP.StopCoroutine(QPYX_arg0_YXQP);
return(0);
}
else if (QPYX_count_YXQP == 2 && TypeChecker.CheckTypes <string>(L_YXQP, 2))
{
UnityEngine.MonoBehaviour QPYX_obj_YXQP = (UnityEngine.MonoBehaviour)ToLua.CheckObject <UnityEngine.MonoBehaviour>(L_YXQP, 1);
string QPYX_arg0_YXQP = ToLua.ToString(L_YXQP, 2);
QPYX_obj_YXQP.StopCoroutine(QPYX_arg0_YXQP);
return(0);
}
else
{
return(LuaDLL.luaL_throw(L_YXQP, "invalid arguments to method: UnityEngine.MonoBehaviour.StopCoroutine"));
}
}
catch (Exception e_YXQP) {
return(LuaDLL.toluaL_exception(L_YXQP, e_YXQP));
}
}
void Move(Vector3 newPos, float duration, float delay)
{
if (_moveCoroutine != null)
StopCoroutine(_moveCoroutine);
_moveCoroutine = StartCoroutine(MoveRoutine(newPos, duration, delay));
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyUp(KeyCode.P))
{
if (Time.timeScale != 0)
{
Debug.Log("Pausa");
Time.timeScale = 0;
}
else
{
Debug.Log("Reanudar");
Time.timeScale = 1;
}
}
if (Input.GetKeyUp(KeyCode.Mouse0))
{
if (contador != 0 && co != null)
{
StopCoroutine(co);
}
titulodeljuego.GetComponent <Text>().text = "";
message = texto[contador];
co = StartCoroutine(TypeText()); //Dos corrutinas diferentes
contador++;
if (contador >= texto.Length)
{
contador = 0;
Debug.LogError("Tamaño de tabla superado");
}
}
}
static int StopCoroutine(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.MonoBehaviour), typeof(UnityEngine.Coroutine)))
{
UnityEngine.MonoBehaviour obj = (UnityEngine.MonoBehaviour)ToLua.ToObject(L, 1);
UnityEngine.Coroutine arg0 = (UnityEngine.Coroutine)ToLua.ToObject(L, 2);
try
{
obj.StopCoroutine(arg0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
return(0);
}
else if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.MonoBehaviour), typeof(System.Collections.IEnumerator)))
{
UnityEngine.MonoBehaviour obj = (UnityEngine.MonoBehaviour)ToLua.ToObject(L, 1);
System.Collections.IEnumerator arg0 = (System.Collections.IEnumerator)ToLua.ToObject(L, 2);
try
{
obj.StopCoroutine(arg0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
return(0);
}
else if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.MonoBehaviour), typeof(string)))
{
UnityEngine.MonoBehaviour obj = (UnityEngine.MonoBehaviour)ToLua.ToObject(L, 1);
string arg0 = ToLua.ToString(L, 2);
try
{
obj.StopCoroutine(arg0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
return(0);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: UnityEngine.MonoBehaviour.StopCoroutine");
}
return(0);
}
private void StopAutomaticRunCoroutine()
{
if (_automaticRunCoroutine != null)
{
StopCoroutine(_automaticRunCoroutine);
_automaticRunCoroutine = null;
}
}
public void BeginCounter()
{
if( m_CounterRoutine != null )
return;
Debug.Log( "Begin" );
m_CounterRoutine = StartCoroutine( NotifyRoutine() );
}
public int AddCoroutine(IEnumerator coroutine, ECoroutineLevel level = ECoroutineLevel.High)
{
Coroutine cr = new Coroutine();
cr.coroutine = coroutine;
cr.crLevel = (int)level;
mCoroutineDic[mIndex++] = cr;
return mIndex;
}
public void StartTask(float timeout = 600)
{
if (cor != null)
{
return;
}
cor = StartCoroutine(Cor_Task(timeout));
}
private void StartCheckDayChangeCoroutine()
{
DateTime ZeroClockOfToday = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
TimeSpan ZeroClock2Now = ZeroClockOfToday - DateTime.Now;
int leftSecond = oneDaySeconds - (int)ZeroClock2Now.TotalSeconds + 1;
myCoroutine = StartCoroutine(CheckDayChange(leftSecond));
}
/// <summary>
/// 暂停滚动显示;
/// </summary>
public void PauseScroll()
{
if (scrollCoroutineHandle != null)
{
StopCoroutine(scrollCoroutineHandle);
scrollCoroutineHandle = null;
}
}
IEnumerator CheckDayChange(float seconds)
{
GuLog.Debug("<><DailyTaskResetProcess>CheckDayChange after:" + seconds);
yield return(new WaitForSeconds(seconds));
CheckNewDay();
myCoroutine = StartCoroutine(CheckDayChange(oneDaySeconds));
}
public void ShakeCamera(float factor, TimeSpan duration)
{
if (shakeCoroutine != null)
StopCoroutine(shakeCoroutine);
startShakeTime = Time.time;
shakeCoroutine = StartCoroutine(ShakeCoroutine(factor, duration));
}
public void setCoroutine(object callbakFunc, UnityEngine.Coroutine ct, int index)
{
object key = getKey4InvokeMap(callbakFunc, coroutineMap);
Hashtable map = getCoroutines(callbakFunc);
map [index] = ct;
coroutineMap [key] = map;
}
public void StartTimer(float time)
{
timerRunning = true;
timeRemaining = time;
if(_timer != null)
CoolDownManager.Instance.StopCoroutine(_timer);
_timer = CoolDownManager.Instance.StartCoroutine(CoolDownTimer(time));
}
private static void StopStreaming()
{
if (streamer.IsNotNull())
{
LockstepManager.UnityInstance.StopCoroutine(streamer);
streamer = null;
}
}
public override void PreDestroy()
{
this.StopAllCoroutines();
this._coroutines.Clear();
base.PreDestroy();
this._threadPointer = null;
this._theadAlive = false;
}
private void OnStopCoroutine()
{
if (coroutine != null)
{
GameLogic.Instance.StopCoroutine(coroutine);
}
coroutine = null;
}
public StaffIdle(Staff staff, float duration=5)
: base(staff)
{
animator.SetBool("isWalking", false);
if (duration >= 0)
{
delay = staff.StartCoroutine(Delay(duration));
}
}
override protected GO getFollowed()
{
if (this.bgFunc == null)
{
this.bgFunc = this.StartCoroutine(this.recacheFollowedObject());
}
return(this.followed);
}
protected void StopCoroutine(UnityEngine.Coroutine routine)
{
if (routine == null)
{
return;
}
outer.StopCoroutine(routine);
}
public void StopCounter()
{
if( this == null || m_CounterRoutine == null )
return;
Debug.Log( "Stop" );
StopCoroutine( m_CounterRoutine );
m_CounterRoutine = null;
}
public static Coroutine DelayRealtime(float time, CoroutineDefaultFunction func)
{
UnityEngine.Coroutine routine = CoroutineCaller.StartCoroutine(DelayFunctionCallRealtime(time, func));
if (routine == null)
{
UnityEngine.Debug.Log("Coroutine returned immediately");
}
return(new Coroutine(routine));
}
private void PressStarted()
{
isPouring = true;
currentSprite = PouringSprite1;
Background.sprite = currentSprite;
spriteSwitcherCoroutine = StartCoroutine(DoSpriteSwitcher());
}
public static Coroutine Start(IEnumerator enumerator)
{
UnityEngine.Coroutine routine = CoroutineCaller.StartCoroutine(enumerator);
if (routine == null)
{
UnityEngine.Debug.Log("Coroutine returned immediately");
}
return(new Coroutine(routine));
}
public void Initialize(PlayerUnit player)
{
baseWeapon = player.AimController.CurrentWeapon;
if(updateRoutine!=null)
StopCoroutine(updateRoutine);
updateRoutine = StartCoroutine(UpdateCoroutine());
}
public void SetValue(float f)
{
if (animation != null)
{
StopCoroutine(animation);
}
animation = StartCoroutine(CoAnimHp(Slider.value, f, 1f));
}
public void Notify(string message, Color color, int duration)
{
if (noticeRoutine != null) StopCoroutine(noticeRoutine);
m_notifierText.color = color;
m_notifierText.text = message.ToLower();
noticeRoutine = StartCoroutine(NoticeRoutine(duration));
}
override protected void onLand()
{
if (this._playFallSfx != null)
{
this.StopCoroutine(this._playFallSfx);
this._playFallSfx = null;
}
Global.Sfx.playPlayerLand(this.fastGetTr());
}
/// <summary>
/// 停止滚动显示;
/// </summary>
public void StopScroll()
{
if (scrollCoroutineHandle != null)
{
StopCoroutine(scrollCoroutineHandle);
scrollCoroutineHandle = null;
ResetScroll();
}
}
public virtual void StartLevel()
{
var enemiesLayer = LayerMask.NameToLayer( "Enemies" );
var playerLayer = LayerMask.NameToLayer( "Player" );
Physics.IgnoreLayerCollision( enemiesLayer, enemiesLayer );
Physics.IgnoreLayerCollision( playerLayer, playerLayer );
State = LevelState.Running;
LevelRunningCoroutine = Locator.Coroutines.RunCoroutine( LevelRunning() );
}
public override void Start()
{
m_childs = new List <ActionNode>();
m_childs.AddRange(children.ToList());
m_current = m_childs.FirstOrDefault();
m_status = Status.Running;
CoroutineManager.I.StopCoroutine(YieldUpdate());
m_coroutine = CoroutineManager.I.StartCoroutine(YieldUpdate());
}
private void HandleDoubleClick ()
{
// If the coroutine to check whether a click is a double is running, stop it.
if(m_SingleClickDelayCoroutine != null)
StopCoroutine (m_SingleClickDelayCoroutine);
// If warnings should be shown for double clicks show one with the double tap message and keep a reference to it.
if (m_ShowDoubleTapWarnings)
m_WarningCoroutine = StartCoroutine (DisplayWarning (m_DoubleTapWarningMessage));
}
private void HandleClick ()
{
// If the difference in time between now and the time when the button went down is greater than the constant, it's a 'hold' so return.
if (Time.time - m_DownTime >= k_ClickIsHoldTime)
return;
// If warning should be shown for single clicks and there is no current swipe direction, start a coroutine to check it's not a double click.
if (m_ShowSingleTapWarnings && m_CurrentSwipe == VRInput.SwipeDirection.NONE)
m_SingleClickDelayCoroutine = StartCoroutine(SingleClickCheckDelay ());
}
public void Stop()
{
navMeshAgent.Stop();
if (checkDestination != null)
{
StopCoroutine(checkDestination);
checkDestination = null;
}
}
public void Fall(GO caller)
{
if (this._isFalling)
{
return;
}
this.startAligning = false;
this.bgFunc = this.StartCoroutine(this.fall(caller));
}
override protected void updateState()
{
base.updateState();
if (this.target == null && this.anim == Anim.None &&
this.bgFunc == null)
{
this.bgFunc = this.StartCoroutine(this.wander());
}
}
public void Update()
{
if (_coroutine == null)
{
if (ActiveChildren == 0)
{
_coroutine = StartCoroutine(EnableChildren());
}
}
}
private void beginFade(IEnumerator fade)
{
// if there was an existing fade, stop it and execute its callback if it existed
if (_currentFade != null)
{
StopCoroutine(_currentFade);
}
_currentOnFinish?.Invoke();
_currentFade = StartCoroutine(fade);
}
//
public void Follow(Transform follow) {
if (follow != null) {
if (this.follow == null) {
StopAllCoroutines();
}
else {
StopCoroutine(following);
}
following = StartCoroutine(FollowCR());
}
}
private IEnumerator EnableChildren()
{
yield return new WaitForSeconds(1.0f);
foreach (var ballBumper in m_bumpers)
{
ballBumper.Reset();
}
ScoreDisplay.AddScore(m_pointValue);
_coroutine = null;
}
