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.