// A note about .Wait(: // 1 It would be redundant to add a .Wait(time) because there is an // Add(time) currently. Hm, I need to address this to avoid uglyness. // 2 A Wait(YieldInstruction) would be useless after the first time a // TeaTime runs, because the Yield reference can't be used again when a // TeaTime is replayed. /// The queue will wait until the TeaTime is fullfiled. public TeaTime Wait(TeaTime tt) { return(this.Add((ttHandler t) => { t.Wait(tt); })); }
// CUSTOM YIELDS /// IEnumerator that waits the completion of a TeaTime. private IEnumerator WaitForCompletion(TeaTime tt) { while (!tt.IsCompleted) { yield return(null); } }
void Start() { // Instantiate queue = new TeaTime(this); // or you can use this shortcut: 'queue = this.tt();' (special MonoBehaviour extension) // Adds a one second callback loop that lerps to a random color. queue.Loop(1f, (ttHandler t) => { cubeRen.material.color = Color.Lerp( cubeRen.material.color, new Color(Random.value, Random.value, Random.value, Random.value), t.deltaTime); // t.deltaTime is a custom delta that represents the loop duration }); // Adds a one second callback loop that lerps to a random scale. queue.Loop(1f, (ttHandler t) => { cubeRen.transform.localScale = Vector3.Lerp( cube.localScale, new Vector3(Random.Range(0.5f, 2), Random.Range(0.5f, 2), Random.Range(0.5f, 2)), t.deltaTime); }); }
void Start() { // Instantiate queue = new TeaTime(this); // or you can use this shortcut: 'queue = this.tt();' (special // MonoBehaviour extension) // Adds a one second callback loop that lerps to a random color. queue .Add(() => Debug.Log("Queue Beginning " + Time.time)) .Loop(1, (ttHandler t) => { // From white to black, using .t (completion float from 0.0 to 1.0) cubeRen.material.color = Color.Lerp( Color.white, Color.black, t.t); }) .Loop(1, (ttHandler t) => { cubeRen.transform.localScale = Vector3.Lerp( new Vector3(1, 1, 1), new Vector3(3, 3, 3), t.t); }) .Add(() => Debug.Log("Queue End " + Time.time)) .Yoyo(); // Yoyo mode will .Reverse() the queue execution order when the queue is // completed }
/// Appends a TeaTime to wait after the current callback execution that /// is also affected by the queue .Stop() and .Reset(). public void Wait(TeaTime tt) { // A reference to the waiting list if (!self._waiting.Contains(tt)) { self._waiting.Add(tt); Wait(tt.WaitForCompletion()); } }
void Start() { queue = this.tt("@master").Pause().Add(t => { TeaTime chosen = null; switch (Random.Range(0, 3)) { case 0: chosen = this.tt("@1").Add(1, t2 => { Debug.Log("Waits 1 " + Time.time); }) .Immutable(); break; case 1: chosen = this.tt("@2").Add(2, t2 => { Debug.Log("Waits 2 " + Time.time); }) .Immutable(); break; case 2: chosen = this.tt("@3").Add(3, t2 => { Debug.Log("Waits 3 " + Time.time); }) .Immutable(); break; } t.Wait(chosen); Debug.Log("New cycle " + Time.time); }) .Repeat(); }
/// Returns a TeaTime queue bounded to his name, unique per /// MonoBehaviour instance, new on the first call. This allows you to /// access queues without a formal definition. public static TeaTime tt(this MonoBehaviour instance, string queueName) { // #todo ttRegister will (probably) need an auto clean up from // time to time if this technique is used in volatile GameObjects. // First time if (ttRegister == null) { ttRegister = new Dictionary <MonoBehaviour, Dictionary <string, TeaTime> >(); } if (!ttRegister.ContainsKey(instance)) { ttRegister[instance] = new Dictionary <string, TeaTime>(); } if (!ttRegister[instance].ContainsKey(queueName)) { ttRegister[instance][queueName] = new TeaTime(instance); } return(ttRegister[instance][queueName]); }
void Start() { TeaTime queue = this.tt(); // Every second this.tt().Add(1, () => { // Append lots of Adds & Loops for (int i = 0; i < 10000; i++) { // Call them quick queue.Add(0.10f, (ttHandler t) => { addFrameCount += 1; }) .Loop(0.10f, (ttHandler t) => { loopFrameCount += 1; }); } }) // Forever .Repeat(); }
public ttWaitForCompletion(TeaTime tt) { this.tt = tt; }
void Start() { // Instantiate queue = new TeaTime(this); // or you can use this shortcut: 'queue = this.tt();' (special MonoBehaviour extension) }
void Start() { queue = this.tt().Pause().Add(1, () => { Debug.Log("step 1 " + Time.time); }) .Add(1, () => { Debug.Log("step 2 " + Time.time); }) .Add(1, (ttHandler t) => { Debug.Log("step 3 " + Time.time); t.Wait(1); }) .Add(() => { Debug.Log("step 4 " + Time.time); }) .Loop(1, (ttHandler t) => { transform.position = Vector3.Lerp(transform.position, new Vector3(10, 10, 10), t.deltaTime); }) .Add(() => { Debug.Log("step 5 " + Time.time); }) .Loop((ttHandler t) => { transform.position = Vector3.Lerp(transform.position, Vector3.zero, t.deltaTime); if (t.timeSinceStart >= 1) { t.EndLoop(); } }) .Add(() => { Debug.Log("step 6 " + Time.time); }) .Loop(0, (ttHandler t) => { // Ignorable loop }) .Add(1, () => { Debug.Log("step 8 " + Time.time); }) .Add((ttHandler t) => { // WaitFor a Loop and an Add t.Wait(this.tt().Loop(0.5f, (ttHandler) => { }).Add(0.5f, () => { Debug.Log("step 9 " + Time.time); }) .WaitForCompletion()); }) .Immutable(); // #todo // Create tests for Func<float> as time // Create a tests for Consume() mode }
void Start() { // @ // A simple 2 seconds delay. TeaTime simpleDelay = this.tt().Add(2, () => { Debug.Log("simpleDelay: Two seconds later, just once!" + Time.time); }); // @ // Something that repeats itself every 3 seconds. TeaTime repeatDelay = this.tt().Add(() => { Debug.Log("repeatDelay: Every 3 seconds, repeats forever! " + Time.time); }) .Add(3).Repeat(); // @ // A controlled frame by frame loop (update-like) with 1.5 seconds duration! TeaTime updateLike = this.tt().Loop(1.5f, (ttHandler loop) => { Debug.Log("updateLike: Frame by frame during 1.5 seconds, just once! " + Time.time); }); // @ // A simple delay without autoplay. TeaTime somethingForLater = this.tt().Pause().Add(3, () => { Debug.Log("somethingForLater: Someone called 'somethingForLater.Play()' 3 second ago! " + Time.time); }); somethingForLater.Play(); // @ // A tween-like with before and after setup. TeaTime tweenLike = this.tt().Add(() => { Debug.Log("tweenLike: Just before the 4 seconds loop! " + Time.time); transform.position = new Vector3(999, 999, 999); }) .Loop(4, (ttHandler loop) => { transform.position = Vector3.Lerp( transform.position, Vector3.zero, loop.deltaTime); }) .Add(() => { Debug.Log("tweenLike: Just after the 4 seconds loop! " + Time.time); }); // #todo Fix this pattern as example of a waiting loop // Loading the first level! // this.tt("@LoadUnload").Pause().Add((ttHandler t) => // { // if (levelToLoad >= 0) // loading = SceneManager.LoadSceneAsync(levelToLoad, LoadSceneMode.Additive); // }) // .Loop((ttHandler t) => // { // if (loading == null || loading.isDone) // t.EndLoop(); // }) // .Add(1, () => // { // if (levelToUnload >= 0) // SceneManager.UnloadScene(levelToUnload); // }) // .Immutable(); // // More to come! Soon! // }