UAdvancedAIPerceptionComponent Class Reference

#include <AdvancedAIPerceptionComponent.h>

Inheritance diagram for UAdvancedAIPerceptionComponent:

Public Member Functions
UAISenseConfig *	GetPerceptionSenseConfig (const TSubclassOf< UAISense > SenseClass)
bool	SetPerceptionSenseConfig (const TSubclassOf< UAISense > SenseClass, const bool DetectEnemies, const bool DetectNeutrals, const bool DetectFriendlies)
virtual void	GetNeutralActors (TArray< AActor * > &OutActors) const
void	GetNeutralActorsBySense (TSubclassOf< UAISense > SenseToFilterBy, TArray< AActor * > &OutActors) const
void	GetPerceivedNeutralActors (TArray< AActor * > &OutActors) const
void	GetPerceivedNeutralActorsBySense (const TSubclassOf< UAISense > SenseToUse, TArray< AActor * > &OutActors) const
virtual void	GetFriendlyActors (TArray< AActor * > &OutActors) const
void	GetFriendlyActorsBySense (TSubclassOf< UAISense > SenseToFilterBy, TArray< AActor * > &OutActors) const
void	GetPerceivedFriendlyActors (TArray< AActor * > &OutActors) const
void	GetPerceivedFriendlyActorsBySense (const TSubclassOf< UAISense > SenseToUse, TArray< AActor * > &OutActors) const
AAIController *	GetOwnerController () const
float	GetMaxAge (const TSubclassOf< UAISense > SenseClass)
bool	SetMaxAge (const TSubclassOf< UAISense > SenseClass, const float MaxAge)
bool	SetSightMaxAge (const float MaxAge)
bool	SetHearingMaxAge (const float MaxAge)
float	GetSightRange ()
bool	SetSightRange (const float SightRange)
float	GetLoseSightRange ()
bool	SetLoseSightRange (const float LoseSightRange)
float	GetVisionAngle ()
bool	SetVisionAngle (const float VisionAngle)
float	GetAutoSuccessRange ()
bool	SetAutoSuccessRange (const float AutoSuccessRange)
float	GetPOVBackwardOffset ()
bool	SetPOVBackwardOffset (const float POVBackwardOffset)
float	GetNearClippingRadius ()
bool	SetNearClippingRadius (const float NearClippingRadius)
float	GetHearingRange ()
bool	SetHearingRange (const float HearingRange)
FAISenseAffiliationFilter	GetDetectionByAffiliation (const TSubclassOf< UAISense > SenseClass)
class UAISenseConfig_Sight *	GetSightConfig ()
class UAISenseConfig_Hearing *	GetHearingConfig ()
class UAISenseConfig_Actions *	GetActionsConfig ()
class UAISenseConfig_Damage *	GetDamageConfig ()
class UAISenseConfig_Prediction *	GetPredictionConfig ()
class UAISenseConfig_Team *	GetTeamConfig ()
class UAISenseConfig_Touch *	GetTouchConfig ()

Public Attributes
FOnForgottenStimulus	OnForgottenStimulus

Protected Member Functions
virtual void	HandleExpiredStimulus (FAIStimulus &StimulusStore) override
bool	ForgetActorBP (AActor *ActorToForget)
bool	SetDominantSenseBP (const TSubclassOf< UAISense > SenseClass)
TSubclassOf< UAISense >	GetDominantSenseBP () const
const AActor *	GetBodyActorBP () const
AActor *	GetMutableBodyActorBP ()
void	GetLocationAndDirectionBP (FVector &Location, FVector &Direction) const
FGenericTeamId	GetTeamIdentifierBP () const
void	UpdatePerceptionAllowListBP (const TSubclassOf< UAISense > SenseClass, const bool bNewValue)
float	GetYoungestStimulusAgeBP (AActor *Source) const
bool	HasAnyActiveStimulusBP (const AActor *Source) const
bool	HasAnyCurrentStimulusBP (const AActor *Source) const
bool	HasActiveStimulusBP (const AActor *Source, const TSubclassOf< UAISense > SenseClass) const

Member Function Documentation

ForgetActorBP()

bool UAdvancedAIPerceptionComponent::ForgetActorBP ( AActor * ActorToForget )

protected

{
    if(ActorToForget == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("ActorToForget Null in ForgetActorBP, Advanced AI Perception"));return false;}
    ForgetActor(ActorToForget);
    return true;
}

GetActionsConfig()

UAISenseConfig_Actions * UAdvancedAIPerceptionComponent::GetActionsConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Actions::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetActionsConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Actions* ConfigActions = Cast<UAISenseConfig_Actions>(Config);
    if(ConfigActions == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetActionsConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigActions;
}

GetAutoSuccessRange()

float UAdvancedAIPerceptionComponent::GetAutoSuccessRange

(

)

{
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->AutoSuccessRangeFromLastSeenLocation;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetAutoSuccessRange: Null, Advanced AI Perception"));
    return 0.0f;
}

GetBodyActorBP()

const AActor * UAdvancedAIPerceptionComponent::GetBodyActorBP ( ) const

protected

{
    return GetBodyActor();
}

GetDamageConfig()

UAISenseConfig_Damage * UAdvancedAIPerceptionComponent::GetDamageConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Damage::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetDamageConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Damage* ConfigDamage = Cast<UAISenseConfig_Damage>(Config);
    if(ConfigDamage == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetDamageConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigDamage;
}

GetDetectionByAffiliation()

FAISenseAffiliationFilter UAdvancedAIPerceptionComponent::GetDetectionByAffiliation

(

const TSubclassOf< UAISense >

SenseClass

)

{
    const FAISenseAffiliationFilter DetectionByAffiliation = {};
    if(SenseClass == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in GetDetectionByAffiliation, Advanced AI Perception"));return DetectionByAffiliation;}
    UAISenseConfig* Config = GetPerceptionSenseConfig(SenseClass);
    const UAISenseConfig_Sight* SightSenseConfig = Cast<UAISenseConfig_Sight>(Config);
    if(SightSenseConfig)
    {
        return SightSenseConfig->DetectionByAffiliation;
    }
    const UAISenseConfig_Hearing* HearingSenseConfig = Cast<UAISenseConfig_Hearing>(Config);
    if(HearingSenseConfig)
    {
        return HearingSenseConfig->DetectionByAffiliation;
    }
    // const UAISenseConfig_Actions* ActionsSenseConfig = Cast<UAISenseConfig_Actions>(Config);
    // if(ActionsSenseConfig)
    // {
    //  return ActionsSenseConfig->DetectionByAffiliation;
    // }
    // const UAISenseConfig_Damage* DamageSenseConfig = Cast<UAISenseConfig_Damage>(Config);
    // if(DamageSenseConfig)
    // {
    //  return DamageSenseConfig->DetectionByAffiliation;
    // }
    // const UAISenseConfig_Prediction* PredictionSenseConfig = Cast<UAISenseConfig_Prediction>(Config);
    // if(PredictionSenseConfig)
    // {
    //  return PredictionSenseConfig->DetectionByAffiliation;
    // }
    // const UAISenseConfig_Team* TeamSenseConfig = Cast<UAISenseConfig_Team>(Config);
    // if(TeamSenseConfig)
    // {
    //  return TeamSenseConfig->DetectionByAffiliation;
    // }
    // const UAISenseConfig_Touch* TouchSenseConfig = Cast<UAISenseConfig_Touch>(Config);
    // if(TouchSenseConfig)
    // {
    //  return TouchSenseConfig->DetectionByAffiliation;
    // }
    return DetectionByAffiliation;
}

GetDominantSenseBP()

TSubclassOf< UAISense > UAdvancedAIPerceptionComponent::GetDominantSenseBP ( ) const

protected

{
    return GetDominantSense();
}

GetFriendlyActors()

void UAdvancedAIPerceptionComponent::GetFriendlyActors ( TArray< AActor * > & OutActors ) const

virtual

{
    if(GetOwnerController() == nullptr)
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetFriendlyActors called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
    const bool bDeadDataFound = GetFilteredActors([this](const FActorPerceptionInfo& ActorPerceptionInfo) {
            return (
                (UAIBPLib::GetAttitudeToActor(GetOwnerController()->GetGenericTeamId(), ActorPerceptionInfo.Target.Get()) == ETeamAttitude::Friendly) &&
                ActorPerceptionInfo.HasAnyKnownStimulus());
    }, OutActors);
    
    if (bDeadDataFound)
    {
        FSimpleDelegateGraphTask::CreateAndDispatchWhenReady(
            FSimpleDelegateGraphTask::FDelegate::CreateUObject(const_cast<UAdvancedAIPerceptionComponent*>(this), &UAdvancedAIPerceptionComponent::RemoveDeadData),
            GET_STATID(STAT_FSimpleDelegateGraphTask_RequestingRemovalOfDeadPerceptionData), NULL, ENamedThreads::GameThread);
    }
}

GetFriendlyActorsBySense()

void UAdvancedAIPerceptionComponent::GetFriendlyActorsBySense	(	TSubclassOf< UAISense >	SenseToFilterBy,
		TArray< AActor * > &	OutActors ) const

{
    if(GetOwnerController() == nullptr)
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetNeutralActorsBySense called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
    const FAISenseID SenseIdFilter = UAISense::GetSenseID(SenseToFilterBy);
 
    if(SenseIdFilter == FAISenseID::InvalidID())
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetNeutralActorsBySense called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
 
    const bool bDeadDataFound = GetFilteredActors([SenseIdFilter, this](const FActorPerceptionInfo& ActorPerceptionInfo) {
        return (UAIBPLib::GetAttitudeToActor(GetOwnerController()->GetGenericTeamId(), ActorPerceptionInfo.Target.Get()) == ETeamAttitude::Friendly) &&
             ActorPerceptionInfo.HasKnownStimulusOfSense(SenseIdFilter);
        }, OutActors);
 
    if (bDeadDataFound)
    {
        FSimpleDelegateGraphTask::CreateAndDispatchWhenReady(
            FSimpleDelegateGraphTask::FDelegate::CreateUObject(const_cast<UAdvancedAIPerceptionComponent*>(this), &UAdvancedAIPerceptionComponent::RemoveDeadData),
            GET_STATID(STAT_FSimpleDelegateGraphTask_RequestingRemovalOfDeadPerceptionData), NULL, ENamedThreads::GameThread);
    }
}

GetHearingConfig()

UAISenseConfig_Hearing * UAdvancedAIPerceptionComponent::GetHearingConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Hearing::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetHearingConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Hearing* ConfigHearing = Cast<UAISenseConfig_Hearing>(Config);
    if(ConfigHearing == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetHearingConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigHearing;
}

GetHearingRange()

float UAdvancedAIPerceptionComponent::GetHearingRange

(

)

{
    if(GetHearingConfig() != nullptr)
    {
        return GetHearingConfig()->HearingRange;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetHearingConfig: Null, Advanced AI Perception"));
    return 0.0f;
}

GetLocationAndDirectionBP()

void UAdvancedAIPerceptionComponent::GetLocationAndDirectionBP ( FVector & Location, FVector & Direction ) const

protected

{
    GetLocationAndDirection(Location, Direction);
}

GetLoseSightRange()

float UAdvancedAIPerceptionComponent::GetLoseSightRange

(

)

{
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->LoseSightRadius;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetLoseSightRange: Null, Advanced AI Perception"));
    return 0.0f;
}

GetMaxAge()

float UAdvancedAIPerceptionComponent::GetMaxAge

(

const TSubclassOf< UAISense >

SenseClass

)

{
    if(SenseClass == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in GetMaxAge, Advanced AI Perception"));return 0.0f;}
    UAISenseConfig* Config = GetPerceptionSenseConfig(SenseClass);
    const UAISenseConfig_Sight* SightSenseConfig = Cast<UAISenseConfig_Sight>(Config);
    if(SightSenseConfig)
    {
        return SightSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Hearing* HearingSenseConfig = Cast<UAISenseConfig_Hearing>(Config);
    if(HearingSenseConfig)
    {
        return HearingSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Actions* ActionsSenseConfig = Cast<UAISenseConfig_Actions>(Config);
    if(ActionsSenseConfig)
    {
        return ActionsSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Damage* DamageSenseConfig = Cast<UAISenseConfig_Damage>(Config);
    if(DamageSenseConfig)
    {
        return DamageSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Prediction* PredictionSenseConfig = Cast<UAISenseConfig_Prediction>(Config);
    if(PredictionSenseConfig)
    {
        return PredictionSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Team* TeamSenseConfig = Cast<UAISenseConfig_Team>(Config);
    if(TeamSenseConfig)
    {
        return TeamSenseConfig->GetMaxAge();
    }
    const UAISenseConfig_Touch* TouchSenseConfig = Cast<UAISenseConfig_Touch>(Config);
    if(TouchSenseConfig)
    {
        return TouchSenseConfig->GetMaxAge();
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in GetMaxAge, Advanced AI Perception"));
    return 0.0f;
}

GetMutableBodyActorBP()

AActor * UAdvancedAIPerceptionComponent::GetMutableBodyActorBP ( )

protected

{
    return GetMutableBodyActor();
}

GetNearClippingRadius()

float UAdvancedAIPerceptionComponent::GetNearClippingRadius

(

)

{
#if ENGINE_MINOR_VERSION >= 27 || ENGINE_MAJOR_VERSION >= 5
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->NearClippingRadius;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetNearClippingRadius: Null, Advanced AI Perception"));
#else
    UE_LOG(LogTemp, Error, TEXT("GetPOVBackwardOffset: Requires UE4.27+"));
#endif
    return 0.0f;
}

GetNeutralActors()

void UAdvancedAIPerceptionComponent::GetNeutralActors ( TArray< AActor * > & OutActors ) const

virtual

{
    if(GetOwnerController() == nullptr)
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetNeutralActors called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
    const bool bDeadDataFound = GetFilteredActors([this](const FActorPerceptionInfo& ActorPerceptionInfo) {
            return (
                (UAIBPLib::GetAttitudeToActor(GetOwnerController()->GetGenericTeamId(), ActorPerceptionInfo.Target.Get()) == ETeamAttitude::Neutral) &&
                ActorPerceptionInfo.HasAnyKnownStimulus());
    }, OutActors);
    
    if (bDeadDataFound)
    {
        FSimpleDelegateGraphTask::CreateAndDispatchWhenReady(
            FSimpleDelegateGraphTask::FDelegate::CreateUObject(const_cast<UAdvancedAIPerceptionComponent*>(this), &UAdvancedAIPerceptionComponent::RemoveDeadData),
            GET_STATID(STAT_FSimpleDelegateGraphTask_RequestingRemovalOfDeadPerceptionData), NULL, ENamedThreads::GameThread);
    }
}

GetNeutralActorsBySense()

void UAdvancedAIPerceptionComponent::GetNeutralActorsBySense	(	TSubclassOf< UAISense >	SenseToFilterBy,
		TArray< AActor * > &	OutActors ) const

{
    if(GetOwnerController() == nullptr)
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetNeutralActorsBySense called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
    const FAISenseID SenseIdFilter = UAISense::GetSenseID(SenseToFilterBy);
 
    if(SenseIdFilter == FAISenseID::InvalidID())
    {
        UE_LOG(LogAIToolKit, Warning, TEXT("UAdvancedAIPerceptionComponent::GetNeutralActorsBySense called with an invalid or yet unregistered sense. Bailing out."));
        return;
    }
 
    const bool bDeadDataFound = GetFilteredActors([SenseIdFilter, this](const FActorPerceptionInfo& ActorPerceptionInfo) {
        return (UAIBPLib::GetAttitudeToActor(GetOwnerController()->GetGenericTeamId(), ActorPerceptionInfo.Target.Get()) == ETeamAttitude::Neutral) &&
             ActorPerceptionInfo.HasKnownStimulusOfSense(SenseIdFilter);
        }, OutActors);
 
    if (bDeadDataFound)
    {
        FSimpleDelegateGraphTask::CreateAndDispatchWhenReady(
            FSimpleDelegateGraphTask::FDelegate::CreateUObject(const_cast<UAdvancedAIPerceptionComponent*>(this), &UAdvancedAIPerceptionComponent::RemoveDeadData),
            GET_STATID(STAT_FSimpleDelegateGraphTask_RequestingRemovalOfDeadPerceptionData), NULL, ENamedThreads::GameThread);
    }
}

GetOwnerController()

AAIController * UAdvancedAIPerceptionComponent::GetOwnerController ( ) const

inline

{return AIOwner;};

GetPerceivedFriendlyActors()

void UAdvancedAIPerceptionComponent::GetPerceivedFriendlyActors

(

TArray< AActor * > &

OutActors

)

const

{
    return GetFriendlyActors(OutActors);
}

GetPerceivedFriendlyActorsBySense()

void UAdvancedAIPerceptionComponent::GetPerceivedFriendlyActorsBySense	(	const TSubclassOf< UAISense >	SenseToUse,
		TArray< AActor * > &	OutActors ) const

{
    return GetFriendlyActorsBySense(SenseToUse, OutActors);
}

GetPerceivedNeutralActors()

void UAdvancedAIPerceptionComponent::GetPerceivedNeutralActors

(

TArray< AActor * > &

OutActors

)

const

{
    return GetNeutralActors(OutActors);
}

GetPerceivedNeutralActorsBySense()

void UAdvancedAIPerceptionComponent::GetPerceivedNeutralActorsBySense	(	const TSubclassOf< UAISense >	SenseToUse,
		TArray< AActor * > &	OutActors ) const

{
    return GetNeutralActorsBySense(SenseToUse, OutActors);
}

GetPerceptionSenseConfig()

UAISenseConfig * UAdvancedAIPerceptionComponent::GetPerceptionSenseConfig

(

const TSubclassOf< UAISense >

SenseClass

)

{
    const FAISenseID ID = UAISense::GetSenseID(SenseClass);
    if(ID.IsValid())
    {
        return GetSenseConfig(ID);
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetSenseID Null in GetPerceptionSenseConfig, Advanced AI Perception"));
    return nullptr;
}

GetPOVBackwardOffset()

float UAdvancedAIPerceptionComponent::GetPOVBackwardOffset

(

)

{
#if ENGINE_MINOR_VERSION >= 27 || ENGINE_MAJOR_VERSION >= 5
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->PointOfViewBackwardOffset;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetAutoSuccessRange: Null, Advanced AI Perception"));
#else
    UE_LOG(LogTemp, Error, TEXT("GetPOVBackwardOffset: Requires UE4.27+"));
#endif
    return 0.0f;
}

GetPredictionConfig()

UAISenseConfig_Prediction * UAdvancedAIPerceptionComponent::GetPredictionConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Prediction::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetPredictionConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Prediction* ConfigPrediction = Cast<UAISenseConfig_Prediction>(Config);
    if(ConfigPrediction == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetPredictionConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigPrediction;
}

GetSightConfig()

UAISenseConfig_Sight * UAdvancedAIPerceptionComponent::GetSightConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Sight::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetSightConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Sight* ConfigSight = Cast<UAISenseConfig_Sight>(Config);
    if(ConfigSight == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetSightConfig: ConfigSight Null, Advanced AI Perception"));
    }
    return ConfigSight;
}

GetSightRange()

float UAdvancedAIPerceptionComponent::GetSightRange

(

)

{
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->SightRadius;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetSightRange: Null, Advanced AI Perception"));
    return 0.0f;
}

GetTeamConfig()

UAISenseConfig_Team * UAdvancedAIPerceptionComponent::GetTeamConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Team::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetTeamConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Team* ConfigTeam = Cast<UAISenseConfig_Team>(Config);
    if(ConfigTeam == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetTeamConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigTeam;
}

GetTeamIdentifierBP()

FGenericTeamId UAdvancedAIPerceptionComponent::GetTeamIdentifierBP ( ) const

protected

{
    return GetTeamIdentifier();
}

GetTouchConfig()

UAISenseConfig_Touch * UAdvancedAIPerceptionComponent::GetTouchConfig

(

)

{
    UAISenseConfig* Config = GetPerceptionSenseConfig(UAISense_Touch::StaticClass());
    if(Config == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetTouchConfig: Config Null, Advanced AI Perception"));
        return nullptr;
    }
    UAISenseConfig_Touch* ConfigTouch = Cast<UAISenseConfig_Touch>(Config);
    if(ConfigTouch == nullptr)
    {
        UE_LOG(LogAIToolKit, Error, TEXT("GetTouchConfig: ConfigHearing Null, Advanced AI Perception"));
    }
    return ConfigTouch;
}

GetVisionAngle()

float UAdvancedAIPerceptionComponent::GetVisionAngle

(

)

{
    if(GetSightConfig() != nullptr)
    {
        return GetSightConfig()->PeripheralVisionAngleDegrees;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetVisionAngle: Null, Advanced AI Perception"));
    return 0.0f;
}

GetYoungestStimulusAgeBP()

float UAdvancedAIPerceptionComponent::GetYoungestStimulusAgeBP ( AActor * Source ) const

protected

{
    if(Source != nullptr)
    {
        const AActor& ActorReference = *Source;
        return GetYoungestStimulusAge(ActorReference);
    }
    UE_LOG(LogAIToolKit, Error, TEXT("Source Null in GetYoungestStimulusAgeBP, Advanced AI Perception"));
    return 0.0f;
}

HandleExpiredStimulus()

void UAdvancedAIPerceptionComponent::HandleExpiredStimulus ( FAIStimulus & StimulusStore )

overrideprotectedvirtual

{
    OnForgottenStimulus.Broadcast(StimulusStore);
}

HasActiveStimulusBP()

bool UAdvancedAIPerceptionComponent::HasActiveStimulusBP ( const AActor * Source, const TSubclassOf< UAISense > SenseClass ) const

protected

{
    const FAISenseID ID = UAISense::GetSenseID(SenseClass);
    if(ID.IsValid() && GetSenseConfig(ID) != nullptr)
    {
        if(Source != nullptr)
        {
            const AActor& ActorReference = *Source;
            return HasActiveStimulus(ActorReference, ID);
        }
        UE_LOG(LogAIToolKit, Error, TEXT("Source Null in HasAnyCurrentStimulusBP, Advanced AI Perception"));
    }
    UE_LOG(LogAIToolKit, Error, TEXT("ID.IsValid GetSenseConfig Null in UpdatePerceptionAllowListBP, Advanced AI Perception"));
    return false;
}

HasAnyActiveStimulusBP()

bool UAdvancedAIPerceptionComponent::HasAnyActiveStimulusBP ( const AActor * Source ) const

protected

{
    if(Source != nullptr)
    {
        const AActor& ActorReference = *Source;
        return HasAnyActiveStimulus(ActorReference);
    }
    UE_LOG(LogAIToolKit, Error, TEXT("Source Null in HasAnyActiveStimulusBP, Advanced AI Perception"));
    return false;
}

HasAnyCurrentStimulusBP()

bool UAdvancedAIPerceptionComponent::HasAnyCurrentStimulusBP ( const AActor * Source ) const

protected

{
    if(Source != nullptr)
    {
        const AActor& ActorReference = *Source;
        return HasAnyCurrentStimulus(ActorReference);
    }
    UE_LOG(LogAIToolKit, Error, TEXT("Source Null in HasAnyCurrentStimulusBP, Advanced AI Perception"));
    return false;
}

SetAutoSuccessRange()

bool UAdvancedAIPerceptionComponent::SetAutoSuccessRange

(

const float

AutoSuccessRange

)

{
    if(GetSightConfig() != nullptr)
    {
        UE_LOG(LogAIToolKit, Verbose, TEXT("SetAutoSuccessRange was %f, setting to %f"), GetSightConfig()->AutoSuccessRangeFromLastSeenLocation, AutoSuccessRange);
        GetSightConfig()->AutoSuccessRangeFromLastSeenLocation = AutoSuccessRange;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetAutoSuccessRange: Null, Advanced AI Perception"));
    return false;
}

SetDominantSenseBP()

bool UAdvancedAIPerceptionComponent::SetDominantSenseBP ( const TSubclassOf< UAISense > SenseClass )

protected

{
    if(SenseClass == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in SetDominantSenseBP, Advanced AI Perception"));return false;}
    SetDominantSense(SenseClass);
    return true;
}

SetHearingMaxAge()

bool UAdvancedAIPerceptionComponent::SetHearingMaxAge

(

const float

MaxAge

)

{
    if(GetHearingConfig() != nullptr)
    {
        GetHearingConfig()->SetMaxAge(MaxAge);
        // ConfigureSense();
        RequestStimuliListenerUpdate();
        Deactivate();
        Activate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetHearingMaxAge: Null, Advanced AI Perception"));
    return false;
}

SetHearingRange()

bool UAdvancedAIPerceptionComponent::SetHearingRange

(

const float

HearingRange

)

{
    if(GetHearingConfig() != nullptr)
    {
        UE_LOG(LogTemp, Verbose, TEXT("SetHearingRange was %f, setting to %f"), GetHearingConfig()->HearingRange, HearingRange);
        GetHearingConfig()->HearingRange = HearingRange;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetHearingRange: Null, Advanced AI Perception"));
    return false;
 
}

SetLoseSightRange()

bool UAdvancedAIPerceptionComponent::SetLoseSightRange

(

const float

LoseSightRange

)

{
    if(GetSightConfig() != nullptr)
    {
        if(LoseSightRange < GetSightConfig()->SightRadius)
        {
            GetSightConfig()->LoseSightRadius = GetSightConfig()->SightRadius;
            UE_LOG(LogAIToolKit, Verbose, TEXT("SetLoseSightRange was %f, setting to %f"), GetSightConfig()->LoseSightRadius, LoseSightRange);
            return true;
        }
        UE_LOG(LogAIToolKit, Verbose, TEXT("SetLoseSightRange was %f, setting to %f"), GetSightConfig()->LoseSightRadius, LoseSightRange);
        GetSightConfig()->LoseSightRadius = LoseSightRange;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetLoseSightRange: Null, Advanced AI Perception"));
    return false;
}

SetMaxAge()

bool UAdvancedAIPerceptionComponent::SetMaxAge	(	const TSubclassOf< UAISense >	SenseClass,
		const float	MaxAge )

{
    if(SenseClass == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in SetMaxAge, Advanced AI Perception"));return false;}
    UAISenseConfig* Config = GetPerceptionSenseConfig(SenseClass);
    UAISenseConfig_Sight* SightSenseConfig = Cast<UAISenseConfig_Sight>(Config);
    if(SightSenseConfig)
    {
        SightSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Hearing* HearingSenseConfig = Cast<UAISenseConfig_Hearing>(Config);
    if(HearingSenseConfig)
    {
        HearingSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Actions* ActionsSenseConfig = Cast<UAISenseConfig_Actions>(Config);
    if(ActionsSenseConfig)
    {
        ActionsSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Damage* DamageSenseConfig = Cast<UAISenseConfig_Damage>(Config);
    if(DamageSenseConfig)
    {
        DamageSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Prediction* PredictionSenseConfig = Cast<UAISenseConfig_Prediction>(Config);
    if(PredictionSenseConfig)
    {
        PredictionSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Team* TeamSenseConfig = Cast<UAISenseConfig_Team>(Config);
    if(TeamSenseConfig)
    {
        TeamSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UAISenseConfig_Touch* TouchSenseConfig = Cast<UAISenseConfig_Touch>(Config);
    if(TouchSenseConfig)
    {
        TouchSenseConfig->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in SetMaxAge, Advanced AI Perception"));
    return false;
}

SetNearClippingRadius()

bool UAdvancedAIPerceptionComponent::SetNearClippingRadius

(

const float

NearClippingRadius

)

{
#if ENGINE_MINOR_VERSION >= 27 || ENGINE_MAJOR_VERSION >= 5
    if(GetSightConfig() != nullptr)
    {
        UE_LOG(LogAIToolKit, Verbose, TEXT("SetNearClippingRadius was %f, setting to %f"), GetSightConfig()->NearClippingRadius, NearClippingRadius);
        GetSightConfig()->NearClippingRadius = NearClippingRadius;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetNearClippingRadius: Null, Advanced AI Perception"));
#else
    UE_LOG(LogTemp, Error, TEXT("SetNearClippingRadius: Requires UE4.27+"));
#endif
    return false;
}

SetPerceptionSenseConfig()

bool UAdvancedAIPerceptionComponent::SetPerceptionSenseConfig	(	const TSubclassOf< UAISense >	SenseClass,
		const bool	DetectEnemies,
		const bool	DetectNeutrals,
		const bool	DetectFriendlies )

{
    if(SenseClass == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("SenseClass Null in SetPerceptionSenseConfig, Advanced AI Perception"));return false;}
    UAISenseConfig* Config = GetPerceptionSenseConfig(SenseClass);
    UAISenseConfig_Sight* SightSenseConfig = Cast<UAISenseConfig_Sight>(Config);
    UAISenseConfig_Hearing* HearingSenseConfig = Cast<UAISenseConfig_Hearing>(Config);
    if (SightSenseConfig)
    {
        SightSenseConfig->DetectionByAffiliation.bDetectEnemies = DetectEnemies;
        SightSenseConfig->DetectionByAffiliation.bDetectNeutrals = DetectNeutrals;
        SightSenseConfig->DetectionByAffiliation.bDetectFriendlies = DetectFriendlies;
    }
    else
    {
        HearingSenseConfig->DetectionByAffiliation.bDetectEnemies = DetectEnemies;
        HearingSenseConfig->DetectionByAffiliation.bDetectNeutrals = DetectNeutrals;
        HearingSenseConfig->DetectionByAffiliation.bDetectFriendlies = DetectFriendlies;
    }
    return true;
}

SetPOVBackwardOffset()

bool UAdvancedAIPerceptionComponent::SetPOVBackwardOffset

(

const float

POVBackwardOffset

)

{
#if ENGINE_MINOR_VERSION >= 27 || ENGINE_MAJOR_VERSION >= 5
    if(GetSightConfig() != nullptr)
    {
        UE_LOG(LogAIToolKit, Verbose, TEXT("SetPOVBackwardOffset was %f, setting to %f"), GetSightConfig()->PointOfViewBackwardOffset, POVBackwardOffset);
        GetSightConfig()->PointOfViewBackwardOffset = POVBackwardOffset;
        RequestStimuliListenerUpdate();
        return true;
    }
#else
    UE_LOG(LogTemp, Error, TEXT("SetPOVBackwardOffset: Requires UE4.27+"));
#endif
    return false;
}

SetSightMaxAge()

bool UAdvancedAIPerceptionComponent::SetSightMaxAge

(

const float

MaxAge

)

{
    if(GetSightConfig() != nullptr)
    {
        GetSightConfig()->SetMaxAge(MaxAge);
        RequestStimuliListenerUpdate();
        // Deactivate();
        // Activate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetSightMaxAge: Null, Advanced AI Perception"));
    return false;
}

SetSightRange()

bool UAdvancedAIPerceptionComponent::SetSightRange

(

const float

SightRange

)

{
    if(GetSightConfig() != nullptr)
    {
        UE_LOG(LogAIToolKit, Verbose, TEXT("SetSightRange was %f %f, setting to %f %f"), GetSightConfig()->SightRadius, GetSightConfig()->LoseSightRadius, SightRange, (GetSightConfig()->LoseSightRadius - GetSightConfig()->SightRadius + SightRange));
        // Save original lose range
        const float LoseRange = GetSightConfig()->LoseSightRadius - GetSightConfig()->SightRadius;
        GetSightConfig()->SightRadius = SightRange;
        // Apply lose range to new radius of the sight
        GetSightConfig()->LoseSightRadius = GetSightConfig()->SightRadius + LoseRange;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("GetSightConfig: Null, Advanced AI Perception"));
    return false;
}

SetVisionAngle()

bool UAdvancedAIPerceptionComponent::SetVisionAngle

(

const float

VisionAngle

)

{
    if(GetSightConfig() != nullptr)
    {
        UE_LOG(LogTemp, Verbose, TEXT("SetVisionAngle was %f, setting to %f"), GetSightConfig()->PeripheralVisionAngleDegrees, VisionAngle);
        GetSightConfig()->PeripheralVisionAngleDegrees = VisionAngle;
        RequestStimuliListenerUpdate();
        return true;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("SetVisionAngle: Null, Advanced AI Perception"));
    return false;
}

UpdatePerceptionAllowListBP()

void UAdvancedAIPerceptionComponent::UpdatePerceptionAllowListBP ( const TSubclassOf< UAISense > SenseClass, const bool bNewValue )

protected

Allows toggling senses on and off

{
    const FAISenseID ID = UAISense::GetSenseID(SenseClass);
    if(ID.IsValid() && GetSenseConfig(ID) != nullptr)
    {
        const bool bCurrentValue = PerceptionFilter.ShouldRespondToChannel(ID);
        if(bNewValue != bCurrentValue)
        {
            bNewValue ? PerceptionFilter.AcceptChannel(ID) : PerceptionFilter.FilterOutChannel(ID);
            RequestStimuliListenerUpdate();
            return;
        }
        return;
    }
    UE_LOG(LogAIToolKit, Error, TEXT("ID.IsValid GetSenseConfig Null in UpdatePerceptionAllowListBP, Advanced AI Perception"));
}

Member Data Documentation

OnForgottenStimulus

FOnForgottenStimulus UAdvancedAIPerceptionComponent::OnForgottenStimulus

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Public/Components/AdvancedAIPerceptionComponent.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Private/Components/AdvancedAIPerceptionComponent.cpp