BTDecorator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "BehaviorTree/BTAuxiliaryNode.h"
#include "BTDecorator.generated.h"
 
class FBehaviorDecoratorDetails;
 
enum class EBTDecoratorAbortRequest : uint8
{
    // request execution update when only result of condition changes and active branch of tree can potentially change too
    ConditionResultChanged,
 
    // request execution update every time as long as condition is still passing
    ConditionPassing,
};
 
UCLASS(Abstract, MinimalAPI)
class UBTDecorator : public UBTAuxiliaryNode
{
    GENERATED_UCLASS_BODY()
 
    
    AIMODULE_API bool WrappedCanExecute(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const;
 
    AIMODULE_API void WrappedOnNodeActivation(FBehaviorTreeSearchData& SearchData) const;
    
    AIMODULE_API void WrappedOnNodeDeactivation(FBehaviorTreeSearchData& SearchData, EBTNodeResult::Type NodeResult) const;
 
    AIMODULE_API void WrappedOnNodeProcessed(FBehaviorTreeSearchData& SearchData, EBTNodeResult::Type& NodeResult) const;
 
    EBTFlowAbortMode::Type GetFlowAbortMode() const;
 
    bool IsInversed() const;
 
    AIMODULE_API virtual FString GetStaticDescription() const override;
 
    AIMODULE_API void UpdateFlowAbortMode();
 
    AIMODULE_API bool IsFlowAbortModeValid() const;
 
protected:
 
    uint32 bAllowAbortNone : 1;
 
    uint32 bAllowAbortLowerPri : 1;
 
    uint32 bAllowAbortChildNodes : 1;
 
    uint32 bNotifyActivation : 1;
 
    uint32 bNotifyDeactivation : 1;
 
    uint32 bNotifyProcessed : 1;
 
    uint32 bShowInverseConditionDesc : 1;
 
private:
    UPROPERTY(Category = Condition, EditAnywhere)
    uint32 bInverseCondition : 1;
 
protected:
    UPROPERTY(Category=FlowControl, EditAnywhere)
    TEnumAsByte<EBTFlowAbortMode::Type> FlowAbortMode;
 
    AIMODULE_API void SetIsInversed(bool bShouldBeInversed);
 
    AIMODULE_API virtual void OnNodeActivation(FBehaviorTreeSearchData& SearchData);
 
    AIMODULE_API virtual void OnNodeDeactivation(FBehaviorTreeSearchData& SearchData, EBTNodeResult::Type NodeResult);
 
    AIMODULE_API virtual void OnNodeProcessed(FBehaviorTreeSearchData& SearchData, EBTNodeResult::Type& NodeResult);
 
    AIMODULE_API virtual bool CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const;
 
    AIMODULE_API void ConditionalFlowAbort(UBehaviorTreeComponent& OwnerComp, EBTDecoratorAbortRequest RequestMode) const;
 
    friend FBehaviorDecoratorDetails;
 
    template<typename TickNode, typename OnBecomeRelevant, typename OnCeaseRelevant,
        typename OnNodeActivation, typename OnNodeDeactivation, typename OnNodeProcessed>
    void InitNotifyFlags(TickNode, OnBecomeRelevant, OnCeaseRelevant,
                     OnNodeActivation, OnNodeDeactivation, OnNodeProcessed)
    {
        bNotifyTick = !std::is_same_v<decltype(&UBTDecorator::TickNode), TickNode>;
        bNotifyBecomeRelevant = !std::is_same_v<decltype(&UBTDecorator::OnBecomeRelevant), OnBecomeRelevant>;
        bNotifyCeaseRelevant = !std::is_same_v<decltype(&UBTDecorator::OnCeaseRelevant), OnCeaseRelevant>;
        bNotifyActivation = !std::is_same_v<decltype(&UBTDecorator::OnNodeActivation), OnNodeActivation>;
        bNotifyDeactivation = !std::is_same_v<decltype(&UBTDecorator::OnNodeDeactivation), OnNodeDeactivation>;
        bNotifyProcessed = !std::is_same_v<decltype(&UBTDecorator::OnNodeProcessed), OnNodeProcessed>;
    }
};
 
#define INIT_DECORATOR_NODE_NOTIFY_FLAGS() \
    do { \
    using NodeType = TRemovePointer<decltype(this)>::Type; \
    InitNotifyFlags(&NodeType::TickNode, \
                    &NodeType::OnBecomeRelevant, \
                    &NodeType::OnCeaseRelevant, \
                    &NodeType::OnNodeActivation, \
                    &NodeType::OnNodeDeactivation, \
                    &NodeType::OnNodeProcessed); \
    } while (false)
 
// Inlines
 
inline EBTFlowAbortMode::Type UBTDecorator::GetFlowAbortMode() const
{
    return FlowAbortMode;
}
 
inline bool UBTDecorator::IsInversed() const
{
    return bInverseCondition;
}