AIPerceptionComponent.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/ObjectKey.h"
#include "Templates/SubclassOf.h"
#include "Components/ActorComponent.h"
#include "EngineDefines.h"
#include "GenericTeamAgentInterface.h"
#include "Perception/AIPerceptionTypes.h"
#include "Perception/AISense.h"
#include "Perception/AIPerceptionSystem.h"
#include "AIPerceptionComponent.generated.h"
 
class AAIController;
class FGameplayDebuggerCategory;
class UAISenseConfig;
struct FVisualLogEntry;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPerceptionUpdatedDelegate, const TArray<AActor*>&, UpdatedActors);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FActorPerceptionUpdatedDelegate, AActor*, Actor, FAIStimulus, Stimulus);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FActorPerceptionForgetUpdatedDelegate, AActor*, Actor);
 
USTRUCT(BlueprintType, meta = (DisplayName = "Sensed Actor's Update Data"))
struct FActorPerceptionUpdateInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    int32 TargetId = -1;
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    TWeakObjectPtr<AActor> Target;
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    FAIStimulus Stimulus;
 
    FActorPerceptionUpdateInfo() = default;
    FActorPerceptionUpdateInfo(const int32 TargetId, const TWeakObjectPtr<AActor>& Target, const FAIStimulus& Stimulus);
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FActorPerceptionInfoUpdatedDelegate, const FActorPerceptionUpdateInfo&, UpdateInfo);
 
struct FActorPerceptionInfo
{
    TWeakObjectPtr<AActor> Target;
 
    TArray<FAIStimulus> LastSensedStimuli;
 
    FAISenseID DominantSense;
 
    uint32 bIsHostile : 1;
 
    uint32 bIsFriendly : 1;
 
    explicit FActorPerceptionInfo(AActor* InTarget = nullptr)
        : Target(InTarget), DominantSense(FAISenseID::InvalidID()), bIsHostile(false), bIsFriendly(false)
    {
        LastSensedStimuli.AddDefaulted(FAISenseID::GetSize());
    }
 
    FVector GetLastStimulusLocation(float* OptionalAge = nullptr) const 
    {
        FVector Location(FAISystem::InvalidLocation);
        float BestAge = FLT_MAX;
        bool bBestWasSuccessfullySensed = false;
        for (int32 Sense = 0; Sense < LastSensedStimuli.Num(); ++Sense)
        {
            const float Age = LastSensedStimuli[Sense].GetAge();
            const bool bWasSuccessfullySensed = LastSensedStimuli[Sense].WasSuccessfullySensed();
 
            if (Age >= 0 && (Age < BestAge 
                || (bBestWasSuccessfullySensed == false && bWasSuccessfullySensed)
                || (Sense == DominantSense && bWasSuccessfullySensed)))
            {
                BestAge = Age;
                Location = LastSensedStimuli[Sense].StimulusLocation;
                bBestWasSuccessfullySensed = bWasSuccessfullySensed;
 
                if (Sense == DominantSense && bWasSuccessfullySensed)
                {
                    // if dominant sense is active we don't want to look any further 
                    break;
                }
            }
        }
 
        if (OptionalAge)
        {
            *OptionalAge = BestAge;
        }
 
        return Location;
    }
 
    bool HasAnyKnownStimulus() const
    {
        for (const FAIStimulus& Stimulus : LastSensedStimuli)
        {
            // not that WasSuccessfullySensed will return 'false' for expired stimuli
            if (Stimulus.IsValid() && (Stimulus.WasSuccessfullySensed() == true || Stimulus.IsExpired() == false))
            {
                return true;
            }
        }
 
        return false;
    }
 
    bool HasAnyCurrentStimulus() const
    {
        for (const FAIStimulus& Stimulus : LastSensedStimuli)
        {
            // not that WasSuccessfullySensed will return 'false' for expired stimuli
            if (Stimulus.IsValid() && Stimulus.WasSuccessfullySensed() == true && Stimulus.IsExpired() == false)
            {
                return true;
            }
        }
 
        return false;
    }
 
    inline FVector GetStimulusLocation(const FAISenseID Sense) const
    {
        return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false)) ? LastSensedStimuli[Sense].StimulusLocation : FAISystem::InvalidLocation;
    }
 
    inline FVector GetReceiverLocation(const FAISenseID Sense) const
    {
        return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false)) ? LastSensedStimuli[Sense].ReceiverLocation : FAISystem::InvalidLocation;
    }
 
    inline bool HasKnownStimulusOfSense(const FAISenseID Sense) const
    {
        return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false));
    }
 
    inline bool IsSenseActive(const FAISenseID Sense) const
    {
        return LastSensedStimuli.IsValidIndex(Sense) && LastSensedStimuli[Sense].IsActive();
    }
    
    AIMODULE_API void Merge(const FActorPerceptionInfo& Other);
};
 
USTRUCT(BlueprintType, meta = (DisplayName = "Sensed Actor's Data"))
struct FActorPerceptionBlueprintInfo
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    TObjectPtr<AActor> Target;
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    TArray<FAIStimulus> LastSensedStimuli;
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    uint32 bIsHostile : 1;
 
    UPROPERTY(BlueprintReadWrite, Category = "AI|Perception")
    uint32 bIsFriendly : 1;
 
    FActorPerceptionBlueprintInfo() : Target(nullptr), bIsHostile(false), bIsFriendly(false)
    {}
    FActorPerceptionBlueprintInfo(const FActorPerceptionInfo& Info);
};
 
UCLASS(ClassGroup=AI, HideCategories=(Activation, Collision), meta=(BlueprintSpawnableComponent), config=Game, MinimalAPI)
class UAIPerceptionComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
    
    static AIMODULE_API const int32 InitialStimuliToProcessArraySize;
 
    typedef TMap<TObjectKey<AActor>, FActorPerceptionInfo> TActorPerceptionContainer;
    typedef TActorPerceptionContainer FActorPerceptionContainer;
 
protected:
    UPROPERTY(EditDefaultsOnly, Instanced, Category = "AI Perception")
    TArray<TObjectPtr<UAISenseConfig>> SensesConfig;
 
    UPROPERTY(EditDefaultsOnly, Category = "AI Perception")
    TSubclassOf<UAISense> DominantSense;
    
    FAISenseID DominantSenseID;
 
    UPROPERTY(Transient)
    TObjectPtr<AAIController> AIOwner;
 
    FPerceptionChannelAllowList PerceptionFilter;
 
private:
    FPerceptionListenerID PerceptionListenerId;
    FActorPerceptionContainer PerceptualData;
        
protected:  
    struct FStimulusToProcess
    {
        TObjectKey<AActor> Source;
        FAIStimulus Stimulus;
 
        FStimulusToProcess(AActor* InSource, const FAIStimulus& InStimulus)
            : Source(InSource), Stimulus(InStimulus)
        {
 
        }
    };
 
    TArray<FStimulusToProcess> StimuliToProcess; 
    
    TArray<float> MaxActiveAge;
 
private:
 
    uint32 bForgetStaleActors : 1;
 
    uint32 bCleanedUp : 1;
 
public:
 
    AIMODULE_API virtual void PostInitProperties() override;
    AIMODULE_API virtual void BeginDestroy() override;
    AIMODULE_API virtual void OnRegister() override;
    AIMODULE_API virtual void OnUnregister() override;
 
    UFUNCTION()
    AIMODULE_API void OnOwnerEndPlay(AActor* Actor, EEndPlayReason::Type EndPlayReason);
    
    AIMODULE_API void GetLocationAndDirection(FVector& Location, FVector& Direction) const;
    AIMODULE_API const AActor* GetBodyActor() const;
    AIMODULE_API AActor* GetMutableBodyActor();
 
    inline FPerceptionChannelAllowList GetPerceptionFilter() const { return PerceptionFilter; }
 
    AIMODULE_API FGenericTeamId GetTeamIdentifier() const;
    inline FPerceptionListenerID GetListenerId() const { return PerceptionListenerId; }
 
    AIMODULE_API FVector GetActorLocation(const AActor& Actor) const;
    inline const FActorPerceptionInfo* GetActorInfo(const AActor& Actor) const { return PerceptualData.Find(&Actor); }
    inline FActorPerceptionContainer::TIterator GetPerceptualDataIterator() { return FActorPerceptionContainer::TIterator(PerceptualData); }
    inline FActorPerceptionContainer::TConstIterator GetPerceptualDataConstIterator() const { return FActorPerceptionContainer::TConstIterator(PerceptualData); }
 
    AIMODULE_API virtual void GetHostileActors(TArray<AActor*>& OutActors) const;
    
    AIMODULE_API void GetHostileActorsBySense(TSubclassOf<UAISense> SenseToFilterBy, TArray<AActor*>& OutActors) const;
 
    AIMODULE_API bool GetFilteredActors(const TFunctionRef<bool(const FActorPerceptionInfo&)>& Predicate, TArray<AActor*>& OutActors) const;
 
    // @note Will stop on first age 0 stimulus
    AIMODULE_API const FActorPerceptionInfo* GetFreshestTrace(const FAISenseID Sense) const;
    
    AIMODULE_API void SetDominantSense(TSubclassOf<UAISense> InDominantSense);
    inline FAISenseID GetDominantSenseID() const { return DominantSenseID; }
    inline TSubclassOf<UAISense> GetDominantSense() const { return DominantSense; }
    AIMODULE_API UAISenseConfig* GetSenseConfig(const FAISenseID& SenseID);
    AIMODULE_API const UAISenseConfig* GetSenseConfig(const FAISenseID& SenseID) const;
 
    template<typename T, typename = std::enable_if_t<std::is_base_of_v<UAISenseConfig, T>>>
    T* GetSenseConfig() const
    {
        for (UAISenseConfig* SenseConfig : SensesConfig)
        {
            if (T* SenseConfigType = Cast<T>(SenseConfig))
            {
                return SenseConfigType;
            }
        }
        return nullptr;
    }
    
    AIMODULE_API void ConfigureSense(UAISenseConfig& SenseConfig);
 
    typedef TArray<UAISenseConfig*>::TConstIterator TAISenseConfigConstIterator;
    AIMODULE_API TAISenseConfigConstIterator GetSensesConfigIterator() const;
 
    UFUNCTION(BlueprintCallable, Category="AI|Perception")
    AIMODULE_API void RequestStimuliListenerUpdate();
 
    AIMODULE_API void UpdatePerceptionAllowList(const FAISenseID Channel, const bool bNewValue);
 
    UE_DEPRECATED(5.0, "Use UpdatePerceptionAllowList instead")
    void UpdatePerceptionWhitelist(const FAISenseID Channel, const bool bNewValue)
    {
        UpdatePerceptionAllowList(Channel, bNewValue);
    }
    
 
    AIMODULE_API void RegisterStimulus(AActor* Source, const FAIStimulus& Stimulus);
    AIMODULE_API void ProcessStimuli();
    AIMODULE_API bool AgeStimuli(const float ConstPerceptionAgingRate);
    AIMODULE_API void ForgetActor(AActor* ActorToForget);
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void ForgetAll();
 
    AIMODULE_API float GetYoungestStimulusAge(const AActor& Source) const;
    AIMODULE_API bool HasAnyActiveStimulus(const AActor& Source) const;
    AIMODULE_API bool HasAnyCurrentStimulus(const AActor& Source) const;
    AIMODULE_API bool HasActiveStimulus(const AActor& Source, const FAISenseID Sense) const;
 
#if WITH_GAMEPLAY_DEBUGGER_MENU
    AIMODULE_API virtual void DescribeSelfToGameplayDebugger(FGameplayDebuggerCategory* DebuggerCategory) const;
#endif // WITH_GAMEPLAY_DEBUGGER_MENU
 
#if ENABLE_VISUAL_LOG
    AIMODULE_API virtual void DescribeSelfToVisLog(FVisualLogEntry* Snapshot) const;
#endif // ENABLE_VISUAL_LOG
 
    //----------------------------------------------------------------------//
    // blueprint interface
    //----------------------------------------------------------------------//
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void GetPerceivedHostileActors(TArray<AActor*>& OutActors) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void GetPerceivedHostileActorsBySense(const TSubclassOf<UAISense> SenseToUse, TArray<AActor*>& OutActors) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void GetCurrentlyPerceivedActors(TSubclassOf<UAISense> SenseToUse, TArray<AActor*>& OutActors) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void GetKnownPerceivedActors(TSubclassOf<UAISense> SenseToUse, TArray<AActor*>& OutActors) const;
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API bool GetActorsPerception(AActor* Actor, FActorPerceptionBlueprintInfo& Info);
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API void SetSenseEnabled(TSubclassOf<UAISense> SenseClass, const bool bEnable);
 
    UFUNCTION(BlueprintCallable, Category = "AI|Perception")
    AIMODULE_API bool IsSenseEnabled(TSubclassOf<UAISense> SenseClass) const;
 
    // Might want to move these to special "BP_AIPerceptionComponent"
    UPROPERTY(BlueprintAssignable)
    FPerceptionUpdatedDelegate OnPerceptionUpdated;
 
    UPROPERTY(BlueprintAssignable)
    FActorPerceptionForgetUpdatedDelegate OnTargetPerceptionForgotten;
 
    UPROPERTY(BlueprintAssignable)
    FActorPerceptionUpdatedDelegate OnTargetPerceptionUpdated;
 
    UPROPERTY(BlueprintAssignable)
    FActorPerceptionInfoUpdatedDelegate OnTargetPerceptionInfoUpdated;
 
protected:
    FActorPerceptionContainer& GetPerceptualData() { return PerceptualData; }
    const FActorPerceptionContainer& GetPerceptualData() const { return PerceptualData; }
 
    AIMODULE_API virtual void CleanUp();
 
    AIMODULE_API void RemoveDeadData();
 
    UE_DEPRECATED(5.6, "RefreshStimulus is deprecated. Use ConditionallyStoreSuccessfulStimulus() instead.")
    AIMODULE_API virtual void RefreshStimulus(FAIStimulus& StimulusStore, const FAIStimulus& NewStimulus) final;
 
    AIMODULE_API virtual bool ConditionallyStoreSuccessfulStimulus(FAIStimulus& StimulusStore, const FAIStimulus& NewStimulus);
 
    AIMODULE_API virtual void HandleExpiredStimulus(FAIStimulus& StimulusStore);
    
private:
    friend UAIPerceptionSystem;
 
    AIMODULE_API void RegisterSenseConfig(const UAISenseConfig& SenseConfig, UAIPerceptionSystem& AIPerceptionSys);
    void StoreListenerId(const FPerceptionListenerID InListenerId) { PerceptionListenerId = InListenerId; }
    AIMODULE_API void SetMaxStimulusAge(const FAISenseID SenseId, float MaxAge);
};