AIController.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 "UObject/UObjectGlobals.h"
#include "Templates/SubclassOf.h"
#include "EngineDefines.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "NavFilters/NavigationQueryFilter.h"
#endif
#include "AITypes.h"
#include "GameplayTaskOwnerInterface.h"
#include "GameplayTask.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/Controller.h"
#include "Perception/AIPerceptionListenerInterface.h"
#include "GenericTeamAgentInterface.h"
#include "VisualLogger/VisualLoggerDebugSnapshotInterface.h"
#include "AIController.generated.h"
 
class FDebugDisplayInfo;
class UAIPerceptionComponent;
class UBehaviorTree;
class UBlackboardComponent;
class UBlackboardData;
class UBrainComponent;
class UCanvas;
class UGameplayTaskResource;
class UGameplayTasksComponent;
class UPathFollowingComponent;
 
namespace EPathFollowingRequestResult { enum Type : int; }
namespace EPathFollowingResult { enum Type : int; }
namespace EPathFollowingStatus { enum Type : int; }
 
#if ENABLE_VISUAL_LOG
struct FVisualLogEntry;
#endif // ENABLE_VISUAL_LOG
struct FPathFindingQuery;
struct FPathFollowingRequestResult;
struct FPathFollowingResult;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FAIMoveCompletedSignature, FAIRequestID, RequestID, EPathFollowingResult::Type, Result);
 
// the reason for this being namespace instead of a regular enum is
// so that it can be expanded in game-specific code
// @todo this is a bit messy, needs to be refactored
namespace EAIFocusPriority
{
    typedef uint8 Type;
 
    inline const Type Default = 0;
    inline const Type Move = 1;
    inline const Type Gameplay = 2;
 
    inline const Type LastFocusPriority = Gameplay;
}
 
struct FFocusKnowledge
{
    struct FFocusItem
    {
        TWeakObjectPtr<AActor> Actor;
        FVector Position;
 
        FFocusItem()
        {
            Actor = nullptr;
            Position = FAISystem::InvalidLocation;
        }
    };
    
    TArray<FFocusItem> Priorities;
};
 
//~=============================================================================
UCLASS(ClassGroup = AI, BlueprintType, Blueprintable, MinimalAPI)
class AAIController : public AController, public IAIPerceptionListenerInterface, public IGameplayTaskOwnerInterface, public IGenericTeamAgentInterface, public IVisualLoggerDebugSnapshotInterface
{
    GENERATED_BODY()
 
    FGameplayResourceSet ScriptClaimedResources;
protected:
    FFocusKnowledge FocusInformation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bStartAILogicOnPossess : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bStopAILogicOnUnposses : 1;
 
public:
    UPROPERTY()
    mutable uint32 bLOSflag : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bSkipExtraLOSChecks : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bAllowStrafe : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bWantsPlayerState : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    uint32 bSetControlRotationFromPawnOrientation:1;
 
private:
 
    UPROPERTY(VisibleDefaultsOnly, Category = AI)
    TObjectPtr<UPathFollowingComponent> PathFollowingComponent;
 
public:
 
    UPROPERTY(BlueprintReadWrite, Category = AI)
    TObjectPtr<UBrainComponent> BrainComponent;
 
    UPROPERTY(VisibleDefaultsOnly, Category = AI)
    TObjectPtr<UAIPerceptionComponent> PerceptionComponent;
 
protected:
    UPROPERTY(BlueprintReadOnly, Category = AI, meta = (AllowPrivateAccess = "true"))
    TObjectPtr<UBlackboardComponent> Blackboard;
 
    UPROPERTY()
    TObjectPtr<UGameplayTasksComponent> CachedGameplayTasksComponent;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AI)
    TSubclassOf<UNavigationQueryFilter> DefaultNavigationFilterClass;
 
public:
 
    AIMODULE_API AAIController(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    AIMODULE_API virtual void SetPawn(APawn* InPawn) override;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation", Meta = (AdvancedDisplay = "bStopOnOverlap,bCanStrafe,bAllowPartialPath"))
    AIMODULE_API EPathFollowingRequestResult::Type MoveToActor(AActor* Goal, float AcceptanceRadius = -1, bool bStopOnOverlap = true,
        bool bUsePathfinding = true, bool bCanStrafe = true,
        TSubclassOf<UNavigationQueryFilter> FilterClass = {}, bool bAllowPartialPath = true);
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation", Meta = (AdvancedDisplay = "bStopOnOverlap,bCanStrafe,bAllowPartialPath"))
    AIMODULE_API EPathFollowingRequestResult::Type MoveToLocation(const FVector& Dest, float AcceptanceRadius = -1, bool bStopOnOverlap = true,
        bool bUsePathfinding = true, bool bProjectDestinationToNavigation = false, bool bCanStrafe = true,
        TSubclassOf<UNavigationQueryFilter> FilterClass = {}, bool bAllowPartialPath = true);
 
    AIMODULE_API virtual FPathFollowingRequestResult MoveTo(const FAIMoveRequest& MoveRequest, FNavPathSharedPtr* OutPath = nullptr);
 
    AIMODULE_API virtual FAIRequestID RequestMove(const FAIMoveRequest& MoveRequest, FNavPathSharedPtr Path);
 
    AIMODULE_API virtual void FindPathForMoveRequest(const FAIMoveRequest& MoveRequest, FPathFindingQuery& Query, FNavPathSharedPtr& OutPath) const;
 
    AIMODULE_API bool BuildPathfindingQuery(const FAIMoveRequest& MoveRequest, FPathFindingQuery& OutQuery) const;
 
    AIMODULE_API bool BuildPathfindingQuery(const FAIMoveRequest& MoveRequest, const FVector& StartLocation, FPathFindingQuery& OutQuery) const;
 
    UE_DEPRECATED_FORGAME(4.13, "This function is now deprecated, please use FindPathForMoveRequest() for adjusting Query or BuildPathfindingQuery() for getting one.")
    AIMODULE_API virtual bool PreparePathfinding(const FAIMoveRequest& MoveRequest, FPathFindingQuery& Query);
 
    UE_DEPRECATED_FORGAME(4.13, "This function is now deprecated, please use FindPathForMoveRequest() for adjusting pathfinding or path postprocess.")
    AIMODULE_API virtual FAIRequestID RequestPathAndMove(const FAIMoveRequest& MoveRequest, FPathFindingQuery& Query);
 
    AIMODULE_API bool PauseMove(FAIRequestID RequestToPause);
 
    AIMODULE_API bool ResumeMove(FAIRequestID RequestToResume);
 
    AIMODULE_API virtual void StopMovement() override;
 
    AIMODULE_API virtual void OnMoveCompleted(FAIRequestID RequestID, const FPathFollowingResult& Result);
 
    UE_DEPRECATED_FORGAME(4.13, "This function is now deprecated, please use version with EPathFollowingResultDetails parameter.")
    AIMODULE_API virtual void OnMoveCompleted(FAIRequestID RequestID, EPathFollowingResult::Type Result);
 
    AIMODULE_API FAIRequestID GetCurrentMoveRequestID() const;
 
    UPROPERTY(BlueprintAssignable, meta = (DisplayName = "MoveCompleted"))
    FAIMoveCompletedSignature ReceiveMoveCompleted;
 
    TSubclassOf<UNavigationQueryFilter> GetDefaultNavigationFilterClass() const { return DefaultNavigationFilterClass; }
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation")
    AIMODULE_API EPathFollowingStatus::Type GetMoveStatus() const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation")
    AIMODULE_API bool HasPartialPath() const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation")
    AIMODULE_API FVector GetImmediateMoveDestination() const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation")
    AIMODULE_API void SetMoveBlockDetection(bool bEnable);
    
    UFUNCTION(BlueprintCallable, Category = "AI")
    AIMODULE_API virtual bool RunBehaviorTree(UBehaviorTree* BTAsset);
 
protected:
    AIMODULE_API virtual void CleanupBrainComponent();
 
    AIMODULE_API virtual void MergePaths(const FNavPathSharedPtr& InitialPath, FNavPathSharedPtr& InOutMergedPath) const;
 
public:
    UFUNCTION(BlueprintCallable, Category = "AI")
    AIMODULE_API bool UseBlackboard(UBlackboardData* BlackboardAsset, UBlackboardComponent*& BlackboardComponent);
 
    AIMODULE_API virtual bool ShouldSyncBlackboardWith(const UBlackboardComponent& OtherBlackboardComponent) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Tasks")
    AIMODULE_API void ClaimTaskResource(TSubclassOf<UGameplayTaskResource> ResourceClass);
    
    UFUNCTION(BlueprintCallable, Category = "AI|Tasks")
    AIMODULE_API void UnclaimTaskResource(TSubclassOf<UGameplayTaskResource> ResourceClass);
 
protected:
    UFUNCTION(BlueprintImplementableEvent)
    AIMODULE_API void OnUsingBlackBoard(UBlackboardComponent* BlackboardComp, UBlackboardData* BlackboardAsset);
 
    AIMODULE_API virtual bool InitializeBlackboard(UBlackboardComponent& BlackboardComp, UBlackboardData& BlackboardAsset);
 
public:
    UFUNCTION(BlueprintCallable, Category = "AI")
    AIMODULE_API FVector GetFocalPoint() const;
 
    AIMODULE_API FVector GetFocalPointForPriority(EAIFocusPriority::Type InPriority) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI")
    AIMODULE_API virtual FVector GetFocalPointOnActor(const AActor *Actor) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI", meta = (DisplayName = "SetFocalPoint", ScriptName = "SetFocalPoint", Keywords = "focus"))
    AIMODULE_API void K2_SetFocalPoint(FVector FP);
 
    UFUNCTION(BlueprintCallable, Category = "AI", meta = (DisplayName = "SetFocus", ScriptName = "SetFocus"))
    AIMODULE_API void K2_SetFocus(AActor* NewFocus);
 
    UFUNCTION(BlueprintCallable, Category = "AI")
    AIMODULE_API AActor* GetFocusActor() const;
 
    inline AActor* GetFocusActorForPriority(EAIFocusPriority::Type InPriority) const { return FocusInformation.Priorities.IsValidIndex(InPriority) ? FocusInformation.Priorities[InPriority].Actor.Get() : nullptr; }
 
    UFUNCTION(BlueprintCallable, Category = "AI", meta = (DisplayName = "ClearFocus", ScriptName = "ClearFocus"))
    AIMODULE_API void K2_ClearFocus();
 
 
    AIMODULE_API bool SuggestTossVelocity(FVector& OutTossVelocity, FVector Start, FVector End, float TossSpeed, bool bPreferHighArc, float CollisionRadius = 0, bool bOnlyTraceUp = false);
 
    //~ Begin AActor Interface
    AIMODULE_API virtual void Tick(float DeltaTime) override;
    AIMODULE_API virtual void PostInitializeComponents() override;
    AIMODULE_API virtual void PostRegisterAllComponents() override;
    //~ End AActor Interface
 
    //~ Begin AController Interface
protected:
    AIMODULE_API virtual void OnPossess(APawn* InPawn) override;
    AIMODULE_API virtual void OnUnPossess() override;
 
public:
    AIMODULE_API virtual bool ShouldPostponePathUpdates() const override;
    AIMODULE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
 
#if ENABLE_VISUAL_LOG
    AIMODULE_API virtual void GrabDebugSnapshot(FVisualLogEntry* Snapshot) const override;
#endif
 
    AIMODULE_API virtual void Reset() override;
 
    AIMODULE_API virtual bool LineOfSightTo(const AActor* Other, FVector ViewPoint = FVector(ForceInit), bool bAlternateChecks = false) const override;
    //~ End AController Interface
 
    AIMODULE_API virtual void ActorsPerceptionUpdated(const TArray<AActor*>& UpdatedActors);
 
    AIMODULE_API virtual void UpdateControlRotation(float DeltaTime, bool bUpdatePawn = true);
 
    AIMODULE_API virtual void SetFocalPoint(FVector NewFocus, EAIFocusPriority::Type InPriority = EAIFocusPriority::Gameplay);
 
    /* Set Focus actor for given priority, will set FocalPoint as a result. */
    AIMODULE_API virtual void SetFocus(AActor* NewFocus, EAIFocusPriority::Type InPriority = EAIFocusPriority::Gameplay);
 
    AIMODULE_API virtual void ClearFocus(EAIFocusPriority::Type InPriority);
 
    AIMODULE_API void SetPerceptionComponent(UAIPerceptionComponent& InPerceptionComponent);
    //----------------------------------------------------------------------//
    // IAIPerceptionListenerInterface
    //----------------------------------------------------------------------//
    virtual UAIPerceptionComponent* GetPerceptionComponent() override { return GetAIPerceptionComponent(); }
 
    //----------------------------------------------------------------------//
    // INavAgentInterface
    //----------------------------------------------------------------------//
    AIMODULE_API virtual bool IsFollowingAPath() const override;
    AIMODULE_API virtual IPathFollowingAgentInterface* GetPathFollowingAgent() const override;
 
    //----------------------------------------------------------------------//
    // IGenericTeamAgentInterface
    //----------------------------------------------------------------------//
private:
    FGenericTeamId TeamID;
public:
    AIMODULE_API virtual void SetGenericTeamId(const FGenericTeamId& NewTeamID) override;
    virtual FGenericTeamId GetGenericTeamId() const override { return TeamID; }
 
    //----------------------------------------------------------------------//
    // IGameplayTaskOwnerInterface
    //----------------------------------------------------------------------//
    virtual UGameplayTasksComponent* GetGameplayTasksComponent(const UGameplayTask& Task) const override { return GetGameplayTasksComponent(); }
    virtual AActor* GetGameplayTaskOwner(const UGameplayTask* Task) const override { return const_cast<AAIController*>(this); }
    virtual AActor* GetGameplayTaskAvatar(const UGameplayTask* Task) const override { return GetPawn(); }
    virtual uint8 GetGameplayTaskDefaultPriority() const { return FGameplayTasks::DefaultPriority - 1; }
 
    inline UGameplayTasksComponent* GetGameplayTasksComponent() const { return CachedGameplayTasksComponent; }
 
    // add empty overrides to fix linker errors if project implements a child class without adding GameplayTasks module dependency
    virtual void OnGameplayTaskInitialized(UGameplayTask& Task) override {}
    virtual void OnGameplayTaskActivated(UGameplayTask& Task) override {}
    virtual void OnGameplayTaskDeactivated(UGameplayTask& Task) override {}
 
    UFUNCTION()
    AIMODULE_API virtual void OnGameplayTaskResourcesClaimed(FGameplayResourceSet NewlyClaimed, FGameplayResourceSet FreshlyReleased);
 
    //----------------------------------------------------------------------//
    // debug/dev-time 
    //----------------------------------------------------------------------//
    AIMODULE_API virtual FString GetDebugIcon() const;
    
    // Cheat/debugging functions
    static void ToggleAIIgnorePlayers() { bAIIgnorePlayers = !bAIIgnorePlayers; }
    static bool AreAIIgnoringPlayers() { return bAIIgnorePlayers; }
 
    static AIMODULE_API bool bAIIgnorePlayers;
 
public:
    UFUNCTION(BlueprintCallable, Category="AI|Navigation")
    UPathFollowingComponent* GetPathFollowingComponent() const { return PathFollowingComponent; }
    UFUNCTION(BlueprintPure, Category = "AI|Perception")
    UAIPerceptionComponent* GetAIPerceptionComponent() { return PerceptionComponent; }
 
    const UAIPerceptionComponent* GetAIPerceptionComponent() const { return PerceptionComponent; }
 
    UBrainComponent* GetBrainComponent() const { return BrainComponent; }
    const UBlackboardComponent* GetBlackboardComponent() const { return Blackboard; }
    UBlackboardComponent* GetBlackboardComponent() { return Blackboard; }
 
    UFUNCTION(BlueprintCallable, Category = "AI|Navigation")
    AIMODULE_API void SetPathFollowingComponent(UPathFollowingComponent* NewPFComponent);
};
 
//----------------------------------------------------------------------//
// forceinlines
//----------------------------------------------------------------------//
namespace FAISystem
{
    inline bool IsValidControllerAndHasValidPawn(const AController* Controller)
    {
        return Controller != nullptr && Controller->IsPendingKillPending() == false
            && Controller->GetPawn() != nullptr && Controller->GetPawn()->IsPendingKillPending() == false;
    }
}