UBTTask_Rotate Class Reference

A task node that rotates the AI character by a specified number of degrees. More...

#include <BTTask_Rotate.h>

Inheritance diagram for UBTTask_Rotate:

Classes
struct	FBTTaskRotateMemory

Public Member Functions
	UBTTask_Rotate ()

Public Attributes
float	RotationDegrees = 90.0f
float	ForwardDistance = 500.0f
bool	bInstantTurn = true
float	InterpolationDuration = 2.0f
float	RandomDeviation = 0.1f
bool	bLookAround = false
int32	TimesToLookAround = 1
bool	bDebuggingMode = false
bool	bShowCurrentFocus = true
bool	bShowText = true
float	PointSize = 20.0f
FColor	TargetFocalPointColor = FColor::Red
float	TargetFocalPointDuration = 2.0f
FColor	CurrentFocalPointColor = FColor::Yellow

Protected Member Functions
virtual EBTNodeResult::Type	ExecuteTask (UBehaviorTreeComponent &OwnerComp, uint8 *NodeMemory) override
virtual EBTNodeResult::Type	AbortTask (UBehaviorTreeComponent &OwnerComp, uint8 *NodeMemory) override
virtual void	TickTask (UBehaviorTreeComponent &OwnerComp, uint8 *NodeMemory, float DeltaSeconds) override
virtual uint16	GetInstanceMemorySize () const override
void	InstantTurn (const FBTTaskRotateMemory *RotateMemory, AAIController *AIController) const
void	Turn (FBTTaskRotateMemory *RotateMemory, AAIController *AIController, const bool bForward=true)
virtual FString	GetStaticDescription () const override

Static Protected Member Functions
static void	ResetNumbers (FBTTaskRotateMemory *RotateMemory)

Detailed Description

A task node that rotates the AI character by a specified number of degrees.

This task node rotates the AI character by a specified number of degrees. The rotation can be instant or interpolated over a specified duration. The rotation can be performed either to the left or to the right based on the sign of the RotationDegrees property.

The task node also provides debugging options to visualize the current focal point of rotation and the target focal point.

Note

This class is part of the AIToolkit module.

See also

UBTTaskNode

Constructor & Destructor Documentation

UBTTask_Rotate()

UBTTask_Rotate::UBTTask_Rotate

(

)

{
    NodeName = TEXT("Rotate");
    INIT_TASK_NODE_NOTIFY_FLAGS();
#if WITH_EDITOR
    bDebuggingMode = true;
#endif // WITH_EDITOR
}

Member Function Documentation

AbortTask()

EBTNodeResult::Type UBTTask_Rotate::AbortTask ( UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory )

overrideprotectedvirtual

{
    return EBTNodeResult::Aborted;
}

ExecuteTask()

EBTNodeResult::Type UBTTask_Rotate::ExecuteTask ( UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTTask_Rotate::ExecuteTask);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Behaviors);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Tasks);
 
    FBTTaskRotateMemory* RotateMemory = reinterpret_cast<FBTTaskRotateMemory*>(NodeMemory);
    if(OwnerComp.GetAIOwner() == nullptr || OwnerComp.GetAIOwner()->GetPawn() == nullptr || RotateMemory == nullptr){return EBTNodeResult::Failed;}
    RotateMemory->LookAroundCount = 1;
    ResetNumbers(RotateMemory);
    
    //- Get the Characters View //
    FVector ActorsEyeLocation;
    FRotator ActorsEyeRotation;
    OwnerComp.GetAIOwner()->GetPawn()->GetActorEyesViewPoint(ActorsEyeLocation, ActorsEyeRotation);
    
    //- Save Vars for tick  //
    RotateMemory->StartRotation = ActorsEyeRotation;
    RotateMemory->OriginalRotation = RotateMemory->StartRotation;
    RotateMemory->StartLocation = ActorsEyeLocation;
    RotateMemory->OriginalLocation = RotateMemory->StartLocation;
 
    //- Set Random Number   //
    RotateMemory->RandomDeviationMultiplier = FMath::RandRange(0.0f, RandomDeviation);
 
    //- This is the characters forward view + the rotation in Degrees + 90 = right turn //
    const FRotator TargetRotation = FRotator(ActorsEyeRotation.Pitch, (ActorsEyeRotation.Yaw + RotationDegrees), ActorsEyeRotation.Roll);
    const FRotator TargetOppositeRotation = FRotator(ActorsEyeRotation.Pitch, (ActorsEyeRotation.Yaw - RotationDegrees), ActorsEyeRotation.Roll);
 
    
    // //- Forward Vector from the Character Rotation, x Distance + Location    //
    RotateMemory->FocalPoint = (ActorsEyeLocation + (ActorsEyeRotation.Vector() * ForwardDistance));
    
    //-     Location    + Forward Vector Toward target Rotation, x Distance forward //
    RotateMemory->TargetLocation = (ActorsEyeLocation + (TargetRotation.Vector() * ForwardDistance));
    RotateMemory->TargetOppositeLocation = (ActorsEyeLocation + (TargetOppositeRotation.Vector() * ForwardDistance));
    
    if(bInstantTurn)
    {
        if(AAIController* AIController = OwnerComp.GetAIOwner())
        {
            InstantTurn(RotateMemory, AIController);
        }
        return EBTNodeResult::Succeeded;
    }
    return EBTNodeResult::InProgress;
}

GetInstanceMemorySize()

uint16 UBTTask_Rotate::GetInstanceMemorySize ( ) const

overrideprotectedvirtual

{
    return sizeof(FBTTaskRotateMemory);
}

GetStaticDescription()

FString UBTTask_Rotate::GetStaticDescription ( ) const

overrideprotectedvirtual

{
    FString Description;
    if(bDebuggingMode)
    {
        Description += FString::Printf(TEXT("\n DEBUG ACTIVE"));
    }
    Description += FString::Printf(TEXT("\nDegrees: %i"), FMath::RoundToInt(RotationDegrees));
    Description += FString::Printf(TEXT("\nDuration: %i + %i"), FMath::RoundToInt(InterpolationDuration), FMath::RoundToInt(RandomDeviation));
    if (bLookAround)
    {
        Description += FString::Printf(TEXT("\nLook Around: %s Times"), *FString::FromInt(TimesToLookAround));
    }
    Description += FString::Printf(TEXT("\nInstant Turn: %s"), bInstantTurn ? TEXT("True") : TEXT("False"));
    return Description;
}

InstantTurn()

void UBTTask_Rotate::InstantTurn ( const FBTTaskRotateMemory * RotateMemory, AAIController * AIController ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTTask_Rotate::InstantTurn);
    AIController->SetFocalPoint(RotateMemory->TargetLocation);
    if(bDebuggingMode)
    {
        DrawDebugPoint(GetWorld(), RotateMemory->TargetLocation, PointSize, TargetFocalPointColor, false, 2.0f);
        if(bShowText)
        {
            const FString ActorName = AIController->GetPawn()->GetName();
            const FString PrintMessage = (ActorName + " Target Focal Point");
            DrawDebugString(GetWorld(), RotateMemory->TargetLocation, PrintMessage, nullptr, FColor::White, TargetFocalPointDuration);
        }
    }
}

ResetNumbers()

void UBTTask_Rotate::ResetNumbers ( FBTTaskRotateMemory * RotateMemory )

staticprotected

{
    //- Reset all Tick floats   //
    RotateMemory->TimeElapsed = 0.0f;
    RotateMemory->Alpha = 0.0f;
}

TickTask()

void UBTTask_Rotate::TickTask ( UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory, float DeltaSeconds )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBTTask_Rotate::TickTask);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Behaviors);
    SCOPE_CYCLE_COUNTER(STATGROUP_AIToolKit_Tasks);
 
    Super::TickTask(OwnerComp, NodeMemory, DeltaSeconds);
    FBTTaskRotateMemory* RotateMemory = reinterpret_cast<FBTTaskRotateMemory*>(NodeMemory);
    if(RotateMemory == nullptr){return;}
    const bool bForward = RotateMemory->LookAroundCount % 2 == 1;
    RotateMemory->TimeElapsed += DeltaSeconds;
    
    if(RotateMemory->TimeElapsed < ((InterpolationDuration) * RotateMemory->LookAroundCount))
    {
        Turn(RotateMemory, OwnerComp.GetAIOwner(), bForward);
    }
    else if(bLookAround && RotateMemory->LookAroundCount < TimesToLookAround)
    {
        ResetNumbers(RotateMemory);
        RotateMemory->LookAroundCount++;
        // if(RotateMemory->TimeElapsed < (InterpolationDuration * Multiplier))
        // {
        //  
        // }
        // RotateMemory->LookAroundCount++;
        // ResetNumbers(RotateMemory);
        // RotateMemory->TargetLocation = RotateMemory->TargetOppositeLocation;
        // OwnerComp.GetAIOwner()->GetPawn()->GetActorEyesViewPoint(RotateMemory->StartLocation, RotateMemory->StartRotation);
    }
    else if(bLookAround && RotateMemory->LookAroundCount >= TimesToLookAround)
    {
        if(RotateMemory->TargetLocation == (RotateMemory->OriginalLocation + (RotateMemory->OriginalRotation.Vector() * ForwardDistance)))
        {
            FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded);
        }
        ResetNumbers(RotateMemory);
        RotateMemory->TargetLocation = (RotateMemory->OriginalLocation + (RotateMemory->OriginalRotation.Vector() * ForwardDistance));
    }
    else
    {
        FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded);
    }
}

Turn()

void UBTTask_Rotate::Turn ( FBTTaskRotateMemory * RotateMemory, AAIController * AIController, const bool bForward = true )

protected

{
    const float TotalDuration = (InterpolationDuration + RotateMemory->RandomDeviationMultiplier);
    if(bForward)
    {
        RotateMemory->Alpha = FMath::Clamp((RotateMemory->TimeElapsed / (TotalDuration)), 0.0f, 1.0f);
    }
    else
    {
        RotateMemory->Alpha = FMath::Clamp(1.0f - (RotateMemory->TimeElapsed - InterpolationDuration - RotateMemory->RandomDeviationMultiplier) / TotalDuration, 0.0f, 1.0f);
    }
 
    const FVector CurrentFocalPoint = (RotateMemory->StartLocation + (RotateMemory->StartRotation.Vector() * ForwardDistance));
    const FVector LerpVector = UKismetMathLibrary::VLerp(CurrentFocalPoint, RotateMemory->TargetLocation, RotateMemory->Alpha);
            
    if(AIController != nullptr)
    {
        AIController->SetFocalPoint(LerpVector);
        if(bDebuggingMode && bShowCurrentFocus)
        {
            DrawDebugPoint(GetWorld(), LerpVector, PointSize, CurrentFocalPointColor, false, 0.1f);
            if(bShowText && AIController->GetPawn() != nullptr)
            {
                const FString ActorName = AIController->GetPawn()->GetName();
                const FString PrintMessage = (ActorName + " Focal Point");
                DrawDebugString(GetWorld(), LerpVector, PrintMessage, AIController->GetPawn(), FColor::White, 0.1f);
            }
        }
    }
}

Member Data Documentation

bDebuggingMode

bool UBTTask_Rotate::bDebuggingMode = false

bInstantTurn

bool UBTTask_Rotate::bInstantTurn = true

bLookAround

bool UBTTask_Rotate::bLookAround = false

bShowCurrentFocus

bool UBTTask_Rotate::bShowCurrentFocus = true

bShowText

bool UBTTask_Rotate::bShowText = true

CurrentFocalPointColor

FColor UBTTask_Rotate::CurrentFocalPointColor = FColor::Yellow

ForwardDistance

float UBTTask_Rotate::ForwardDistance = 500.0f

InterpolationDuration

float UBTTask_Rotate::InterpolationDuration = 2.0f

PointSize

float UBTTask_Rotate::PointSize = 20.0f

RandomDeviation

float UBTTask_Rotate::RandomDeviation = 0.1f

RotationDegrees

float UBTTask_Rotate::RotationDegrees = 90.0f

TargetFocalPointColor

FColor UBTTask_Rotate::TargetFocalPointColor = FColor::Red

TargetFocalPointDuration

float UBTTask_Rotate::TargetFocalPointDuration = 2.0f

TimesToLookAround

int32 UBTTask_Rotate::TimesToLookAround = 1

---

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

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