/// <summary> /// Stops the running LerpChannel and terminates the Coroutine. /// This will not execute the InterruptedCallback. /// </summary> public void HardKill() { running = false; if (lerpCoroutine?.MoveNext() ?? false) { StopCoroutine(lerpCoroutine); finishedCallback = null; lerpAction = null; continuousAction = null; interruptedCallback = null; } }
public void Activate( float duration, ILerpAction <T> lerpAction = null, IContinuousAction <T> continuousAction = null, Action <T> finishedCallback = null, Action <T> interruptedCallback = null) { if (running) { if (this.interruptedCallback != null) { //Handle existing interruptedCallbacks if (recurrentInterruptIdentifier > 2) { Debug.LogError("Identified potentially recursive interrupt callbacks"); } ++recurrentInterruptIdentifier; Action <T> tempInterruptedCallback = this.interruptedCallback; this.interruptedCallback = interruptedCallback; tempInterruptedCallback.Invoke(Target); --recurrentInterruptIdentifier; } } ElapsedTime = 0f; this.duration = duration; this.lerpAction = lerpAction; this.continuousAction = continuousAction; this.finishedCallback = finishedCallback; this.interruptedCallback = interruptedCallback; this.lerpAction?.Initialize(Target); this.continuousAction?.Initialize(Target, Time.time); if (!running) { StartCoroutine(lerpCoroutine = RunAction()); } }
private IEnumerator RunAction() { running = true; lerpAction?.CallAction(0f); continuousAction?.CallAction(Time.time); do { yield return(null); ElapsedTime += Time.deltaTime; //As per best-practices, we are not using null-conditional operators in //every-frame loops if (lerpAction != null) { lerpAction.CallAction(ElapsedTime / duration); } if (continuousAction != null) { continuousAction.CallAction(Time.time); } }while (ElapsedTime < duration && running); running = false; if (ElapsedTime < duration) { //If ElapsedTime < duration, that means we bailed out when running was set to false //and thus didn't execute lerpAction.CallAction(1f) if (interruptedCallback != null) { //Execute our interrupted callback ++recurrentInterruptIdentifier; //Cache the value because executing it could could change or clear the state. Action <T> tempInterruptedCallback = interruptedCallback; finishedCallback = null; interruptedCallback = null; lerpAction = null; continuousAction = null; tempInterruptedCallback.Invoke(Target); --recurrentInterruptIdentifier; } } else if (finishedCallback != null) { //Copy the callback in case it triggers a new coroutine Action <T> tempFinishedCallback = finishedCallback; finishedCallback = null; lerpAction = null; continuousAction = null; interruptedCallback = null; tempFinishedCallback.Invoke(Target); } }