May 20, 2021
Coroutines
Unity
Title:
Introduction to Game Development (E21: coroutines)
By:
Sebastian Lague
Description:
Covers the basics of coroutines in Unity.
Title:
Coroutines In Unity – What Are Coroutines And How To Use Them – Coroutines Unity Tutorial
By:
Awesome Tuts
Description:
Covers some intermediate complexity uses of coroutines as well as tying them in with Invoke calls.
Title:
Coroutines – Unity Official Tutorials
By:
Unity
Description:
Old official Unity tutorial on the fundamentals of coroutines in their system.
Overview
Coroutines appear to be a strong tool within Unity that I still am looking for ways to implement better in my systems. While understanding the basic uses for them with timing related events, I feel like they offer a lot more that I am not utilizing, so I wanted to further my understanding of them by following up on one of my older tutorial blogs and going through the tutorials it offers.
Tutorial #1 Notes
Coroutines are part of the Unity engine, and are not native to C#. They also belong to the Monobehaviour base class, so they class they are used in must inherit from Monobehaviour.
The coroutine return type is IEnumerator. Because of this, coroutines can also be stored in IEnumerator variables. This also allows them to be passed in as a paramter for the yield return statement within a Coroutine.
Use a reference to properly control the starting and stopping of a specific coroutine instance.
Tutorial #2 Notes
You can call a Coroutine from within itself (the same Coroutine). This is one way to cycle a Coroutine continously.
WaitForSecondsRealtime is similar to WaitForSeconds, except that WaitForSecondsRealtime is independent of Unity’s timescale. WaitForSeconds however is affected by the timescale. WaitUntil suspends the coroutine until the given delegate returns true.
Invoke Notes
- Invoke – call a method after a given amount of time
- InvokeRepeating – call a method every given amount of time, after a starting given time
- CancleInvoke – stops an InvokeRepeating call
Tutorial #3 Notes
Coroutines are functions which execute in intervals. They work with special yield statements which return the code execution out of the function. Then, when the function continues, execution begins from where it left off.
Combining coroutines with properties can allow for efficient code which produces execution only when a value is changed, without the need to check for variable changes every frame with the Update() method or something similar.
Coroutine Return Statements
A substantial part of using and controlling coroutines is the various return statements you can use within them to determine when they should run and when they should pause execution. As such I listed several of these options and how they work within the coroutines.
yield return null
waits a frame before progressing to the next step
seems similar to the rate of the Update() method
yield return new WaitForSeconds(float time)
waits the given amount of seconds between each run of the process
yield return WaitForSecondsRealtime(float time)
waits the given amount of seconds, regardless of Unity’s timescale
yield return StartCoroutine(DoSomething())
waits until the given Coroutine “DoSomething” is finished running
yield return new WaitUntil(bool test)
suspends coroutine until the given parameter is true (opposite of WaitWhile)
yield return new WaitWhile(bool test)
suspends coroutine until the given paramter is false (opposite of WaitUntil)
Summary
Coroutines are starting to become a bit more clear to me, and this helped me learn a few more ways to incorporate them into my projects. Just seeing that they are specifically a Unity native concept was helpful to me as I did not think about that before, and that makes their somewhat strange nature make more sense in my head. This made it more clear that Unity is doing a lot of work behind the scenes to accomplish their main goals of determining when to start, pause, resume execution based on their yield values. Also the Unity note on tying them in with properties is very interesting and something I want to experiment with more myself for more efficient code.
via Blogger http://stevelilleyschool.blogspot.com/2021/05/coroutine-fundamentals-in-unity.html