[C++/UE] UE5中AI開發的一點功能梳理（二） – 行為樹Composite類型節點說明

//BTComposite_SimpleParallel.cpp
/**
 * Simple Parallel composite node.
 * Allows for running two children: one which must be a single task node (with optional decorators), and the other of which can be a complete subtree.
 */
int32 UBTComposite_SimpleParallel::GetNextChildHandler(FBehaviorTreeSearchData& SearchData, int32 PrevChild, EBTNodeResult::Type LastResult) const
{
    FBTParallelMemory* MyMemory = GetNodeMemory<FBTParallelMemory>(SearchData);
    int32 NextChildIdx = BTSpecialChild::ReturnToParent;

    if (PrevChild == BTSpecialChild::NotInitialized)
    {
        NextChildIdx = EBTParallelChild::MainTask;
        MyMemory->MainTaskResult = EBTNodeResult::Failed;
        MyMemory->bRepeatMainTask = false;
    }
    else if ((MyMemory->bMainTaskIsActive || MyMemory->bForceBackgroundTree) && !SearchData.OwnerComp.IsRestartPending())
    {
        // if main task is running - always pick background tree
        // unless search is from abort from background tree - return to parent (and break from search when node gets deactivated)
        NextChildIdx = EBTParallelChild::BackgroundTree;
        MyMemory->bForceBackgroundTree = false;
    }
    else if (MyMemory->bRepeatMainTask)
    {
        UE_VLOG(SearchData.OwnerComp.GetOwner(), LogBehaviorTree, Verbose, TEXT("Repeating main task of %s"), *UBehaviorTreeTypes::DescribeNodeHelper(this));
        NextChildIdx = EBTParallelChild::MainTask;
        MyMemory->bRepeatMainTask = false;
    }

    if ((PrevChild == NextChildIdx) && (MyMemory->LastSearchId == SearchData.SearchId))
    {
        // retrying the same branch again within the same search - possible infinite loop
        SearchData.bPostponeSearch = true;
    }

    MyMemory->LastSearchId = SearchData.SearchId;
    return NextChildIdx;
}

void UBTComposite_SimpleParallel::NotifyChildExecution(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, int32 ChildIdx, EBTNodeResult::Type& NodeResult) const
{
    FBTParallelMemory* MyMemory = (FBTParallelMemory*)NodeMemory;
    if (ChildIdx == EBTParallelChild::MainTask)
    {
        MyMemory->MainTaskResult = NodeResult;

        if (NodeResult == EBTNodeResult::InProgress)
        {
            EBTTaskStatus::Type Status = OwnerComp.GetTaskStatus(Children[EBTParallelChild::MainTask].ChildTask);
            if (Status == EBTTaskStatus::Active)
            {
                // can't register if task is currently being aborted (latent abort returns in progress)

                MyMemory->bMainTaskIsActive = true;
                MyMemory->bForceBackgroundTree = false;
                
                OwnerComp.RegisterParallelTask(Children[EBTParallelChild::MainTask].ChildTask);
                RequestDelayedExecution(OwnerComp, EBTNodeResult::Succeeded);
            }
        }
        else if (MyMemory->bMainTaskIsActive)
        {
            MyMemory->bMainTaskIsActive = false;
            
            // notify decorators on main task, ignore observers updates in FakeSearchData - they are not allowed by parallel composite
            FBehaviorTreeSearchData FakeSearchData(OwnerComp);
            NotifyDecoratorsOnDeactivation(FakeSearchData, ChildIdx, NodeResult, true /*bIsRequestInSameInstance*/);

            const int32 MyInstanceIdx = OwnerComp.FindInstanceContainingNode(this);

            // use check() here not IntCastChecked() as MyInstanceIdx can be INDEX_NONE!
            check(MyInstanceIdx < MAX_uint16);
            OwnerComp.UnregisterParallelTask(Children[EBTParallelChild::MainTask].ChildTask, static_cast<uint16>(MyInstanceIdx));
            if (NodeResult != EBTNodeResult::Aborted && !MyMemory->bRepeatMainTask)
            {
                // check if subtree should be aborted when task finished with success/failed result
                if (FinishMode == EBTParallelMode::AbortBackground)
                {
                    OwnerComp.RequestExecution((UBTCompositeNode*)this, MyInstanceIdx,
                        Children[EBTParallelChild::MainTask].ChildTask, EBTParallelChild::MainTask,
                        NodeResult);
                }
            }
        }
        else if (NodeResult == EBTNodeResult::Succeeded && FinishMode == EBTParallelMode::WaitForBackground)
        {
            // special case: if main task finished instantly, but composite is supposed to wait for background tree,
            // request single run of background tree anyway

            MyMemory->bForceBackgroundTree = true;

            RequestDelayedExecution(OwnerComp, EBTNodeResult::Succeeded);
        }
    }
}

void UBTComposite_SimpleParallel::NotifyNodeDeactivation(FBehaviorTreeSearchData& SearchData, EBTNodeResult::Type& NodeResult) const
{
    FBTParallelMemory* MyMemory = GetNodeMemory<FBTParallelMemory>(SearchData);
    const uint16 ActiveInstanceIdx = SearchData.OwnerComp.GetActiveInstanceIdx();

    // modify node result if main task has finished
    if (!MyMemory->bMainTaskIsActive)
    {
        NodeResult = MyMemory->MainTaskResult;
    }

    // remove main task
    if (Children.IsValidIndex(EBTParallelChild::MainTask))
    {
        SearchData.AddUniqueUpdate(FBehaviorTreeSearchUpdate(Children[EBTParallelChild::MainTask].ChildTask, ActiveInstanceIdx, EBTNodeUpdateMode::Remove));
    }
}