Comprehensive Guide to Wait and Delay Methods in Unity

Fundamental Implementation with Coroutines and WaitForSeconds

In Unity game development, the most straightforward approach to implement waiting functionality involves using coroutines combined with the WaitForSeconds class. Coroutines enable pausing function execution and resuming after specified durations, perfectly addressing the need to insert delays between sequential operations.

The following example demonstrates inserting 3-second delays between text displays:

IEnumerator ShowTextSequence()
{
    TextUI.text = "Welcome to Number Wizard!";
    yield return new WaitForSeconds(3f);
    TextUI.text = "The highest number you can pick is " + max;
    yield return new WaitForSeconds(3f);
    TextUI.text = "The lowest number you can pick is " + min;
}

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

The crucial aspect is that code containing yield return statements must be encapsulated within methods returning IEnumerator and initiated via StartCoroutine. This approach doesn't block the main thread, ensuring other game components like user input and physics simulation continue functioning normally.

Real-time Waiting and Game Pause Handling

When games require pause state management, WaitForSecondsRealtime offers a superior solution. Unlike WaitForSeconds which uses scaled game time, WaitForSecondsRealtime operates based on real time and remains unaffected by Time.timeScale adjustments.

IEnumerator PauseAwareWait()
{
    // Perform some operations
    transform.Rotate(new Vector3(90, 0, 0));
    
    // Wait for 4 seconds (real time)
    yield return new WaitForSecondsRealtime(4);
    
    // Continue with subsequent operations
    transform.Rotate(new Vector3(40, 0, 0));
}

This characteristic proves particularly valuable for implementing in-game menus, pause interfaces, or features requiring synchronization with system time.

Interruptible Precision Timers

For waiting scenarios requiring precise control or potential interruption, custom timers based on Time.deltaTime provide optimal flexibility. This method enables execution of additional logic during waiting periods and incorporates interruption mechanisms.

bool shouldQuit = false;

IEnumerator CustomTimer(float waitTime)
{
    float elapsed = 0;
    
    while (elapsed < waitTime)
    {
        if (shouldQuit)
        {
            yield break; // Early coroutine termination
        }
        
        elapsed += Time.deltaTime;
        Debug.Log("We have waited for: " + elapsed + " seconds");
        yield return null; // Wait until next frame
    }
    
    // Operations after waiting completion
    ExecuteAfterWait();
}

This approach's advantage lies in its capacity to update UI displays showing remaining time during waiting periods or prematurely terminate waits based on specific conditions.

Conditional Waiting: WaitUntil and WaitWhile

Unity provides two condition-based waiting methods: WaitUntil resumes execution when conditions become true, while WaitWhile maintains waiting while conditions remain true.

// Wait until player score reaches target
IEnumerator WaitForScore()
{
    yield return new WaitUntil(() => playerScore >= 100);
    LoadNextLevel();
}

// Wait while exit key remains unpressed
IEnumerator WaitForExit()
{
    yield return new WaitWhile(() => !Input.GetKeyDown(KeyCode.Escape));
    QuitApplication();
}

These methods prove especially suitable for event-driven scenarios such as awaiting user input, resource loading completion, or game state changes.

Alternative Approaches: Invoke Method and Update Function

Beyond coroutines, Unity offers the Invoke method for simple delayed invocation:

void Start()
{
    Invoke("DelayedAction", 2.5f);
}

void DelayedAction()
{
    Debug.Log("Executed after 2.5 seconds delay");
}

For basic timing requirements, implementation within the Update function remains viable:

float timer = 0;
bool actionExecuted = false;

void Update()
{
    if (!actionExecuted)
    {
        timer += Time.deltaTime;
        
        if (timer >= 3.0f)
        {
            ExecuteDelayedAction();
            actionExecuted = true;
        }
    }
}

Method Selection and Best Practices

Selecting appropriate waiting methods requires consideration of multiple factors:

• Simple Delays: Utilize WaitForSeconds coroutines
• Pause Compatibility: Choose WaitForSecondsRealtime
• Precise Control: Employ custom timers based on Time.deltaTime
• Condition Triggering: Use WaitUntil or WaitWhile
• Simple Invocation: Consider Invoke method

In practical development, coroutine methods emerge as the most frequently used solution due to their flexibility and ease of use. However, careful attention must be paid to coroutine lifecycle management to prevent errors caused by continued coroutine execution after object destruction.

Through judicious selection and application of these waiting techniques, developers can create responsive Unity applications with superior user experiences.