Sequential Task Chaining with Coroutines

In this lesson, you will learn how to orchestrate complex sequences of operations by nesting coroutines to ensure tasks execute in a specific, reliable order.

The Problem: Order of Operations

Sometimes, a game feature requires several steps to happen one after the other. For example, imagine a treasure chest: you want it to 1. play an opening animation, 2. wait for the lid to finish, and 3. spawn loot. If you trigger these all at once, the loot will spawn before the chest is even open.

While you could use WaitForSeconds for each step, that gets messy if your animations vary in length. Instead, you can "chain" your coroutines so one routine waits for the completion of another.

Chaining with yield return

In Unity, a coroutine is a method that returns an IEnumerator. The magic happens because yield return can accept a call to another coroutine. When you yield to another method, the parent coroutine pauses until the child coroutine finishes its final execution.

Consider this example:

IEnumerator OpenChestSequence()
{
    Debug.Log("Starting sequence...");
    // This pauses OpenChestSequence until PlayAnimation finishes
    yield return StartCoroutine(PlayAnimation());
    
    // This line only runs after PlayAnimation finishes
    SpawnLoot();
    Debug.Log("Sequence complete!");
}

IEnumerator PlayAnimation()
{
    // Simulate animation time
    yield return new WaitForSeconds(2.0f);
    Debug.Log("Chest is now open.");
}

Why This Matters

By nesting coroutines, you turn complex, multi-step behaviors into readable blocks of code. Instead of tracking global timers or boolean flags (like isChestOpen), your logic follows a linear path that reads exactly like a list of instructions. This is highly effective for cutscenes, ability cooldown sequences, or multi-stage enemy behaviors. Because each step is contained within its own method, you can easily debug or reuse specific tasks in different parts of your game without rewriting the timing logic.

Key Takeaway: You can chain sequential tasks by calling yield return StartCoroutine() within a parent routine, ensuring that complex multi-step processes execute in a precise, predictable order.