BehaviorTreeComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "EngineDefines.h"
#include "BehaviorTree/BehaviorTreeTypes.h"
#include "GameplayTagContainer.h"
#include "AITypes.h"
#include "BrainComponent.h"
#include "ProfilingDebugging/CsvProfiler.h"
#include "BehaviorTreeComponent.generated.h"
 
class FBehaviorTreeDebugger;
class UBehaviorTree;
class UBTAuxiliaryNode;
class UBTCompositeNode;
class UBTDecorator;
class UBTNode;
class UBTTask_RunBehavior;
class UBTTask_RunBehaviorDynamic;
class UBTTaskNode;
 
struct FBTNodeExecutionInfo
{
    FBTNodeIndex SearchStart;
 
    FBTNodeIndex SearchEnd;
 
    TObjectPtr<const UBTCompositeNode> ExecuteNode;
 
    uint16 ExecuteInstanceIdx;
 
    TEnumAsByte<EBTNodeResult::Type> ContinueWithResult;
 
    uint8 bTryNextChild : 1;
 
    uint8 bIsRestart : 1;
 
    FBTNodeExecutionInfo() : ExecuteNode(NULL), bTryNextChild(false), bIsRestart(false) { }
};
 
struct FBTPendingExecutionInfo
{
    TObjectPtr<UBTTaskNode> NextTask;
 
    uint32 bOutOfNodes : 1;
 
    uint32 bLocked : 1;
 
    FBTPendingExecutionInfo() : NextTask(NULL), bOutOfNodes(false), bLocked(false) {}
    bool IsSet() const { return (NextTask || bOutOfNodes) && !bLocked; }
    bool IsLocked() const { return bLocked; }
 
    void Lock() { bLocked = true; }
    void Unlock() { bLocked = false; }
};
 
struct FBTTreeStartInfo
{
    UBehaviorTree* Asset;
    EBTExecutionMode::Type ExecuteMode;
    uint8 bPendingInitialize : 1;
 
    FBTTreeStartInfo() : Asset(nullptr), ExecuteMode(EBTExecutionMode::Looped), bPendingInitialize(0) {}
    bool IsSet() const { return Asset != nullptr; }
    bool HasPendingInitialize() const { return bPendingInitialize && IsSet(); }
};
 
enum class EBTBranchAction : uint16
{
    None = 0x0,
    DecoratorEvaluate = 0x1,
    DecoratorActivate_IfNotExecuting = 0x2,
    DecoratorActivate_EvenIfExecuting = 0x4,
    DecoratorActivate = DecoratorActivate_IfNotExecuting | DecoratorActivate_EvenIfExecuting,
    DecoratorDeactivate = 0x8,
    UnregisterAuxNodes = 0x10,
    StopTree_Safe = 0x20,
    StopTree_Forced = 0x40,
    ActiveNodeEvaluate = 0x80,
    SubTreeEvaluate = 0x100,
    ProcessPendingInitialize = 0x200,
    Cleanup = 0x400,
    UninitializeComponent = 0x800,
    StopTree = StopTree_Safe | StopTree_Forced,
    Changing_Topology_Actions = UnregisterAuxNodes | StopTree | ProcessPendingInitialize | Cleanup | UninitializeComponent,
    All = DecoratorEvaluate | DecoratorActivate_IfNotExecuting | DecoratorActivate_EvenIfExecuting | DecoratorDeactivate | Changing_Topology_Actions | ActiveNodeEvaluate | SubTreeEvaluate,
};
ENUM_CLASS_FLAGS(EBTBranchAction);
 
UCLASS(ClassGroup = AI, meta = (BlueprintSpawnableComponent), MinimalAPI)
class UBehaviorTreeComponent : public UBrainComponent
{
    GENERATED_UCLASS_BODY()
 
    // UActorComponent overrides
    AIMODULE_API virtual void RegisterComponentTickFunctions(bool bRegister) override;
    AIMODULE_API virtual void SetComponentTickEnabled(bool bEnabled) override;
 
    // Begin UBrainComponent overrides
    AIMODULE_API virtual void StartLogic() override;
    AIMODULE_API virtual void RestartLogic() override;
    AIMODULE_API virtual void StopLogic(const FString& Reason) override;
    AIMODULE_API virtual void PauseLogic(const FString& Reason) override;
    AIMODULE_API virtual EAILogicResuming::Type ResumeLogic(const FString& Reason) override;
 
    AIMODULE_API bool TreeHasBeenStarted() const;
 
public:
    AIMODULE_API UBehaviorTreeComponent(FVTableHelper& Helper);
 
    AIMODULE_API virtual bool IsRunning() const override;
    AIMODULE_API virtual bool IsPaused() const override;
    AIMODULE_API virtual void Cleanup() override;
    AIMODULE_API virtual void HandleMessage(const FAIMessage& Message) override;
    // End UBrainComponent overrides
 
    // Begin UActorComponent overrides
    AIMODULE_API virtual void UninitializeComponent() override;
    // End UActorComponent overrides
 
    AIMODULE_API void StartTree(UBehaviorTree& Asset, EBTExecutionMode::Type ExecuteMode = EBTExecutionMode::Looped);
 
    AIMODULE_API void StopTree(EBTStopMode::Type StopMode = EBTStopMode::Safe);
 
    AIMODULE_API void RestartTree(EBTRestartMode RestartMode = EBTRestartMode::ForceReevaluateRootNode);
 
    AIMODULE_API void RequestExecution(const UBTCompositeNode* RequestedOn, const int32 InstanceIdx, 
        const UBTNode* RequestedBy, const int32 RequestedByChildIndex,
        const EBTNodeResult::Type ContinueWithResult, bool bStoreForDebugger = true);
 
    void RequestExecution(const UBTDecorator* RequestedBy) { check(RequestedBy); RequestBranchEvaluation(*RequestedBy); }
 
    void RequestExecution(EBTNodeResult::Type ContinueWithResult) { RequestBranchEvaluation(ContinueWithResult); }
 
    UE_DEPRECATED(5.0, "This function is deprecated. Please use RequestBranchDeactivation instead.")
    AIMODULE_API void RequestUnregisterAuxNodesInBranch(const UBTCompositeNode* Node);
 
    AIMODULE_API void RequestBranchEvaluation(EBTNodeResult::Type ContinueWithResult);
 
    AIMODULE_API void RequestBranchEvaluation(const UBTDecorator& RequestedBy);
 
    AIMODULE_API void RequestBranchActivation(const UBTDecorator& RequestedBy, const bool bRequestEvenIfExecuting);
 
    AIMODULE_API void RequestBranchDeactivation(const UBTDecorator& RequestedBy);
 
    AIMODULE_API void OnTaskFinished(const UBTTaskNode* TaskNode, EBTNodeResult::Type TaskResult);
 
    AIMODULE_API void RegisterMessageObserver(const UBTTaskNode* TaskNode, FName MessageType);
    AIMODULE_API void RegisterMessageObserver(const UBTTaskNode* TaskNode, FName MessageType, FAIRequestID MessageID);
    
    AIMODULE_API void UnregisterMessageObserversFrom(const UBTTaskNode* TaskNode);
    AIMODULE_API void UnregisterMessageObserversFrom(const FBTNodeIndex& TaskIdx);
 
    AIMODULE_API void RegisterParallelTask(const UBTTaskNode* TaskNode);
 
    AIMODULE_API void UnregisterParallelTask(const UBTTaskNode* TaskNode, uint16 InstanceIdx);
 
    AIMODULE_API void UnregisterAuxNodesUpTo(const FBTNodeIndex& Index);
 
    AIMODULE_API void UnregisterAuxNodesInRange(const FBTNodeIndex& FromIndex, const FBTNodeIndex& ToIndex);
 
    AIMODULE_API void UnregisterAuxNodesInBranch(const UBTCompositeNode* Node, bool bApplyImmediately = true);
 
    AIMODULE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    AIMODULE_API void ScheduleNextTick(float NextDeltaTime);
 
    AIMODULE_API void ProcessExecutionRequest();
 
    AIMODULE_API void ScheduleExecutionUpdate();
 
    AIMODULE_API int32 FindInstanceContainingNode(const UBTNode* Node) const;
 
    AIMODULE_API UBTNode* FindTemplateNode(const UBTNode* Node) const;
 
    UBehaviorTree* GetCurrentTree() const;
 
    UBehaviorTree* GetRootTree() const;
 
    const UBTNode* GetActiveNode() const;
    
    uint16 GetActiveInstanceIdx() const;
 
    AIMODULE_API uint8* GetNodeMemory(const UBTNode* Node, int32 InstanceIdx) const;
 
    bool IsRestartPending() const;
 
    bool IsAbortPending() const;
 
    AIMODULE_API bool IsExecutingBranch(const UBTNode* Node, int32 ChildIndex = -1) const;
 
    AIMODULE_API bool IsAuxNodeActive(const UBTAuxiliaryNode* AuxNode) const;
    AIMODULE_API bool IsAuxNodeActive(const UBTAuxiliaryNode* AuxNodeTemplate, int32 InstanceIdx) const;
 
    bool IsInstanceStackEmpty() const
    {
        return (InstanceStack.Num() == 0);
    }
 
    float GetAccumulatedTickDeltaTime() const
    {
        return AccumulatedTickDeltaTime;
    }
 
    AIMODULE_API EBTTaskStatus::Type GetTaskStatus(const UBTTaskNode* TaskNode) const;
 
    AIMODULE_API virtual FString GetDebugInfoString() const override;
    AIMODULE_API virtual FString DescribeActiveTasks() const;
    AIMODULE_API virtual FString DescribeActiveTrees() const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Logic")
    AIMODULE_API double GetTagCooldownEndTime(FGameplayTag CooldownTag) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Logic")
    AIMODULE_API void AddCooldownTagDuration(FGameplayTag CooldownTag, float CooldownDuration, bool bAddToExistingDuration);
 
    UFUNCTION(BlueprintCallable, Category="AI|Logic")
    AIMODULE_API virtual void SetDynamicSubtree(FGameplayTag InjectTag, UBehaviorTree* BehaviorAsset);
 
    AIMODULE_API virtual void SetDynamicSubtree(FGameplayTag InjectTag, UBehaviorTree* BehaviorAsset, UBTCompositeNode* OptionalStartingNode);
 
    AIMODULE_API void ForEachChildTask(TFunctionRef<void (UBTTaskNode&, const FBehaviorTreeInstance&, int32 InstanceIndex)> Functor);
 
    AIMODULE_API void ForEachChildTask(UBTCompositeNode& StartNode, int32 InstanceIndex, TFunctionRef<void(UBTTaskNode&, const FBehaviorTreeInstance&, int32 InstanceIndex)> Functor);
// Code for timing BT Search for FramePro
#if !UE_BUILD_SHIPPING
    static AIMODULE_API void EndFrame();
#endif
 
#if ENABLE_VISUAL_LOG
    AIMODULE_API virtual void DescribeSelfToVisLog(struct FVisualLogEntry* Snapshot) const override;
#endif
 
#if CSV_PROFILER_STATS
    void SetCSVTickStatName(const char* InCSVTickStatName) { CSVTickStatName = InCSVTickStatName; }
#endif
 
    static AIMODULE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
protected:
    TArray<FBehaviorTreeInstance> InstanceStack;
 
    TArray<FBehaviorTreeInstanceId> KnownInstances;
 
    UPROPERTY(transient)
    TArray<TObjectPtr<UBTNode>> NodeInstances;
 
    FBehaviorTreeSearchData SearchData;
 
    FBTNodeExecutionInfo ExecutionRequest;
 
    FBTPendingExecutionInfo PendingExecution;
 
    struct FBranchActionInfo
    {
        FBranchActionInfo(const EBTBranchAction InAction)
            : Action(InAction)
        {}
        FBranchActionInfo(const UBTNode* InNode, const EBTBranchAction InAction)
            : Node(InNode)
            , Action(InAction)
        {}
        FBranchActionInfo(const UBTNode* InNode, EBTNodeResult::Type InContinueWithResult, const EBTBranchAction InAction)
            : Node(InNode)
            , ContinueWithResult(InContinueWithResult)
            , Action(InAction)
        {}
        TObjectPtr<const UBTNode> Node = nullptr;
        EBTNodeResult::Type ContinueWithResult = EBTNodeResult::Succeeded;
        EBTBranchAction Action;
    };
 
    /* Type of suspended branch action */
    EBTBranchAction SuspendedBranchActions;
 
    TArray<FBranchActionInfo> PendingBranchActionRequests;
 
    FBTTreeStartInfo TreeStartInfo;
 
    TMultiMap<FBTNodeIndex,FAIMessageObserverHandle> TaskMessageObservers;
 
    TMap<FGameplayTag, double> CooldownTagsMap;
 
#if USE_BEHAVIORTREE_DEBUGGER
    mutable TArray<TArray<FBehaviorTreeDebuggerInstance::FNodeFlowData> > CurrentSearchFlow;
    mutable TArray<TArray<FBehaviorTreeDebuggerInstance::FNodeFlowData> > CurrentRestarts;
    mutable TMap<FName, FString> SearchStartBlackboard;
    mutable TArray<FBehaviorTreeDebuggerInstance> RemovedInstances;
 
    mutable TArray<FBehaviorTreeExecutionStep> DebuggerSteps;
 
    static AIMODULE_API int32 ActiveDebuggerCounter;
#endif
 
    // Code for timing BT Search for FramePro
#if !UE_BUILD_SHIPPING
    static AIMODULE_API bool bAddedEndFrameCallback;
    static AIMODULE_API double FrameSearchTime;
    static AIMODULE_API int32 NumSearchTimeCalls;
#endif
 
    uint16 ActiveInstanceIdx;
 
    uint8 bLoopExecution : 1;
 
    uint8 bWaitingForLatentAborts : 1;
 
    uint8 bRequestedFlowUpdate : 1;
 
    uint8 bRequestedStop : 1;
 
    uint8 bIsRunning : 1;
 
    uint8 bIsPaused : 1;
 
    AIMODULE_API bool PushInstance(UBehaviorTree& TreeAsset);
 
    AIMODULE_API uint8 UpdateInstanceId(UBehaviorTree* TreeAsset, const UBTNode* OriginNode, int32 OriginInstanceIdx);
 
    AIMODULE_API void RemoveAllInstances();
 
    AIMODULE_API void CopyInstanceMemoryToPersistent();
 
    AIMODULE_API void CopyInstanceMemoryFromPersistent();
 
    AIMODULE_API virtual void OnTreeFinished();
 
    AIMODULE_API void ApplySearchData(UBTNode* NewActiveNode);
 
    AIMODULE_API void ApplyDiscardedSearch();
 
    UE_DEPRECATED(5.4, "This function is deprecated. Please use ApplyAllSearchUpdates instead.")
    AIMODULE_API void ApplySearchUpdates(const TArray<FBehaviorTreeSearchUpdate>& UpdateList, int32 NewNodeExecutionIndex, bool bPostUpdate = false);
 
    AIMODULE_API void ApplyAllSearchUpdates(const TArray<FBehaviorTreeSearchUpdate>& UpdateList, int32 NewNodeExecutionIndex, bool bDoPostUpdate = true, bool bAllowTaskUpdates = true);
 
    AIMODULE_API void AbortCurrentTask();
 
    AIMODULE_API void ExecuteTask(UBTTaskNode* TaskNode);
 
    AIMODULE_API bool DeactivateUpTo(const UBTCompositeNode* Node, uint16 NodeInstanceIdx, EBTNodeResult::Type& NodeResult, int32& OutLastDeactivatedChildIndex);
 
    AIMODULE_API bool TrackPendingLatentAborts();
 
    AIMODULE_API void TrackNewLatentAborts();
 
    AIMODULE_API bool HasActiveLatentAborts() const;
 
    AIMODULE_API void ProcessPendingExecution();
 
    AIMODULE_API void ProcessPendingInitialize();
 
    AIMODULE_API void RollbackSearchChanges();
 
    AIMODULE_API void StoreDebuggerExecutionStep(EBTExecutionSnap::Type SnapType);
 
    AIMODULE_API void StoreDebuggerInstance(FBehaviorTreeDebuggerInstance& InstanceInfo, uint16 InstanceIdx, EBTExecutionSnap::Type SnapType) const;
    AIMODULE_API void StoreDebuggerRemovedInstance(uint16 InstanceIdx) const;
 
    AIMODULE_API void StoreDebuggerSearchStep(const UBTNode* Node, uint16 InstanceIdx, EBTNodeResult::Type NodeResult) const;
    AIMODULE_API void StoreDebuggerSearchStep(const UBTNode* Node, uint16 InstanceIdx, bool bPassed) const;
 
    AIMODULE_API void StoreDebuggerRestart(const UBTNode* Node, uint16 InstanceIdx, bool bAllowed);
 
    AIMODULE_API void StoreDebuggerBlackboard(TMap<FName, FString>& BlackboardValueDesc) const;
 
    AIMODULE_API void StoreDebuggerRuntimeValues(TArray<FString>& RuntimeDescriptions, UBTNode* RootNode, uint16 InstanceIdx) const;
 
    AIMODULE_API void UpdateDebuggerAfterExecution(const UBTTaskNode* TaskNode, uint16 InstanceIdx) const;
 
    static AIMODULE_API bool IsDebuggerActive();
 
    AIMODULE_API EBTNodeRelativePriority CalculateRelativePriority(const UBTNode* NodeA, const UBTNode* NodeB) const;
 
    AIMODULE_API void EvaluateBranch(EBTNodeResult::Type LastResult);
 
    AIMODULE_API void EvaluateBranch(const UBTDecorator& RequestedBy);
 
    AIMODULE_API void ActivateBranch(const UBTDecorator& RequestedBy, bool bRequestEvenIfNotExecuting);
 
    AIMODULE_API void DeactivateBranch(const UBTDecorator& RequestedBy);
 
    AIMODULE_API void SuspendBranchActions(EBTBranchAction BranchActions = EBTBranchAction::All);
 
    AIMODULE_API void ResumeBranchActions();
 
    UE_DEPRECATED(5.1, "This function is deprecated. Please use SuspendBranchActions instead.")
    void SuspendBranchDeactivation() { SuspendBranchActions(); }
 
    UE_DEPRECATED(5.1, "This function is deprecated. Please use ResumeBranchActions instead.")
    void ResumeBranchDeactivation() { ResumeBranchActions(); }
 
    struct FBTSuspendBranchActionsScoped
    {
        FBTSuspendBranchActionsScoped(UBehaviorTreeComponent& InBTComp, EBTBranchAction BranchActions = EBTBranchAction::All)
            : BTComp(InBTComp)
        {
            BTComp.SuspendBranchActions(BranchActions);
        }
        ~FBTSuspendBranchActionsScoped()
        {
            BTComp.ResumeBranchActions();
        }
        UBehaviorTreeComponent& BTComp;
    };
 
    void TickNewlyAddedAuxNodesHelper();
 
    UE_DEPRECATED(5.1, "This struct is deprecated. Please use FBTSuspendBranchActionsScoped instead.")
    typedef FBTSuspendBranchActionsScoped FBTSuspendBranchDeactivationScoped;
 
    friend UBTNode;
    friend UBTCompositeNode;
    friend UBTTaskNode;
    friend UBTTask_RunBehavior;
    friend UBTTask_RunBehaviorDynamic;
    friend FBehaviorTreeDebugger;
    friend FBehaviorTreeInstance;
 
private:
    void ApplySearchUpdatesImpl(const TArray<FBehaviorTreeSearchUpdate>& UpdateList, int32 NewNodeExecutionIndex, bool bPostUpdate, bool bAllowTaskUpdates);
 
protected:
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = AI)
    TObjectPtr<UBehaviorTree> DefaultBehaviorTreeAsset;
 
    bool bTickedOnce = false;
 
    float NextTickDeltaTime = 0.f;
 
    float AccumulatedTickDeltaTime = 0.f;
 
    float CurrentFrameDeltaTime = 0.f;
 
    double LastRequestedDeltaTimeGameTime = 0;
 
#if CSV_PROFILER_STATS
    const char* CSVTickStatName = "BehaviorTreeTick";
#endif
};
 
// Inlines
 
inline UBehaviorTree* UBehaviorTreeComponent::GetCurrentTree() const
{
    return InstanceStack.Num() ? KnownInstances[InstanceStack[ActiveInstanceIdx].InstanceIdIndex].TreeAsset : NULL;
}
 
inline UBehaviorTree* UBehaviorTreeComponent::GetRootTree() const
{
    return InstanceStack.Num() ? KnownInstances[InstanceStack[0].InstanceIdIndex].TreeAsset : NULL;
}
 
inline const UBTNode* UBehaviorTreeComponent::GetActiveNode() const
{
    return InstanceStack.Num() ? InstanceStack[ActiveInstanceIdx].ActiveNode : NULL;
}
 
inline uint16 UBehaviorTreeComponent::GetActiveInstanceIdx() const
{
    return ActiveInstanceIdx;
}
 
inline bool UBehaviorTreeComponent::IsRestartPending() const
{
    return ExecutionRequest.ExecuteNode && !ExecutionRequest.bTryNextChild;
}
 
inline bool UBehaviorTreeComponent::IsAbortPending() const
{
    return bWaitingForLatentAborts || PendingExecution.IsSet();
}