BehaviorTreeTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Blackboard/BlackboardKey.h"
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "InputCoreTypes.h"
#include "Templates/SubclassOf.h"
#include "BehaviorTreeTypes.generated.h"
 
class FBlackboardDecoratorDetails;
class UBehaviorTree;
class UBehaviorTreeComponent;
class UBlackboardComponent;
class UBlackboardData;
class UBlackboardKeyType;
class UBTAuxiliaryNode;
class UBTCompositeNode;
class UBTNode;
class UBTTaskNode;
struct FBehaviorTreeSearchData;
 
// Visual logging helper
#define BT_VLOG(Context, Verbosity, Format, ...) UE_VLOG(Context->OwnerComp.IsValid() ? Context->OwnerComp->GetOwner() : NULL, LogBehaviorTree, Verbosity, Format, ##__VA_ARGS__)
#define BT_SEARCHLOG(SearchData, Verbosity, Format, ...) UE_VLOG(SearchData.OwnerComp.GetOwner(), LogBehaviorTree, Verbosity, Format, ##__VA_ARGS__)
 
// Behavior tree debugger in editor
#define USE_BEHAVIORTREE_DEBUGGER   (1 && WITH_EDITORONLY_DATA)
 
DECLARE_STATS_GROUP(TEXT("Behavior Tree"), STATGROUP_AIBehaviorTree, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Tick"),STAT_AI_BehaviorTree_Tick,STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Load Time"),STAT_AI_BehaviorTree_LoadTime,STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Search Time"),STAT_AI_BehaviorTree_SearchTime,STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Execution Time"),STAT_AI_BehaviorTree_ExecutionTime,STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Auxiliary Update Time"),STAT_AI_BehaviorTree_AuxUpdateTime,STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Cleanup Time"), STAT_AI_BehaviorTree_Cleanup, STATGROUP_AIBehaviorTree, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("BT Stop Tree Time"), STAT_AI_BehaviorTree_StopTree, STATGROUP_AIBehaviorTree, );
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("Num Templates"),STAT_AI_BehaviorTree_NumTemplates,STATGROUP_AIBehaviorTree, );
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("Num Instances"),STAT_AI_BehaviorTree_NumInstances,STATGROUP_AIBehaviorTree, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("Instance memory"),STAT_AI_BehaviorTree_InstanceMemory,STATGROUP_AIBehaviorTree, AIMODULE_API);
 
#ifndef AI_BLACKBOARD_KEY_SIZE_8
template <> struct TIsValidVariadicFunctionArg<FBlackboard::FKey>
{
    enum { Value = true };
};
#endif
 
#if WITH_EDITORONLY_DATA
namespace UE::BehaviorTree::Messages
{
    extern AIMODULE_API FText BlackboardNotSet;
}
#endif // WITH_EDITORONLY_DATA
 
enum class EBlackboardNotificationResult : uint8
{
    RemoveObserver,
    ContinueObserving
};
 
// delegate defines
DECLARE_DELEGATE_TwoParams(FOnBlackboardChange, const UBlackboardComponent&, FBlackboard::FKey /*key ID*/);
 
// using "not checked" user policy (means race detection is disabled) because this delegate is stored in a TMultiMap and causes its reallocation
// from inside delegate's execution. This is incompatible with race detection that needs to access the delegate instance after its execution
using FOnBlackboardChangeNotification = TDelegate<EBlackboardNotificationResult(const UBlackboardComponent&, FBlackboard::FKey keyID), FNotThreadSafeNotCheckedDelegateUserPolicy>;
 
namespace BTSpecialChild
{
    inline constexpr int32 NotInitialized = -1; // special value for child indices: needs to be initialized
    inline constexpr int32 ReturnToParent = -2; // special value for child indices: return to parent node
    
    inline constexpr uint8 OwnedByComposite = MAX_uint8;    // special value for aux node's child index: owned by composite node instead of a task
}
 
UENUM(BlueprintType)
namespace EBTNodeResult
{
    // keep in sync with DescribeNodeResult()
    enum Type : int
    {
        // finished as success
        Succeeded,
        // finished as failure
        Failed,
        // finished aborting = failure
        Aborted,
        // not finished yet
        InProgress,
    };
}
 
namespace EBTExecutionMode
{
    enum Type
    {
        SingleRun,
        Looped,
    };
}
 
namespace EBTStopMode
{
    enum Type
    {
        Safe,
        Forced,
    };
}
 
enum class EBTRestartMode : uint8
{
    ForceReevaluateRootNode, // (Default) will just request a new execution on the root node and any active nodes that gets re-added will not get CeaseRelevant/BecomeRelevant notification
    CompleteRestart, // essentially equivalent to calling StopTree and then StartTree. Every active node is going to be removed and the execution started from the root
};
 
namespace EBTMemoryInit
{
    enum Type
    {
        Initialize,     // first time initialization
        RestoreSubtree, // loading saved data on reentering subtree
    };
}
 
namespace EBTMemoryClear
{
    enum Type
    {
        Destroy,        // final clear
        StoreSubtree,   // saving data on leaving subtree
    };
}
 
UENUM()
namespace EBTFlowAbortMode
{
    // keep in sync with DescribeFlowAbortMode()
 
    enum Type : int
    {
        None                UMETA(DisplayName="Nothing"),
        LowerPriority       UMETA(DisplayName="Lower Priority"),
        Self                UMETA(DisplayName="Self"),
        Both                UMETA(DisplayName="Both"),
    };
}
 
namespace EBTActiveNode
{
    // keep in sync with DescribeActiveNode()
    enum Type
    {
        Composite,
        ActiveTask,
        AbortingTask,
        InactiveTask,
    };
}
 
namespace EBTTaskStatus
{
    // keep in sync with DescribeTaskStatus()
    enum Type
    {
        Active,
        Aborting,
        Inactive,
    };
}
 
namespace EBTNodeUpdateMode
{
    // keep in sync with DescribeNodeUpdateMode()
    enum Type
    {
        Unknown,
        Add,                // add node
        Remove,             // remove node
    };
}
 
struct FBehaviorTreeParallelTask
{
    TObjectPtr<const UBTTaskNode> TaskNode;
 
    EBTTaskStatus::Type Status;
 
    FBehaviorTreeParallelTask() : TaskNode(nullptr) {}
    FBehaviorTreeParallelTask(const UBTTaskNode* InTaskNode, EBTTaskStatus::Type InStatus) : TaskNode(InTaskNode), Status(InStatus) {}
 
    bool operator==(const FBehaviorTreeParallelTask& Other) const { return TaskNode == Other.TaskNode; }
    bool operator==(const UBTTaskNode* OtherTask) const { return TaskNode == OtherTask; }
};
 
namespace EBTExecutionSnap
{
    enum Type
    {
        Regular,
        OutOfNodes,
    };
}
 
namespace EBTDescriptionVerbosity
{
    enum Type
    {
        Basic,
        Detailed,
    };
}
 
enum class EBTNodeRelativePriority : uint8
{
    Lower,
    Same,
    Higher
};
 
struct FBehaviorTreeDebuggerInstance
{
    struct FNodeFlowData
    {
        uint16 ExecutionIndex;
        uint16 bPassed : 1;
        uint16 bTrigger : 1;
        uint16 bDiscardedTrigger : 1;
 
        FNodeFlowData() : ExecutionIndex(INDEX_NONE), bPassed(0), bTrigger(0), bDiscardedTrigger(0) {}
    };
 
    FBehaviorTreeDebuggerInstance() : TreeAsset(nullptr), RootNode(nullptr) {}
 
    UBehaviorTree* TreeAsset;
 
    TWeakObjectPtr<UBTCompositeNode> RootNode;
 
    TArray<uint16> ActivePath;
 
    TArray<uint16> AdditionalActiveNodes;
 
    TArray<FNodeFlowData> PathFromPrevious;
 
    TArray<FString> RuntimeDesc;
 
    inline bool IsValid() const { return ActivePath.Num() != 0; }
};
 
struct FBehaviorTreeExecutionStep
{
    FBehaviorTreeExecutionStep() : TimeStamp(0.), ExecutionStepId(InvalidExecutionId) {}
 
    TArray<FBehaviorTreeDebuggerInstance> InstanceStack;
 
    TMap<FName, FString> BlackboardValues;
 
    double TimeStamp;
 
    inline static constexpr int32 InvalidExecutionId = -1;
 
    int32 ExecutionStepId;
 
    bool bIsExecutionPaused = false;
};
 
struct FBehaviorTreeInstanceId
{
    TObjectPtr<UBehaviorTree> TreeAsset;
 
    TObjectPtr<UBTCompositeNode> RootNode;
 
    TArray<uint16> Path;
 
    TArray<uint8> InstanceMemory;
 
    int32 FirstNodeInstance;
 
    FBehaviorTreeInstanceId() : TreeAsset(0), RootNode(0), FirstNodeInstance(-1) {}
 
    bool operator==(const FBehaviorTreeInstanceId& Other) const
    {
        return (TreeAsset == Other.TreeAsset) && (Path == Other.Path);
    }
};
 
struct FBehaviorTreeSearchData;
DECLARE_DELEGATE_TwoParams(FBTInstanceDeactivation, UBehaviorTreeComponent&, EBTNodeResult::Type);
 
struct FBehaviorTreeInstance
{
    TObjectPtr<UBTCompositeNode> RootNode;
 
    TObjectPtr<UBTNode> ActiveNode;
 
    TArray<TObjectPtr<UBTAuxiliaryNode>> ActiveAuxNodes;
 
    TArray<FBehaviorTreeParallelTask> ParallelTasks;
 
    TArray<uint8> InstanceMemory;
 
    uint8 InstanceIdIndex;
 
    TEnumAsByte<EBTActiveNode::Type> ActiveNodeType;
 
    FBTInstanceDeactivation DeactivationNotify;
 
    AIMODULE_API FBehaviorTreeInstance();
 
    UE_DEPRECATED(5.2, "Copying FBehaviorTreeInstance constructor has been deprecated in favor of move-constructor")
    AIMODULE_API FBehaviorTreeInstance(const FBehaviorTreeInstance& Other);
 
    UE_DEPRECATED(5.2, "Copying FBehaviorTreeInstance assignement operator has been deprecated in favor of move assignement operator")
    FBehaviorTreeInstance& operator=(const FBehaviorTreeInstance& Other) = default;
 
    AIMODULE_API FBehaviorTreeInstance(FBehaviorTreeInstance&& Other);
    AIMODULE_API FBehaviorTreeInstance& operator=(FBehaviorTreeInstance&& Other);
 
    AIMODULE_API FBehaviorTreeInstance(int32 MemorySize);
    AIMODULE_API ~FBehaviorTreeInstance();
 
#if STATS
    void IncMemoryStats() const;
    void DecMemoryStats() const;
    uint32 GetAllocatedSize() const;
#else
    inline uint32 GetAllocatedSize() const { return 0; }
    inline void IncMemoryStats() const {}
    inline void DecMemoryStats() const {}
#endif // STATS
 
    void Initialize(UBehaviorTreeComponent& OwnerComp, UBTCompositeNode& Node, int32& InstancedIndex, EBTMemoryInit::Type InitType);
 
    void Cleanup(UBehaviorTreeComponent& OwnerComp, EBTMemoryClear::Type CleanupType);
 
    bool HasActiveNode(uint16 TestExecutionIndex) const;
 
    void DeactivateNodes(FBehaviorTreeSearchData& SearchData, uint16 InstanceIndex);
 
    TArrayView<UBTAuxiliaryNode* const> GetActiveAuxNodes() const { return ActiveAuxNodes; }
 
    UE_DEPRECATED(5.4, "This function is deprecated. Please use version that takes UBehaviorTreeComponent.")
    void AddToActiveAuxNodes(UBTAuxiliaryNode* AuxNode);
 
    void AddToActiveAuxNodes(UBehaviorTreeComponent& OwnerComp, UBTAuxiliaryNode* AuxNode);
 
    UE_DEPRECATED(5.4, "This function is deprecated. Please use version that takes UBehaviorTreeComponent.")
    void RemoveFromActiveAuxNodes(UBTAuxiliaryNode* AuxNode);
 
    void RemoveFromActiveAuxNodes(UBehaviorTreeComponent& OwnerComp, UBTAuxiliaryNode* AuxNode);
 
    void ResetActiveAuxNodes();
 
    void ExecuteOnEachAuxNode(TFunctionRef<void(const UBTAuxiliaryNode&)> ExecFunc);
 
    TArrayView<const FBehaviorTreeParallelTask> GetParallelTasks() const { return ParallelTasks; }
 
    void AddToParallelTasks(FBehaviorTreeParallelTask&& ParallelTask);
 
    void RemoveParallelTaskAt(int32 TaskIndex);
 
    void MarkParallelTaskAsAbortingAt(int32 TaskIndex);
 
    bool IsValidParallelTaskIndex(const int32 Index) const { return ParallelTasks.IsValidIndex(Index); }
 
    void ExecuteOnEachParallelTask(TFunctionRef<void(const FBehaviorTreeParallelTask&, const int32)> ExecFunc);
 
    void SetInstanceMemory(const TArray<uint8>& Memory);
 
    TArrayView<const uint8> GetInstanceMemory() const { return InstanceMemory; }
 
protected:
 
    void CleanupNodes(UBehaviorTreeComponent& OwnerComp, UBTCompositeNode& Node, EBTMemoryClear::Type CleanupType);
 
private:
    void AddToActiveAuxNodesImpl(UBTAuxiliaryNode* AuxNode);
    void RemoveFromActiveAuxNodesImpl(UBTAuxiliaryNode* AuxNode);
 
private:
#if DO_ENSURE
    bool bIteratingNodes = false;
 
    int32 ParallelTaskIndex = INDEX_NONE;
#endif // DO_ENSURE
};
 
struct FBTNodeIndex
{
    static constexpr uint16 InvalidIndex = TNumericLimits<uint16>::Max(); // (This is also the same as INDEX_NONE assigned to IndexType!)
 
    uint16 InstanceIndex;
 
    uint16 ExecutionIndex;
 
    FBTNodeIndex() : InstanceIndex(InvalidIndex), ExecutionIndex(InvalidIndex) {}
    FBTNodeIndex(uint16 InInstanceIndex, uint16 InExecutionIndex) : InstanceIndex(InInstanceIndex), ExecutionIndex(InExecutionIndex) {}
 
    bool TakesPriorityOver(const FBTNodeIndex& Other) const;
    bool IsSet() const { return InstanceIndex < InvalidIndex; }
 
    inline bool operator==(const FBTNodeIndex& Other) const { return Other.ExecutionIndex == ExecutionIndex && Other.InstanceIndex == InstanceIndex; }
    inline bool operator!=(const FBTNodeIndex& Other) const { return !operator==(Other); }
    inline friend uint32 GetTypeHash(const FBTNodeIndex& Other) { return Other.ExecutionIndex ^ Other.InstanceIndex; }
 
    inline FString Describe() const { return FString::Printf(TEXT("[%d:%d]"), InstanceIndex, ExecutionIndex); }
};
 
struct FBTNodeIndexRange
{
    FBTNodeIndex FromIndex;
 
    FBTNodeIndex ToIndex;
 
    FBTNodeIndexRange(const FBTNodeIndex& From, const FBTNodeIndex& To) : FromIndex(From), ToIndex(To) {}
 
    bool IsSet() const { return FromIndex.IsSet() && ToIndex.IsSet(); }
 
    bool operator==(const FBTNodeIndexRange& Other) const { return Other.FromIndex == FromIndex && Other.ToIndex == ToIndex; }
    bool operator!=(const FBTNodeIndexRange& Other) const { return !operator==(Other); }
 
    bool Contains(const FBTNodeIndex& Index) const
    { 
        return Index.InstanceIndex == FromIndex.InstanceIndex && FromIndex.ExecutionIndex <= Index.ExecutionIndex && Index.ExecutionIndex <= ToIndex.ExecutionIndex;
    }
 
    FString Describe() const { return FString::Printf(TEXT("[%s...%s]"), *FromIndex.Describe(), *ToIndex.Describe()); }
};
 
struct FBehaviorTreeSearchUpdate
{
    TObjectPtr<UBTAuxiliaryNode> AuxNode;
    TObjectPtr<UBTTaskNode> TaskNode;
 
    uint16 InstanceIndex;
 
    TEnumAsByte<EBTNodeUpdateMode::Type> Mode;
 
    uint8 bPostUpdate : 1;
 
    mutable uint8 bApplySkipped : 1;
 
    FBehaviorTreeSearchUpdate() 
        : AuxNode(0), TaskNode(0), InstanceIndex(0), Mode(EBTNodeUpdateMode::Unknown), bPostUpdate(false), bApplySkipped(false)
    {}
    FBehaviorTreeSearchUpdate(const UBTAuxiliaryNode* InAuxNode, uint16 InInstanceIndex, EBTNodeUpdateMode::Type InMode)
        : AuxNode((UBTAuxiliaryNode*)InAuxNode), TaskNode(0), InstanceIndex(InInstanceIndex), Mode(InMode), bPostUpdate(false), bApplySkipped(false)
    {}
    FBehaviorTreeSearchUpdate(const UBTTaskNode* InTaskNode, uint16 InInstanceIndex, EBTNodeUpdateMode::Type InMode)
        : AuxNode(0), TaskNode((UBTTaskNode*)InTaskNode), InstanceIndex(InInstanceIndex), Mode(InMode), bPostUpdate(false), bApplySkipped(false)
    {}
};
 
struct FBehaviorTreeSearchUpdateNotify
{
    uint16 InstanceIndex;
    TEnumAsByte<EBTNodeResult::Type> NodeResult;
 
    FBehaviorTreeSearchUpdateNotify() : InstanceIndex(0), NodeResult(EBTNodeResult::Succeeded) {}
    FBehaviorTreeSearchUpdateNotify(uint16 InInstanceIndex, EBTNodeResult::Type InNodeResult) : InstanceIndex(InInstanceIndex), NodeResult(InNodeResult) {}
};
 
struct FBehaviorTreeSearchData
{
    UBehaviorTreeComponent& OwnerComp;
 
    TArray<FBehaviorTreeSearchUpdate> PendingUpdates;
 
    TArray<FBehaviorTreeSearchUpdateNotify> PendingNotifies;
 
    FBTNodeIndex SearchRootNode;
 
    FBTNodeIndex SearchStart;
 
    FBTNodeIndex SearchEnd;
 
    int32 SearchId;
 
    int32 RollbackInstanceIdx;
 
    FBTNodeIndex DeactivatedBranchStart;
 
    FBTNodeIndex DeactivatedBranchEnd;
 
    FBTNodeIndex RollbackDeactivatedBranchStart;
 
    FBTNodeIndex RollbackDeactivatedBranchEnd;
 
    uint32 bFilterOutRequestFromDeactivatedBranch : 1;
 
    uint32 bPostponeSearch : 1;
 
    uint32 bSearchInProgress : 1;
 
    uint32 bPreserveActiveNodeMemoryOnRollback : 1;
 
    void AddUniqueUpdate(const FBehaviorTreeSearchUpdate& UpdateInfo);
 
    void AssignSearchId();
 
    void Reset();
 
    FBehaviorTreeSearchData(UBehaviorTreeComponent& InOwnerComp) 
        : OwnerComp(InOwnerComp), RollbackInstanceIdx(INDEX_NONE)
        , bFilterOutRequestFromDeactivatedBranch(false)
        , bPostponeSearch(false)
        , bSearchInProgress(false)
        , bPreserveActiveNodeMemoryOnRollback(false)
    {}
 
    FBehaviorTreeSearchData() = delete;
 
private:
 
    static int32 NextSearchId;
};
 
struct FBehaviorTreePropertyMemory
{
    uint16 Offset;
    uint16 BlockSize;
    
    FBehaviorTreePropertyMemory() {}
    FBehaviorTreePropertyMemory(int32 Value) : Offset((uint32)Value >> 16), BlockSize((uint32)Value & 0xFFFF) {}
 
    int32 Pack() const { return (int32)(((uint32)Offset << 16) | BlockSize); }
};
 
USTRUCT(BlueprintType)
struct FBlackboardKeySelector
{
    GENERATED_USTRUCT_BODY()
 
    FBlackboardKeySelector() : SelectedKeyID(FBlackboard::InvalidKey), bNoneIsAllowedValue(false)
    {}
 
    UPROPERTY(transient, EditAnywhere, BlueprintReadWrite, Category = Blackboard)
    TArray<TObjectPtr<UBlackboardKeyType>> AllowedTypes;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category = Blackboard)
    FName SelectedKeyName;
 
    UPROPERTY(transient, EditInstanceOnly, BlueprintReadWrite, Category = Blackboard)
    TSubclassOf<UBlackboardKeyType> SelectedKeyType;
 
protected:
    UPROPERTY(transient, EditInstanceOnly, BlueprintReadWrite, Category = Blackboard, meta = (ClampMin = "0", UIMin = "0"))
    int32 SelectedKeyID;
 
    // Requires BlueprintReadWrite so that blueprint creators (using MakeBlackboardKeySelector) can specify whether or not None is Allowed.
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Blackboard, Meta = (Tooltip = ""))
    uint32 bNoneIsAllowedValue:1;
 
    AIMODULE_API void InitSelection(const UBlackboardData& BlackboardAsset);
 
public:
    AIMODULE_API void ResolveSelectedKey(const UBlackboardData& BlackboardAsset);
        
    void AllowNoneAsValue(bool bAllow) { bNoneIsAllowedValue = bAllow; }
 
    inline FBlackboard::FKey GetSelectedKeyID() const { return FBlackboard::FKey(IntCastChecked<uint16>(SelectedKeyID)); }
 
    AIMODULE_API void AddObjectFilter(UObject* Owner, FName PropertyName, TSubclassOf<UObject> AllowedClass);
    AIMODULE_API void AddClassFilter(UObject* Owner, FName PropertyName, TSubclassOf<UObject> AllowedClass);
    AIMODULE_API void AddEnumFilter(UObject* Owner, FName PropertyName, UEnum* AllowedEnum);
    AIMODULE_API void AddNativeEnumFilter(UObject* Owner, FName PropertyName, const FString& AllowedEnumName);
    AIMODULE_API void AddIntFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddFloatFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddBoolFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddVectorFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddRotatorFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddStringFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddNameFilter(UObject* Owner, FName PropertyName);
    AIMODULE_API void AddStructFilter(UObject* Owner, FName PropertyName, const UScriptStruct* AllowedStruct);
 
    template<typename T>
    void AddStructFilter(UObject* Owner, FName PropertyName)
    {
        AddStructFilter(Owner, PropertyName, TBaseStructure<T>::Get());
    }
 
    inline bool IsNone() const { return bNoneIsAllowedValue && GetSelectedKeyID() == FBlackboard::InvalidKey; }
    inline bool IsSet() const { return GetSelectedKeyID() != FBlackboard::InvalidKey; }
    inline bool NeedsResolving() const { return GetSelectedKeyID() == FBlackboard::InvalidKey && SelectedKeyName.IsNone() == false; }
    inline void InvalidateResolvedKey() { SelectedKeyID = FBlackboard::InvalidKey; }
 
#if WITH_EDITOR
    void PreSave(const UObject* Outer, const UBlackboardData& Blackboard, FName PropertyName);
#endif // WITH_EDITOR
 
    friend FBlackboardDecoratorDetails;
};
 
UCLASS(Abstract, MinimalAPI)
class UBehaviorTreeTypes : public UObject
{
    GENERATED_BODY()
 
    static AIMODULE_API FString BTLoggingContext;
 
public:
 
    static AIMODULE_API FString DescribeNodeHelper(const UBTNode* Node);
 
    static AIMODULE_API FString DescribeNodeResult(EBTNodeResult::Type NodeResult);
    static AIMODULE_API FString DescribeFlowAbortMode(EBTFlowAbortMode::Type FlowAbortMode);
    static AIMODULE_API FString DescribeActiveNode(EBTActiveNode::Type ActiveNodeType);
    static AIMODULE_API FString DescribeTaskStatus(EBTTaskStatus::Type TaskStatus);
    static AIMODULE_API FString DescribeNodeUpdateMode(EBTNodeUpdateMode::Type UpdateMode);
 
    static AIMODULE_API FString GetShortTypeName(const UObject* Ob);
    
    static FString GetBTLoggingContext() { return BTLoggingContext; }
    
    // @param NewBTLoggingContext the object which name's will be added to some of the BT logging
    //  pass nullptr to clear
    static AIMODULE_API void SetBTLoggingContext(const UBTNode* NewBTLoggingContext);
};
 
struct FScopedBTLoggingContext
{
    FScopedBTLoggingContext() = delete;
    explicit FScopedBTLoggingContext(const UBTNode* Context)
    {
        UBehaviorTreeTypes::SetBTLoggingContext(Context);
    }
 
    ~FScopedBTLoggingContext()
    {
        UBehaviorTreeTypes::SetBTLoggingContext(nullptr);
    }
};