使用协程统一暂停函数的执行

Question

我正在尝试在 untiy 中实现行为树，现在我正在为每个节点/复合/动作使用 Tick() 函数

我要做的是按顺序排列，例如：

1. 开始循环遍历节点列表

2. 在当前节点启动tick函数

3. 等到节点tick返回失败/成功

4. 转到下一个节点，继续进行第1步

   我遇到的问题与第 3 步有关。我正在尝试使用协程来完成此操作。

问题在于断言为真，nodeStat var 为 None。当 WaitFor Seconds 被执行时，控制返回到Debug.Assert(nodeStat != Status.None); 行

public class Sequence : Composite
{
    protected override void Start()
    {
        status = Status.Running;
    }
    Status nodeStat = Status.None;
    IEnumerator Recursive(Node nod)
    {
        while (true)
        {
            Debug.Log(nod + "is running");
            Status status = nod.Tick();

            Debug.Log(Time.time + " " + status);
            if (status == Status.Running)
            {
                Debug.Log("start coroutine at : " + Time.time);
                yield return new WaitForSeconds(0.2f);
                Debug.Log("Comtinue coroutine at : " + Time.time);
            }
            else
            {

                Debug.Log("has finished coroutine");
                nodeStat = status;
                break;
            }
        }
    }
    protected override Status Execute()
    {
        foreach(Node nod in ListaNoduri)
        {
            GameManager.Instance.StartCoroutine(Recursive(nod));
            Debug.Assert(nodeStat != Status.None);
            if (nodeStat == Status.Failure)
                return Status.Failure;
        }
        return Status.Success;
    }

    protected override void Exit()
    {
        base.Exit();
    }
    public override Status Tick()
    {
        //Debug.Log(status);
        return base.Tick();
    }
}

Answer 1

考虑将Execute() 设为协程：

IEnumerator Execute()
{
    foreach(Node nod in ListaNoduri)
    {
        //wait for the current node to be done before continuing
        yield return GameManager.Instance.StartCoroutine(Recursive(nod));
        Debug.Assert(nodeStat != Status.None);
        if (nodeStat == Status.Failure){
            //do something on failure 
            yield break;
        }
    }
    //do something on success
}

Answer 2

请记住，协程的工作方式类似于线程（异步执行）。

请注意，作为 cmets 上的 @akaBase 点，问题是您在调用协程后才评估 nodeStat，而不是等待协程完成。

因此，您正在调度多个异步调用（每个节点一个），但您并没有等待所有这些调用。

一种方法可能是在递归中断之前添加一个事件/委托/动作，您存储一个节点的结果，然后在另一个协程（应该是您当前的执行）上评估，如果某个委托是false，结果为假。

类似：

    private List<bool> nodeExecutionResultsList = new List<bool>();
    private Status statusResult = Status.Failure;
    private Action OnAllNodesEnd = null;

    protected override void Execute()
    {
        OnAllNodesEnd = () => { Debug.Log("Every Node Ends!"); };
        foreach (Node nod in ListaNoduri)
        {
            GameManager.Instance.StartCoroutine(Recursive(nod));            
        }
    }

    IEnumerator Recursive(Node nod)
    {
        while (true)
        {
            Debug.Log(nod + "is running");
            Status status = nod.Tick();

            Debug.Log(Time.time + " " + status);
            if (status == Status.Running)
            {
                Debug.Log("start coroutine at : " + Time.time);
                yield return new WaitForSeconds(0.2f);
                Debug.Log("Comtinue coroutine at : " + Time.time);
            }
            else
            {

                Debug.Log("has finished coroutine");
                nodeStat = status;
                //Do the assert NOW, and register on the list the result
                Debug.Assert(nodeStat != Status.None);
                nodeExecutionResult.Add(nodeStat == Status.Failure);
                break;
            }
        }
    }

    private IEnumerator EvaluateAllNodes()
    {
        while(evaluating)
        {
            //there are the same number of results as nodes
            if(nodeExecutionResultsList.Count == ListaNoduri.Count)
            {
                //check if someone fails
                statusResult = (nodeExecutionResult.Contains(false)) ? Status.Failure : Status.Success;
            }
        }
        OnAllNodesEnd?.Invoke();
    }