Loading screens with coroutines in Unity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine loading simulation?

Consider this Unity coroutine that simulates a loading screen progress. What will be printed in the console?

Unity

using System.Collections;
using UnityEngine;

public class Loader : MonoBehaviour
{
    IEnumerator StartLoading()
    {
        int progress = 0;
        while (progress < 100)
        {
            progress += 20;
            Debug.Log($"Loading: {progress}%");
            yield return new WaitForSeconds(0.5f);
        }
        Debug.Log("Loading Complete!");
    }

    void Start()
    {
        StartCoroutine(StartLoading());
    }
}

A

Loading: 20%
Loading: 40%
Loading: 60%
Loading: 80%
Loading: 100%
Loading Complete!

B

Loading: 20%
Loading: 40%
Loading: 60%
Loading: 80%
Loading: 100%

C

Loading: 0%
Loading: 20%
Loading: 40%
Loading: 60%
Loading: 80%
Loading: 100%
Loading Complete!

D

Loading: 20%
Loading: 40%
Loading: 60%
Loading: 80%
Loading Complete!

💡 Hint

Check how the progress variable changes inside the loop and when the final message is printed.

The coroutine increases progress by 20 each loop until it reaches 100. It prints each progress step and finally prints "Loading Complete!" after the loop.

🧠 Conceptual

intermediate

Which statement about Unity coroutines and loading screens is true?

Choose the correct statement about using coroutines for loading screens in Unity.

A Coroutines allow asynchronous operations without freezing the main thread.

B Coroutines run on a separate thread and block the main thread until complete.

C Coroutines automatically display a loading screen UI without extra code.

D Coroutines cannot be stopped once started.

💡 Hint

Think about how coroutines help keep the game responsive during loading.

Coroutines run on the main thread but pause execution to allow other code to run, enabling asynchronous behavior without freezing the game.

🔧 Debug

advanced

Why does this loading coroutine never finish?

Examine the coroutine below. It is supposed to simulate loading progress but never prints "Loading Complete!". What is the cause?

Unity

IEnumerator LoadScene()
{
    float progress = 0f;
    while (progress <= 1f)
    {
        progress += 0.2f;
        Debug.Log($"Progress: {progress * 100}%");
        yield return new WaitForSeconds(0.5f);
    }
    Debug.Log("Loading Complete!");
}

A The coroutine is missing a yield return null statement inside the loop.

B The loop condition should be progress < 1f instead of <= 1f to avoid infinite loop.

C The progress variable is a float and adding 0.2f causes floating point precision errors preventing loop exit.

D The Debug.Log statement inside the loop causes the coroutine to freeze.

💡 Hint

Consider how floating point numbers behave when incremented repeatedly.

Floating point precision can cause progress to never exactly exceed 1.0, so the loop condition remains true indefinitely.

📝 Syntax

advanced

Which option correctly defines a coroutine for a loading screen?

Identify the correct syntax for a Unity coroutine that waits 1 second and then prints "Done Loading".

A

IEnumerator Load() {
    yield return WaitForSeconds(1);
    Debug.Log("Done Loading");
}

B

void Load() {
    yield return new WaitForSeconds(1);
    Debug.Log("Done Loading");
}

C

IEnumerator Load() {
    yield WaitForSeconds(1);
    Debug.Log("Done Loading");
}

D

IEnumerator Load() {
    yield return new WaitForSeconds(1);
    Debug.Log("Done Loading");
}

💡 Hint

Remember the correct way to yield a WaitForSeconds in a coroutine.

The correct syntax uses 'yield return new WaitForSeconds(1);' inside an IEnumerator method.

🚀 Application

expert

How to update a UI loading bar smoothly with a coroutine?

You want to update a UI loading bar fill amount smoothly from 0 to 1 over 3 seconds using a coroutine. Which code snippet achieves this?

Unity

using UnityEngine;
using UnityEngine.UI;

public class LoadingBar : MonoBehaviour
{
    public Image loadingBar;

    IEnumerator FillBar()
    {
        float elapsed = 0f;
        while (elapsed < 3f)
        {
            loadingBar.fillAmount = elapsed / 3f;
            elapsed += Time.deltaTime;
            yield return null;
        }
        loadingBar.fillAmount = 1f;
    }
}

A

IEnumerator FillBar() {
    float elapsed = 0f;
    while (elapsed < 3f) {
        loadingBar.fillAmount = elapsed / 3f;
        elapsed += Time.deltaTime;
        yield return new WaitForSeconds(0.1f);
    }
    loadingBar.fillAmount = 1f;
}

B

IEnumerator FillBar() {
    float elapsed = 0f;
    while (elapsed <= 3f) {
        loadingBar.fillAmount = elapsed / 3f;
        elapsed += Time.deltaTime;
        yield return null;
    }
    loadingBar.fillAmount = 1f;
}

C

IEnumerator FillBar() {
    float elapsed = 0f;
    while (elapsed < 3f) {
        loadingBar.fillAmount = elapsed * 3f;
        elapsed += Time.deltaTime;
        yield return null;
    }
    loadingBar.fillAmount = 1f;
}

D

IEnumerator FillBar() {
    float elapsed = 0f;
    while (elapsed < 3f) {
        loadingBar.fillAmount = 1f - (elapsed / 3f);
        elapsed += Time.deltaTime;
        yield return null;
    }
    loadingBar.fillAmount = 1f;
}

💡 Hint

Think about the condition to stop the loop and how to calculate fill amount as a fraction of elapsed time.

Option B correctly updates fillAmount from 0 to 1 over 3 seconds using elapsed/3f and stops when elapsed exceeds 3 seconds.

Practice

1. What is the main purpose of using coroutines for loading screens in Unity?

easy

A. To run loading tasks without freezing the game UI

B. To speed up the loading process by using multiple threads

C. To automatically optimize game assets during loading

D. To replace the Update() method for all game logic

Solution

1. Step 1: Understand coroutine behavior

   Coroutines allow tasks to run over multiple frames without blocking the main thread.

2. Step 2: Relate to loading screens

   Using coroutines for loading lets the UI remain responsive and update progress smoothly.

3. Final Answer:

   To run loading tasks without freezing the game UI -> Option A

4. Quick Check:

   Coroutines keep UI responsive during loading = A [OK]

Hint: Coroutines prevent freezing by spreading work over frames [OK]

Common Mistakes:

• Thinking coroutines run on separate threads
• Believing coroutines speed up loading automatically
• Confusing coroutines with Update() method

2. Which of the following is the correct way to start a coroutine named LoadSceneAsync in Unity?

easy

A. StartCoroutine(LoadSceneAsync());

B. StartCoroutine(LoadSceneAsync);

C. StartCoroutine("LoadSceneAsync");

D. StartCoroutine.LoadSceneAsync();

Solution

1. Step 1: Recall coroutine syntax

   Coroutines are started by calling StartCoroutine with the IEnumerator method invoked, like StartCoroutine(MethodName()).

2. Step 2: Check options

   StartCoroutine(LoadSceneAsync()); correctly calls StartCoroutine with LoadSceneAsync() including parentheses.

3. Final Answer:

   StartCoroutine(LoadSceneAsync()); -> Option A

4. Quick Check:

   StartCoroutine needs method call with parentheses = A [OK]

Hint: StartCoroutine requires parentheses to call the IEnumerator method [OK]

Common Mistakes:

• Omitting parentheses when calling the coroutine method
• Using string names instead of method calls
• Trying to call coroutine like a normal method

3. Given this coroutine code snippet, what will be printed to the console?

IEnumerator LoadScene()
{
    AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("GameScene");
    while (!asyncLoad.isDone)
    {
        Debug.Log($"Loading progress: {asyncLoad.progress * 100}%");
        yield return null;
    }
    Debug.Log("Loading complete!");
}

medium

A. Loading progress: 0% ... Loading progress: 100% ... Loading complete!

B. Loading progress: 0% ... Loading progress: 50% ... Loading complete!

C. Loading progress: 0% ... Loading progress: 90% ... Loading complete!

D. Only "Loading complete!" is printed

Solution

1. Step 1: Understand AsyncOperation progress

   AsyncOperation.progress goes from 0 to 0.9 during loading; it reaches 0.9 before isDone becomes true.

2. Step 2: Analyze the loop output

   The loop prints progress from 0% up to 90%, then exits when isDone is true, printing "Loading complete!".

3. Final Answer:

   Loading progress: 0% ... Loading progress: 90% ... Loading complete! -> Option C

4. Quick Check:

   AsyncOperation.progress maxes at 0.9 before done = C [OK]

Hint: AsyncOperation.progress maxes at 0.9 before completion [OK]

Common Mistakes:

• Assuming progress reaches 100% before isDone
• Expecting progress to jump directly to 100%
• Ignoring that isDone triggers after 90% progress

4. Identify the error in this coroutine code for a loading screen:

IEnumerator LoadLevel()
{
    AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Level1");
    while (asyncLoad.isDone == false)
    {
        progressBar.fillAmount = asyncLoad.progress;
        yield return new WaitForSeconds(1);
    }
}

medium

A. AsyncOperation.progress should be multiplied by 100

B. The while loop condition should be asyncLoad.isDone == true

C. The coroutine never yields control to the main thread

D. Using WaitForSeconds delays UI updates unnecessarily

Solution

1. Step 1: Check yield statement impact

   Using yield return new WaitForSeconds(1) pauses the coroutine for 1 second each loop, causing slow UI updates.

2. Step 2: Suggest better yield usage

   Yielding null (yield return null) updates every frame, making progress bar smoother and more responsive.

3. Final Answer:

   Using WaitForSeconds delays UI updates unnecessarily -> Option D

4. Quick Check:

   WaitForSeconds slows progress updates = B [OK]

Hint: Use yield return null for smooth frame-by-frame updates [OK]

Common Mistakes:

• Confusing progress value scale
• Changing loop condition incorrectly
• Not yielding at all causing freeze

5. You want to create a loading screen that shows a progress bar and a "Loading..." text that updates smoothly while loading a scene asynchronously. Which approach correctly combines coroutines and UI updates?

hard

A. Load the scene synchronously and update UI after loading finishes

B. Start a coroutine that updates progressBar.fillAmount with asyncLoad.progress every frame and updates loadingText with percentage until asyncLoad.isDone is true

C. Start a coroutine that waits 5 seconds then sets progressBar.fillAmount to 1 and loadingText to "Done"

D. Use Update() method to check asyncLoad.progress and update UI, no coroutine needed

Solution

1. Step 1: Understand asynchronous loading with UI updates

   Using a coroutine to check asyncLoad.progress each frame allows smooth progress bar and text updates during loading.

2. Step 2: Evaluate options for UI responsiveness

   Start a coroutine that updates progressBar.fillAmount with asyncLoad.progress every frame and updates loadingText with percentage until asyncLoad.isDone is true correctly updates UI every frame until loading completes; other options either block UI or do not update smoothly.

3. Final Answer:

   Start a coroutine that updates progressBar.fillAmount with asyncLoad.progress every frame and updates loadingText with percentage until asyncLoad.isDone is true -> Option B

4. Quick Check:

   Coroutine + frame updates = smooth loading UI = D [OK]

Hint: Update UI inside coroutine each frame until loading completes [OK]

Common Mistakes:

• Using synchronous loading blocking UI
• Not updating UI every frame
• Waiting fixed time instead of checking progress