如何在IEnumerator中等待或等待，然后继续协程？

Question

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

public class NaviConversations : MonoBehaviour
{
    public ObjectsManipulation op;
    public Scaling scaling;
    public ConversationTrigger conversationTrigger;

    private void Update()
    {
        if (DOFControl.hasFinished == true)
        {
            ConversationTrigger.conversationsToPlay.Add(0);
            StartCoroutine(NaviScaling());
            DOFControl.hasFinished = false;
        }
    }

    public IEnumerator NaviScaling()
    {
        // Scaling Up
        if (scaling.objectToScale.transform.localScale == scaling.minSize)
        {
            op.Scaling();
        }
        yield return new WaitUntil

        op.Scaling();
    }
}

At this part :

yield return new WaitUntil

I want to wait for the scaled object to finish scaling :

scaling.objectToScale.transform.localScale == scaling.maxSize

When this is true then continue the continue and do :

conversationTrigger.PlayConversations();

Then wait again until :

conversationTrigger.conversationEnd

Is true.

If it's true scale down back :

op.Scaling();

The steps should be :

1. Add the conversation index to play.

2. Scale up. And wait for the scaling up to finish.

3. Start conversations. And wait for the conversation/s to end.

4. Scale down.

I'm trying to find the easiest wait to do it and a way that I can call the method public IEnumerator NaviScaling() from anywhere.

The part in the update :

if (DOFControl.hasFinished == true)

Is happens once when the game start.

This is the script that the op.Scaling is using :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjectsManipulation : UnityEngine.MonoBehaviour
{
    //Camera
    public Camera playerCamera;

    //Scaling
    public bool canScale = true;
    private Scaling scaling;

    //Lights
    public DimLights dimlights;
    private Coroutine lightCoroutine;

    //Colors
    private Colors colors;

    //Rotating
    public bool stopRotation = false;
    private Rotating rotating;

    private void Start()
    {
        scaling = GetComponent<Scaling>();
        scaling.Inits();

        colors = GetComponent<Colors>();
        colors.Start();

        rotating = GetComponent<Rotating>();
    }

    // Use this for initialization
    void Update()
    {
        if (playerCamera != null)
        {
            //Scaling
            if (Input.GetKeyDown(KeyCode.F) && canScale == true)
            {
                Scaling();
            }
        }

        //Rotate
        if (Input.GetKey(KeyCode.R) && !scaling.scaleUp)
        {
            rotating.x += Time.deltaTime * rotating.rotationSpeed;
            scaling.objectToScale.transform.localRotation = Quaternion.Euler(0, 0, rotating.x);
            rotating.keyPressed = true;
        }
        if (Input.GetKeyUp(KeyCode.R))
        {
            rotating.keyPressed = false;
        }

        if (!rotating.keyPressed && !scaling.scaleUp && rotating.rotateBack == false
            && DetectInteractable.detected == false)
        {
            scaling.objectToScale.transform.rotation = Quaternion.LookRotation(playerCamera.transform.forward);
        }

        if (DetectInteractable.detected == true && !scaling.scaleUp && stopRotation == false)
        {
            rotating.x += Time.deltaTime * rotating.rotationSpeed;
            scaling.objectToScale.transform.localRotation = Quaternion.Euler(0, 0, rotating.x);
        }
    }

    public void Scaling()
    {
        //Flip the scale direction when F key is pressed
        scaling.scaleUp = !scaling.scaleUp;

        //Stop old coroutine
        if (scaling.scaleCoroutine != null)
            StopCoroutine(scaling.scaleCoroutine);

        if (lightCoroutine != null)
            StopCoroutine(lightCoroutine);


        //Scale  up
        if (scaling.scaleUp)
        {
            //Start new coroutine and scale up within 5 seconds and return the coroutine reference
            rotating.rotateBack = false;
            scaling.scaleCoroutine = StartCoroutine(scaling.scaleOverTime(scaling.objectToScale, scaling.maxSize, scaling.duration, playerCamera));
            if (dimlights.lightsOnOff == false)
                lightCoroutine = StartCoroutine(dimlights.dimLightOverTime(1, scaling.duration));
        }

        //Scale Down
        else
        {
            //Start new coroutine and scale up within 5 seconds and return the coroutine reference
            rotating.rotateBack = true;
            scaling.scaleCoroutine = StartCoroutine(scaling.scaleOverTime(scaling.objectToScale, scaling.minSize, scaling.duration, playerCamera));
            if (dimlights.lightsOnOff == false)
                lightCoroutine = StartCoroutine(dimlights.dimLightOverTime(0, scaling.duration)); ;
        }
    }
}

Answer 1

To use WaitUntil , you will need to provide a way for it to check the condition that it is waiting for. This is done by passing a delegate into its constructor.

So to wait while your object is still scaling, you would do something like this:

yield return new WaitUntil(() => scaling.objectToScale.transform.localScale == scaling.minSize);

Note the () => before the condition, this turns your expression into an anonymous function which allows the WaitUntil to reevaluate the condition on each frame.

You can also pass a method as the delegate which reads pretty nicely!

private bool IsFinishedScaling () {
    return scaling.objectToScale.transform.localScale == scaling.minSize;
}

public IEnumerator Example () {
    yield return new WaitUntil(IsFinishedScaling);
    Debug.Log("Scaling has finished!");
}

Answer 2

This should do what you're looking for:

public IEnumerator NaviScaling()
{
    if (scaling.objectToScale.transform.localScale == scaling.minSize)
    {
        op.Scaling();
    }

    while (scaling.objectToScale.transform.localScale != scaling.maxSize)
    {
        yield return null;
    }

    conversationTrigger.PlayConversations();

    while (!conversationTrigger.conversationEnd)
    {
        yield return null;
    }

    op.Scaling();
}

Answer 3

I'm not quite happy with the so far given answers.

Basically the question was how to use WaitUntil which wasn't even used by the accepted answer (which by the way provided a really messi code..)

The reason why the other still could be extended is that both answer are based on using == for checking the equality. For Vector3 however this simply assumes that

Vector3.Distance(vectorA, vectorB) <= 0.00001f

This is usually great for distances between positions but for scales you might rather want more exact values.

If that's the goal and you don't need it to be more exact than stick with it.

Otherwise I would make the check rather using Mathf.Approximately eg as an extension method like

public static class Vector3Extensio s
{
    public static bool IsSameValue(this Vector3 a, Vector3 b)
    {
        return Mathf.Approximately(Vector3.Distance(a,b), 0f);
    }
}

And than use

yield return new WaitUntil(() => scaling.objectToScale.transform.localScale.IsSameValue(scaling.maxSize));

Ofcourse this depends a lot on how op.Scaling works which you don't show.

---

Alternatively: (and I would prefer that)

Unfortunately you didn't show what op.Scaling() does. The easiest way would actually be to make it an IEnumerator as well since you can simply yield return another IEnumerator which makes it execute and automatically wait until it finishes in only one line.

So let's say you make the op.Scaling something like eg

public IEnumerator Scaling(Vector3 targetScale, float duration)
{
    // Get current scale
    var startScale = transform.localScale;

    var timePassed = 0f;
    do
    {
        transform.localScale = Vector3.Lerp(startScale, targetScale, timePassed / duration);

        timePassed += Time.deltaTime;

        yield return null;
    } while(timePassed <= duration);

    transform.localScale = targetScale;
}

You could simply do

public IEnumerator NaviScaling()
{
    // Scale up in 1 second and wait
    yield return op.Scaling(scaling.maxSize, 1f);

    // As you can see again this could be a Coroutine so you could directly yield it
    // instead of having to wait for the bool value to turn true
    conversationTrigger.PlayConversations();

    yield return new WaitUntil(() => conversationTrigger.conversationEnd);

    // Scale down in 1 second and wait
    yield return op.Scaling(scaling.minSize, 1f);
}