Why coroutines handle time-based logic in Unity - Visual Breakdown

Concept Flow - Why coroutines handle time-based logic

Start Coroutine

↓

Execute first step

↓

Yield WaitForSeconds

↓

Pause execution

↓

Wait real time passes

↓

Resume Coroutine

↓

Execute next step

↓

Repeat or End

Coroutines run step-by-step, pausing at yield points like WaitForSeconds, letting time pass before continuing.

Execution Sample

Unity

IEnumerator ExampleCoroutine() {
  Debug.Log("Start");
  yield return new WaitForSeconds(2);
  Debug.Log("After 2 seconds");
}

This coroutine logs a message, waits 2 seconds, then logs another message.

Execution Table

Step	Action	Yield/Wait	Time Passed	Output
1	Start coroutine and run first Debug.Log	No yield	0s	"Start" logged
2	Yield return WaitForSeconds(2)	Pause coroutine	0s	No output, coroutine paused
3	Wait 2 seconds pass	Still paused	2s	No output
4	Resume coroutine after wait	No yield	2s	No output
5	Run Debug.Log after wait	No yield	2s	"After 2 seconds" logged
6	Coroutine ends	No yield	2s	Coroutine finished

💡 Coroutine ends after all steps run and no more yields remain

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
Coroutine State	Not started	Running	Paused (waiting)	Paused (waiting)	Running	Running	Finished
Time Passed (seconds)	0	0	0	2	2	2	2

Key Moments - 3 Insights

Why does the coroutine pause at 'yield return WaitForSeconds(2)'?

Because the coroutine yields control and waits for 2 seconds before continuing, as shown in execution_table step 2 and 3.

Does the coroutine block the whole program while waiting?

No, it only pauses itself. The rest of the program continues running while the coroutine waits, as seen by the pause in coroutine state but time passing.

What happens after the wait time passes?

The coroutine resumes execution from where it paused, running the next lines of code, as shown in execution_table step 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the coroutine state after step 2?

A Running

B Finished

C Paused (waiting)

D Not started

💡 Hint

Check the 'Coroutine State' row in variable_tracker after step 2

At which step does the coroutine resume after waiting?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at execution_table where 'Resume coroutine after wait' happens

If we change WaitForSeconds(2) to WaitForSeconds(5), what changes in the execution_table?

A Coroutine ends earlier

B Time Passed at step 3 changes to 5s

C Output at step 1 changes

D Coroutine state at step 1 changes

💡 Hint

Focus on the 'Time Passed' column in execution_table at the waiting step

Concept Snapshot

Coroutines run code step-by-step and pause at yield points.
Use 'yield return WaitForSeconds(seconds)' to pause without freezing the program.
After the wait, coroutine resumes automatically.
This lets you handle time-based logic easily in Unity.
Coroutines do not block the main thread.

Full Transcript

Coroutines in Unity let you write code that pauses and resumes over time. When you start a coroutine, it runs until it hits a yield statement like 'yield return WaitForSeconds(2)'. At that point, the coroutine pauses and waits for 2 seconds without stopping the whole program. After 2 seconds pass, Unity resumes the coroutine from where it left off. This way, you can handle delays and timed actions easily. The execution table shows each step: starting, pausing, waiting, resuming, and finishing. Variables track the coroutine state and time passed. Beginners often wonder why the coroutine pauses and if it blocks the program. It only pauses itself, letting other code run. Changing the wait time changes how long the coroutine pauses. This makes coroutines perfect for time-based logic in Unity.