UBTService_SetFocus Class Reference

#include <BTService_SetFocus.h>

Inheritance diagram for UBTService_SetFocus:

Public Member Functions
	UBTService_SetFocus ()

Public Attributes
bool	bDoOnce = false
bool	bFocusPoint = true
FBlackboardKeySelector	Target
bool	bDebuggingMode = false
float	PointSize = 20.0f
float	LineLifetime = 20.0f
float	LineThickness = 1.0f
FColor	TargetPointColor = FColor::Red
FColor	TargetLineColor = FColor::Red

Protected Member Functions
virtual void	TickNode (UBehaviorTreeComponent &OwnerComp, uint8 *NodeMemory, const float DeltaSeconds) override
virtual void	OnBecomeRelevant (UBehaviorTreeComponent &OwnerComp, uint8 *NodeMemory) override
virtual FString	GetStaticDescription () const override

Private Member Functions
bool	SetFocusToActor (AActor *TargetActor, class AAIController *Controller) const

Constructor & Destructor Documentation

UBTService_SetFocus()

UBTService_SetFocus::UBTService_SetFocus

(

)

{
    NodeName = TEXT("Set Focus");
    INIT_SERVICE_NODE_NOTIFY_FLAGS();
#if WITH_EDITOR
    bDebuggingMode = true;
#endif // WITH_EDITOR
}

Member Function Documentation

GetStaticDescription()

FString UBTService_SetFocus::GetStaticDescription ( ) const

overrideprotectedvirtual

{
    FString Description;
    if(bDebuggingMode)
    {
        Description += FString::Printf(TEXT("\n DEBUG ACTIVE"));
    }
    if(Target.SelectedKeyName.IsValid())
    {
        Description += FString::Printf(TEXT("\nTarget : %s"), *Target.SelectedKeyName.ToString());
    }
    else
    {
        Description += TEXT("\nTarget : None");
    }
    return Description;
}

OnBecomeRelevant()

void UBTService_SetFocus::OnBecomeRelevant ( UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTService_SetFocus::OnBecomeRelevant);
    Super::OnBecomeRelevant(OwnerComp, NodeMemory);
    const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
    if(BlackboardComp == nullptr){return;}
    AAIController* AIController = OwnerComp.GetAIOwner();
    if(AIController == nullptr){return;}
    UObject* TargetObject = BlackboardComp->GetValueAsObject(Target.SelectedKeyName);
    if(TargetObject != nullptr)
    {
        AActor* TargetActor = Cast<AActor>(TargetObject);
        if(TargetActor == nullptr){return;}
        SetFocusToActor(TargetActor, AIController);
    }
    else
    {
        AIController->SetFocalPoint(BlackboardComp->GetValueAsVector(Target.SelectedKeyName));
    }
}

SetFocusToActor()

bool UBTService_SetFocus::SetFocusToActor ( AActor * TargetActor, class AAIController * Controller ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTService_SetFocus::SetFocusToActor);
    if(TargetActor == nullptr){return false;}
    if(Controller == nullptr){return false;}
    if(bFocusPoint)
    {
        FVector FocalPoint;
        const IInteractionInterface* InteractionActor = Cast<IInteractionInterface>(TargetActor);
        if(InteractionActor != nullptr)
        {
            FocalPoint = InteractionActor->GetInteractionLocation();
        }
        else
        {
            FocalPoint = TargetActor->GetActorLocation();
        }
        Controller->SetFocalPoint(FocalPoint);
        if(bDebuggingMode)
        {
            const FVector StartLocation = Controller->GetPawn()->GetPawnViewLocation();
            DrawDebugLine(GetWorld(), StartLocation, FocalPoint, TargetLineColor, false, LineLifetime, 0, LineThickness);
            DrawDebugPoint(GetWorld(), FocalPoint, PointSize, TargetPointColor,false, LineLifetime, 0);
        }
    }
    else
    {
        Controller->SetFocus(TargetActor);
        if(bDebuggingMode)
        {
            const FVector StartLocation = Controller->GetPawn()->GetPawnViewLocation();
            const FVector EndLocation = TargetActor->GetActorLocation();
            DrawDebugLine(GetWorld(), StartLocation, EndLocation, TargetLineColor, false, LineLifetime, 0, LineThickness);
            DrawDebugPoint(GetWorld(), EndLocation, PointSize, TargetPointColor,false, LineLifetime, 0);
        }
    }
    return true;
}

TickNode()

void UBTService_SetFocus::TickNode ( UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory, const float DeltaSeconds )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTService_SetFocus::TickNode);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Behaviors);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Services);
    Super::TickNode(OwnerComp, NodeMemory, DeltaSeconds);
    if(bDoOnce){return;}
    // FBTTaskFocusMemory* FocusMemory = reinterpret_cast<FBTTaskFocusMemory*>(NodeMemory);
    // if(FocusMemory == nullptr){return;}
    // FocusMemory->FocalPoint = FVector::ZeroVector;
    const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
    if(BlackboardComp == nullptr){return;}
    AAIController* AIController = OwnerComp.GetAIOwner();
    if(AIController == nullptr){return;}
    UObject* TargetObject = BlackboardComp->GetValueAsObject(Target.SelectedKeyName);
    if(TargetObject != nullptr)
    {
        AActor* TargetActor = Cast<AActor>(TargetObject);
        if(TargetActor == nullptr){return;}
        SetFocusToActor(TargetActor, AIController);
        // const IInteractionInterface* InteractionActor = Cast<IInteractionInterface>(TargetActor);
        // if(InteractionActor)
        // {
        //  FocusMemory->FocalPoint = InteractionActor->GetInteractionLocation();
        // }
        // else
        // {
        //  FocusMemory->FocalPoint = TargetActor->GetActorLocation();
        // }
    }
    else
    {
        AIController->SetFocalPoint(BlackboardComp->GetValueAsVector(Target.SelectedKeyName));
        if(bDebuggingMode)
        {
            const FVector StartLocation = AIController->GetPawn()->GetPawnViewLocation();
            const FVector EndLocation = BlackboardComp->GetValueAsVector(Target.SelectedKeyName);
            DrawDebugLine(GetWorld(), StartLocation, EndLocation, TargetLineColor, false, LineLifetime, 0, LineThickness);
            DrawDebugPoint(GetWorld(), EndLocation, PointSize, TargetPointColor,false, LineLifetime, 0);
        }
    }
    //
    // if (AAIController* AIController = OwnerComp.GetAIOwner())
    // {
    //  if(bFocusPoint)
    //  {
    //      AIController->SetFocalPoint(FocusMemory->FocalPoint);
    //  }
    //  else
    //  {
    //      AIController->SetFocus();
    //  }
    // }
    //
}

Member Data Documentation

bDebuggingMode

bool UBTService_SetFocus::bDebuggingMode = false

bDoOnce

bool UBTService_SetFocus::bDoOnce = false

bFocusPoint

bool UBTService_SetFocus::bFocusPoint = true

LineLifetime

float UBTService_SetFocus::LineLifetime = 20.0f

LineThickness

float UBTService_SetFocus::LineThickness = 1.0f

PointSize

float UBTService_SetFocus::PointSize = 20.0f

Target

FBlackboardKeySelector UBTService_SetFocus::Target

TargetLineColor

FColor UBTService_SetFocus::TargetLineColor = FColor::Red

TargetPointColor

FColor UBTService_SetFocus::TargetPointColor = FColor::Red

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Public/Behavior/Services/BTService_SetFocus.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Private/Behavior/Services/BTService_SetFocus.cpp