PathFollowingComponent.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/WeakObjectPtr.h"
#include "Engine/EngineTypes.h"
#include "Components/ActorComponent.h"
#include "EngineDefines.h"
#include "AI/Navigation/NavigationTypes.h"
#include "NavigationData.h"
#include "AITypes.h"
#include "AIResourceInterface.h"
#include "GameFramework/NavMovementComponent.h"
#include "AI/Navigation/PathFollowingAgentInterface.h"
#include "PathFollowingComponent.generated.h"
 
class Error;
class FDebugDisplayInfo;
class INavLinkCustomInterface;
class UCanvas;
class ANavigationData;
 
AIMODULE_API DECLARE_LOG_CATEGORY_EXTERN(LogPathFollowing, Warning, All);
 
class UCanvas;
class AActor;
class INavLinkCustomInterface;
class INavAgentInterface;
class UNavigationComponent;
 
UENUM(BlueprintType)
namespace EPathFollowingStatus
{
    enum Type : int
    {
        Idle,
 
        Waiting,
 
        Paused,
 
        Moving,
    };
}
 
UENUM(BlueprintType)
namespace EPathFollowingResult
{
    enum Type : int
    {
        Success,
 
        Blocked,
 
        OffPath,
 
        Aborted,
 
        Skipped_DEPRECATED UMETA(Hidden),
 
        Invalid,
    };
}
 
namespace FPathFollowingResultFlags
{
    typedef uint16 Type;
 
    inline const Type None = 0;
 
    inline const Type Success = (1 << 0);
 
    inline const Type Blocked = (1 << 1);
 
    inline const Type OffPath = (1 << 2);
 
    inline const Type UserAbort = (1 << 3);
 
    inline const Type OwnerFinished = (1 << 4);
 
    inline const Type InvalidPath = (1 << 5);
 
    inline const Type MovementStop = (1 << 6);
 
    inline const Type NewRequest = (1 << 7);
 
    inline const Type ForcedScript = (1 << 8);
 
    inline const Type AlreadyAtGoal = (1 << 9);
 
    inline const Type FirstGameplayFlagShift = 10;
 
    inline const Type UserAbortFlagMask = ~(Success | Blocked | OffPath);
 
    FString ToString(uint16 Value);
}
 
struct FPathFollowingResult
{
    FPathFollowingResultFlags::Type Flags;
    TEnumAsByte<EPathFollowingResult::Type> Code;
 
    FPathFollowingResult() : Flags(0), Code(EPathFollowingResult::Invalid)  {}
    AIMODULE_API FPathFollowingResult(FPathFollowingResultFlags::Type InFlags);
    AIMODULE_API FPathFollowingResult(EPathFollowingResult::Type ResultCode, FPathFollowingResultFlags::Type ExtraFlags);
 
    bool HasFlag(FPathFollowingResultFlags::Type Flag) const { return (Flags & Flag) != 0; }
 
    bool IsSuccess() const { return HasFlag(FPathFollowingResultFlags::Success); }
    bool IsFailure() const { return !HasFlag(FPathFollowingResultFlags::Success); }
    bool IsInterrupted() const { return HasFlag(FPathFollowingResultFlags::UserAbort | FPathFollowingResultFlags::NewRequest); }
    
    AIMODULE_API FString ToString() const;
};
 
// DEPRECATED, will be removed with GetPathActionType function
UENUM(BlueprintType)
namespace EPathFollowingAction
{
    enum Type : int
    {
        Error,
        NoMove,
        DirectMove,
        PartialPath,
        PathToGoal,
    };
}
 
UENUM(BlueprintType)
namespace EPathFollowingRequestResult
{
    enum Type : int
    {
        Failed,
        AlreadyAtGoal,
        RequestSuccessful
    };
}
 
struct FPathFollowingRequestResult
{
    FAIRequestID MoveId;
    TEnumAsByte<EPathFollowingRequestResult::Type> Code;
 
    FPathFollowingRequestResult() : MoveId(FAIRequestID::InvalidRequest), Code(EPathFollowingRequestResult::Failed) {}
    operator EPathFollowingRequestResult::Type() const { return Code; }
};
 
namespace EPathFollowingDebugTokens
{
    enum Type : int
    {
        Description,
        ParamName,
        FailedValue,
        PassedValue,
    };
}
 
// DEPRECATED, please use EPathFollowingResultDetails instead, will be removed with deprecated override of AbortMove function
namespace EPathFollowingMessage
{
    enum Type : int
    {
        NoPath,
        OtherRequest,
    };
}
 
enum class EPathFollowingVelocityMode : uint8
{
    Reset,
    Keep,
};
 
enum class EPathFollowingReachMode : uint8
{
    ExactLocation,
 
    OverlapAgent,
 
    OverlapGoal,
 
    OverlapAgentAndGoal,
};
 
UCLASS(config=Engine, MinimalAPI)
class UPathFollowingComponent : public UActorComponent, public IAIResourceInterface, public IPathFollowingAgentInterface
{
    GENERATED_UCLASS_BODY()
 
    DECLARE_DELEGATE_TwoParams(FPostProcessMoveSignature, UPathFollowingComponent* /*comp*/, FVector& /*velocity*/);
    DECLARE_DELEGATE_OneParam(FRequestCompletedSignature, EPathFollowingResult::Type /*Result*/);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FMoveCompletedSignature, FAIRequestID /*RequestID*/, EPathFollowingResult::Type /*Result*/);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FMoveComplete, FAIRequestID /*RequestID*/, const FPathFollowingResult& /*Result*/);
 
    FPostProcessMoveSignature PostProcessMove;
 
    FMoveComplete OnRequestFinished;
 
    //~ Begin UActorComponent Interface
    AIMODULE_API virtual void OnRegister() override;
    AIMODULE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    //~ End UActorComponent Interface
 
    AIMODULE_API virtual void Initialize();
 
    AIMODULE_API virtual void Cleanup();
 
    AIMODULE_API virtual void UpdateCachedComponents();
 
    AIMODULE_API virtual FAIRequestID RequestMove(const FAIMoveRequest& RequestData, FNavPathSharedPtr InPath);
 
    AIMODULE_API virtual void AbortMove(const UObject& Instigator, FPathFollowingResultFlags::Type AbortFlags, FAIRequestID RequestID = FAIRequestID::CurrentRequest, EPathFollowingVelocityMode VelocityMode = EPathFollowingVelocityMode::Reset);
 
    AIMODULE_API FAIRequestID RequestMoveWithImmediateFinish(EPathFollowingResult::Type Result, EPathFollowingVelocityMode VelocityMode = EPathFollowingVelocityMode::Reset);
 
    AIMODULE_API virtual void PauseMove(FAIRequestID RequestID = FAIRequestID::CurrentRequest, EPathFollowingVelocityMode VelocityMode = EPathFollowingVelocityMode::Reset);
 
    AIMODULE_API virtual void ResumeMove(FAIRequestID RequestID = FAIRequestID::CurrentRequest);
 
    AIMODULE_API virtual void OnPathFinished(const FPathFollowingResult& Result);
 
    inline void OnPathFinished(EPathFollowingResult::Type ResultCode, uint16 ExtraResultFlags) { OnPathFinished(FPathFollowingResult(ResultCode, ExtraResultFlags)); }
 
    AIMODULE_API virtual void OnSegmentFinished();
 
    AIMODULE_API virtual void OnPathUpdated();
 
    UE_DEPRECATED(5.5, "SetMovementComponent(UNavMovementComponent* MoveComp) is deprecated, please use SetNavMoveInterface(INavMoveInterface* NavMoveInterface) instead.")
    AIMODULE_API virtual void SetMovementComponent(UNavMovementComponent* MoveComp) final;
 
    AIMODULE_API virtual void SetNavMovementInterface(INavMovementInterface* NavMoveInterface);
 
    AIMODULE_API virtual FVector GetMoveFocus(bool bAllowStrafe) const;
 
    AIMODULE_API bool HasReached(const FVector& TestPoint, EPathFollowingReachMode ReachMode, float AcceptanceRadius = UPathFollowingComponent::DefaultAcceptanceRadius) const;
 
    AIMODULE_API bool HasReached(const AActor& TestGoal, EPathFollowingReachMode ReachMode, float AcceptanceRadius = UPathFollowingComponent::DefaultAcceptanceRadius, bool bUseNavAgentGoalLocation = true) const;
 
    AIMODULE_API bool HasReached(const FAIMoveRequest& MoveRequest) const;
 
    AIMODULE_API void SetBlockDetectionState(bool bEnable);
 
    bool IsBlockDetectionActive() const { return bUseBlockDetection; }
 
    AIMODULE_API void SetBlockDetection(float DistanceThreshold, float Interval, int32 NumSamples);
 
    bool IsDecelerating() const { return bIsDecelerating; };
 
    inline bool IsStopMovementOnFinishActive() const { return bStopMovementOnFinish; }
    
    inline void SetStopMovementOnFinish(bool bEnable) { bStopMovementOnFinish = bEnable; }
 
    AIMODULE_API void SetPreciseReachThreshold(float AgentRadiusMultiplier, float AgentHalfHeightMultiplier);
 
    AIMODULE_API void SetLastMoveAtGoal(bool bFinishedAtGoal);
 
    AIMODULE_API FVector::FReal GetRemainingPathCost() const;
    
    AIMODULE_API FNavLocation GetCurrentNavLocation() const;
 
    inline EPathFollowingStatus::Type GetStatus() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return Status;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
    inline float GetAcceptanceRadius() const { return AcceptanceRadius; }
    inline float GetDefaultAcceptanceRadius() const { return MyDefaultAcceptanceRadius; }
    AIMODULE_API void SetAcceptanceRadius(const float InAcceptanceRadius);
    inline AActor* GetMoveGoal() const { return DestinationActor.Get(); }
    inline bool HasPartialPath() const { return Path.IsValid() && Path->IsPartial(); }
    inline bool DidMoveReachGoal() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return bLastMoveReachedGoal && (Status == EPathFollowingStatus::Idle);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    inline FAIRequestID GetCurrentRequestId() const { return CurrentRequestId; }
    inline uint32 GetCurrentPathIndex() const { return MoveSegmentStartIndex; }
    inline uint32 GetNextPathIndex() const { return MoveSegmentEndIndex; }
    inline UObject* GetCurrentCustomLinkOb() const { return CurrentCustomLinkOb.Get(); }
    inline FVector GetCurrentTargetLocation() const { return *CurrentDestination; }
    inline FBasedPosition GetCurrentTargetLocationBased() const { return CurrentDestination; }
    inline FVector GetMoveGoalLocationOffset() const { return MoveOffset; }
    bool HasStartedNavLinkMove() const { return bWalkingNavLinkStart; }
    AIMODULE_API bool IsCurrentSegmentNavigationLink() const;
    AIMODULE_API FVector GetCurrentDirection() const;
    FVector GetCurrentMoveInput() const { return CurrentMoveInput; }
 
    inline bool HasMovementAuthority() const { return (NavMovementInterface == nullptr) || NavMovementInterface->CanStopPathFollowing(); }
 
    inline const FNavPathSharedPtr GetPath() const { return Path; }
    inline bool HasValidPath() const { return Path.IsValid() && Path->IsValid(); }
    AIMODULE_API bool HasDirectPath() const;
 
    AIMODULE_API FString GetStatusDesc() const;
    AIMODULE_API FString GetResultDesc(EPathFollowingResult::Type Result) const;
 
    AIMODULE_API void SetDestinationActor(const AActor* InDestinationActor);
 
    virtual int32 GetCurrentPathElement() const { return MoveSegmentEndIndex; }
 
    AIMODULE_API virtual void GetDebugStringTokens(TArray<FString>& Tokens, TArray<EPathFollowingDebugTokens::Type>& Flags) const;
    AIMODULE_API virtual FString GetDebugString() const;
 
    AIMODULE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) const;
#if ENABLE_VISUAL_LOG
    AIMODULE_API virtual void DescribeSelfToVisLog(struct FVisualLogEntry* Snapshot) const;
#endif // ENABLE_VISUAL_LOG
 
    UFUNCTION()
    AIMODULE_API virtual void OnActorBump(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit);
 
    //~ IPathFollowingAgentInterface begin
    AIMODULE_API virtual void OnUnableToMove(const UObject& Instigator) override;
    AIMODULE_API virtual void OnStartedFalling() override;
    virtual void OnLanded() override {}
    AIMODULE_API virtual bool IsFollowingNavLink() const override;
    //~ IPathFollowingAgentInterface end
 
    AIMODULE_API virtual bool IsPathFollowingAllowed() const;
 
    AIMODULE_API virtual void FinishUsingCustomLink(INavLinkCustomInterface* CustomNavLink);
 
    virtual void OnPathfindingQuery(FPathFindingQuery& Query) {}
 
    //~ IAIResourceInterface begin
    AIMODULE_API virtual void LockResource(EAIRequestPriority::Type LockSource) override;
    AIMODULE_API virtual void ClearResourceLock(EAIRequestPriority::Type LockSource) override;
    AIMODULE_API virtual void ForceUnlockResource() override;
    AIMODULE_API virtual bool IsResourceLocked() const override;
    //~ IAIResourceInterface end
 
    AIMODULE_API void OnPathEvent(FNavigationPath* InPath, ENavPathEvent::Type Event);
 
    static AIMODULE_API void LogPathHelper(const AActor* LogOwner, FNavPathSharedPtr InLogPath, const AActor* LogGoalActor);
    static AIMODULE_API void LogPathHelper(const AActor* LogOwner, FNavigationPath* InLogPath, const AActor* LogGoalActor);
 
    UFUNCTION(BlueprintCallable, Category="AI|Components|PathFollowing", meta = (DeprecatedFunction, DeprecationMessage = "This function is now deprecated, please use AIController.GetMoveStatus instead"))
    AIMODULE_API EPathFollowingAction::Type GetPathActionType() const;
 
    UFUNCTION(BlueprintCallable, Category="AI|Components|PathFollowing", meta = (DeprecatedFunction, DeprecationMessage = "This function is now deprecated, please use AIController.GetImmediateMoveDestination instead"))
    AIMODULE_API FVector GetPathDestination() const;
 
#if WITH_EDITORONLY_DATA
    // This delegate is now deprecated, please use OnRequestFinished instead
    FMoveCompletedSignature OnMoveFinished_DEPRECATED;
#endif
 
protected:
    AIMODULE_API void SetStatus(EPathFollowingStatus::Type InStatus);
 
    UE_DEPRECATED(5.5, "MovementComp is deprecated, please use NavMovementComp and the INavMoveInterface instead.")
    UPROPERTY(transient, meta = (DeprecatedProperty, DeprecationMessage = "MovementComp is deprecated, please use NavMovementInterface and the INavMoveInterface instead."))
    TObjectPtr<UNavMovementComponent> MovementComp;
    
    TWeakInterfacePtr<INavMovementInterface> NavMovementInterface;
 
    FWeakObjectPtr CurrentCustomLinkOb;
 
    FWeakObjectPtr MoveSegmentCustomLinkOb;
 
    UPROPERTY(transient)
    TObjectPtr<ANavigationData> MyNavData;
 
    FNavPathSharedPtr Path;
 
    FSharedConstNavQueryFilter NavigationFilter;
 
    float MyDefaultAcceptanceRadius;
 
    float AcceptanceRadius;
 
    float CurrentAcceptanceRadius;
 
    float MinAgentRadiusPct;
 
    float MinAgentHalfHeightPct;
 
    float WaitingTimeout;
 
    FCustomMoveSharedPtr GameData;
 
    TWeakObjectPtr<AActor> DestinationActor;
 
    const INavAgentInterface* DestinationAgent;
 
    FBasedPosition CurrentDestination;
 
    FVector CurrentMoveInput;
 
    FVector MoveOffset;
 
    FVector LocationWhenPaused;
 
    FVector OriginalMoveRequestGoalLocation;
 
    double PathTimeWhenPaused;
 
    int32 PreciseAcceptanceRadiusCheckStartNodeIndex;
 
    UE_DEPRECATED_FORGAME(5.6, "This member should no longer be accessed directly, please use GetStatus/SetStatus instead.")
    TEnumAsByte<EPathFollowingStatus::Type> Status;
 
    uint8 bReachTestIncludesAgentRadius : 1;
 
    uint8 bReachTestIncludesGoalRadius : 1;
 
    uint8 bMoveToGoalOnLastSegment : 1;
 
    uint8 bMoveToGoalClampedToNavigation : 1;
 
    uint8 bUseBlockDetection : 1;
 
    uint8 bCollidedWithGoal : 1;
 
    uint8 bLastMoveReachedGoal : 1;
 
    uint8 bStopMovementOnFinish : 1;
 
    uint8 bIsUsingMetaPath : 1;
 
    uint8 bWalkingNavLinkStart : 1;
 
    uint8 bIsDecelerating : 1;
 
    uint8 bMoveSegmentIsUsingCustomLinkReachCondition : 1;
 
    uint8 bTickComponentOnlyWhenMoving : 1;
 
    float BlockDetectionDistance;
 
    float BlockDetectionInterval;
 
    int32 BlockDetectionSampleCount;
 
    double LastSampleTime;
 
    int32 NextSampleIdx;
 
    TArray<FBasedPosition> LocationSamples;
 
    int32 MoveSegmentStartIndex;
 
    int32 MoveSegmentEndIndex;
 
    NavNodeRef MoveSegmentStartRef;
 
    NavNodeRef MoveSegmentEndRef;
 
    FVector MoveSegmentDirection;
 
    float CachedBrakingDistance;
 
    float CachedBrakingMaxSpeed;
 
    int32 DecelerationSegmentIndex;
 
    AIMODULE_API FSharedConstNavQueryFilter ExtractNavigationFilter(const FAIMoveRequest& RequestData, FNavPathSharedPtr InPath) const;
 
    AIMODULE_API virtual void Reset();
 
    AIMODULE_API virtual void OnNewPawn(APawn* NewPawn);
 
    AIMODULE_API virtual bool ShouldCheckPathOnResume() const;
 
    AIMODULE_API virtual void SetMoveSegment(int32 SegmentStartIndex);
    
    AIMODULE_API virtual void FollowPathSegment(float DeltaTime);
 
    AIMODULE_API virtual void UpdatePathSegment();
 
    AIMODULE_API virtual void StartUsingCustomLink(INavLinkCustomInterface* CustomNavLink, const FVector& DestPoint);
 
    AIMODULE_API virtual bool UpdateBlockDetection();
 
    AIMODULE_API virtual void UpdateDecelerationData();
 
    AIMODULE_API virtual bool HasReachedDestination(const FVector& CurrentLocation) const;
 
    AIMODULE_API virtual bool HasReachedCurrentTarget(const FVector& CurrentLocation) const;
 
    AIMODULE_API bool HasReachedInternal(const FVector& GoalLocation, float GoalRadius, float GoalHalfHeight, const FVector& AgentLocation, float RadiusThreshold, float AgentRadiusMultiplier) const;
 
    AIMODULE_API void ResetMoveSegmentCustomLinkCache();
 
    AIMODULE_API virtual bool IsOnPath() const;
 
    AIMODULE_API bool IsBlocked() const;
 
    inline void SetNextMoveSegment() { SetMoveSegment(GetNextPathIndex()); }
 
    inline void StoreRequestId() { CurrentRequestId = UPathFollowingComponent::GetNextRequestId(); }
 
    inline static uint32 GetNextRequestId() { return NextRequestId++; }
 
    AIMODULE_API virtual int32 DetermineStartingPathPoint(const FNavigationPath* ConsideredPath) const;
 
    AIMODULE_API virtual int32 DetermineCurrentTargetPathPoint(int32 StartIndex);
 
    AIMODULE_API virtual bool UpdateMovementComponent(bool bForce = false);
 
    AIMODULE_API virtual bool HandlePathUpdateEvent();
 
    AIMODULE_API virtual void OnWaitingPathTimeout();
 
    AIMODULE_API void ResetBlockDetectionData();
 
    AIMODULE_API void ForceBlockDetectionUpdate();
 
    AIMODULE_API virtual void UpdateMoveFocus();
 
    AIMODULE_API virtual bool ShouldStopMovementOnPathFinished() const; 
 
    AIMODULE_API int32 FindPreciseAcceptanceRadiusTestsStartNodeIndex(const FNavigationPath& PathInstance, const FVector& GoalLocation) const;
 
    AIMODULE_API float GetFinalAcceptanceRadius(const FNavigationPath& PathInstance, const FVector OriginalGoalLocation, const FVector* PathEndOverride = nullptr) const;
 
    AIMODULE_API void DebugReachTest(float& CurrentDot, float& CurrentDistance, float& CurrentHeight, uint8& bDotFailed, uint8& bDistanceFailed, uint8& bHeightFailed) const;
 
    AIMODULE_API virtual void OnNavigationInitDone();
 
    UFUNCTION()
    AIMODULE_API void OnNavDataRegistered(ANavigationData* NavData);
 
 
    FAIResourceLock ResourceLock;
 
    FTimerHandle WaitingForPathTimer;
 
private:
 
    static AIMODULE_API uint32 NextRequestId;
    FAIRequestID CurrentRequestId;
 
    mutable FNavLocation CurrentNavLocation;
 
public:
    static AIMODULE_API const float DefaultAcceptanceRadius;
 
#if !UE_BUILD_SHIPPING
    uint8 DEBUG_bMovingDirectlyToGoal : 1;
#endif // !UE_BUILD_SHIPPING
};