ACustomAIController Class Reference

#include <CustomAIController.h>

Inheritance diagram for ACustomAIController:

Public Member Functions
	ACustomAIController ()
virtual ETeamAttitude::Type	GetTeamAttitudeTowards (const AActor &Other) const override
virtual void	SetGenericTeamId (const FGenericTeamId &NewTeamID) override
virtual FGenericTeamId	GetGenericTeamId () const override
int32	GetTeamID () const
void	OnRep_MyTeamID (FGenericTeamId OldTeamID)
void	UpdatePerceptionDetails () const

Public Attributes
FGenericTeamId	MyTeamID

Protected Member Functions
virtual void	OnPossess (APawn *InPawn) override
virtual void	BeginPlay () override
virtual FVector	GetFocalPointOnActor (const AActor *Actor) const override
virtual void	Aim (const bool bStartAiming=true) override
virtual void	CrouchAction (const bool bCrouch=true) override
virtual void	ShootAction (const bool bStartShooting=true) override
virtual void	ShootAtTargetAction (const bool bStartShooting=true, const FVector &TargetLocation=FVector::ZeroVector) override
virtual float	Reload () override
virtual bool	CheckAmmo (bool &bNeedToReload) const override
virtual bool	GetHasWeapon () const override
virtual uint8	GetWeaponFireMode () const override
virtual float	GetWeaponFireRate () const override
virtual void	UpdateMovementSpeed (const EAIMovementSpeed MovementSpeed=EAIMovementSpeed::Running, const EAIMovementType MovementType=EAIMovementType::Normal) override
virtual bool	PickupObject (const AActor *TargetObject) override
virtual float	MeleeAttack () override
virtual float	PlayAnimationMontage (UAnimMontage *Montage, const float PlayRate=1.0f, const float InTimeToStartMontageAt=0.0f, const bool bStopAllMontages=true) override
virtual FVector	PredictLocation (AActor *TargetActor) override
virtual TArray< AActor * >	GetHostileActors () const override
virtual TArray< AActor * >	GetPerceivedObjects (const TArray< EAIStimuliType > Filters) const override
virtual AActor *	GetBestHostileActor () const override
virtual float	GetMaxHealth () const override
virtual FVector	GetLastKnownLocation (AActor *TargetActor, const TArray< EAISense > &Senses) override
void	AIStateChanged (EAIStateType State)
void	OnForgottenStimulusBP (FAIStimulus Stimulus)
void	OnTargetPerceptionForgottenBP (AActor *Actor)
void	OnPerceptionUpdatedBP (const TArray< AActor * > &UpdatedActors)
void	OnTargetPerceptionUpdatedBP (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetPerceptionInfoUpdatedBP (FActorPerceptionUpdateInfo UpdateInfo)
void	OnTargetSightUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetHearingUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetPredictionUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetDamageUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetTeamUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetTouchUpdated (AActor *Actor, FAIStimulus Stimulus)
void	OnTargetActionUpdated (AActor *Actor, FAIStimulus Stimulus)
void	ForgottenStimulus (FAIStimulus Stimulus)
void	TargetPerceptionForgotten (AActor *Actor)
void	PerceptionUpdated (const TArray< AActor * > &UpdatedActors)
void	TargetPerceptionUpdated (AActor *Actor, FAIStimulus Stimulus)
void	TargetPerceptionInfoUpdated (const FActorPerceptionUpdateInfo &UpdateInfo)
void	CharacterDeath (FPlayerDeath &DeathInfo, APawn *PawnThatDied)
void	TargetSightUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetHearingUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetPredictionUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetDamageUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetTeamUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetTouchUpdated (AActor *Actor, const FAIStimulus &Stimulus)
void	TargetActionUpdated (AActor *Actor, const FAIStimulus &Stimulus)

Protected Attributes
TObjectPtr< UBehaviorTree >	Behaviour = nullptr
class UAdvancedAIPerceptionComponent *	AIPerceptionComponent
class UAISenseConfig_Sight *	SightConfig
class UAISenseConfig_Hearing *	HearingConfig
class UAISenseConfig_Prediction *	PredictionConfig
class UAISenseConfig_Team *	TeamConfig
class UAISenseConfig_Damage *	DamageConfig
class UAISenseConfig_Actions *	ActionsConfig
class UAITraitsComponent *	AITraitsComponentReference
class ACustomAICharacter *	CustomAICharacter = nullptr
uint8	TeamID = 2
bool	bDebuggingMode = false

Constructor & Destructor Documentation

ACustomAIController()

ACustomAIController::ACustomAIController

(

)

{
    AIPerceptionComponent = CreateDefaultSubobject<UAdvancedAIPerceptionComponent>("Perception");
    SightConfig = CreateDefaultSubobject<UAISenseConfig_Sight>(TEXT("Sight Perception"));
    SightConfig->DetectionByAffiliation.bDetectEnemies = true;
    SightConfig->DetectionByAffiliation.bDetectNeutrals = true;
    SightConfig->DetectionByAffiliation.bDetectFriendlies = true;
    
    HearingConfig = CreateDefaultSubobject<UAISenseConfig_Hearing>(TEXT("Hearing Perception"));
    HearingConfig->DetectionByAffiliation.bDetectEnemies = true;
    HearingConfig->DetectionByAffiliation.bDetectNeutrals = true;
    HearingConfig->DetectionByAffiliation.bDetectFriendlies = true;
    
    PredictionConfig = CreateDefaultSubobject<UAISenseConfig_Prediction>(TEXT("Prediction Perception"));
    TeamConfig = CreateDefaultSubobject<UAISenseConfig_Team>(TEXT("Team Perception"));
    DamageConfig = CreateDefaultSubobject<UAISenseConfig_Damage>(TEXT("Damage Perception"));
    
    ActionsConfig = CreateDefaultSubobject<UAISenseConfig_Actions>(TEXT("Actions Perception"));
 
    AIPerceptionComponent->ConfigureSense(*ActionsConfig);
    AIPerceptionComponent->ConfigureSense(*SightConfig);
    AIPerceptionComponent->ConfigureSense(*TeamConfig);
    AIPerceptionComponent->ConfigureSense(*PredictionConfig);
    AIPerceptionComponent->ConfigureSense(*HearingConfig);
    AIPerceptionComponent->ConfigureSense(*DamageConfig);
 
    AIPerceptionComponent->SetDominantSense(UAISense_Sight::StaticClass());
 
    // SetGenericTeamId(FGenericTeamId(TeamID));
}

Member Function Documentation

Aim()

void ACustomAIController::Aim ( const bool bStartAiming = true )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        CustomAICharacter->Aim(bStartAiming);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("Aim Action Failed in Custom AI Controller"));}
}

AIStateChanged()

void ACustomAIController::AIStateChanged ( EAIStateType State )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::AIStateChanged);
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Warning, TEXT("AI State: %hhd"), State);}
    const uint8 Byte = static_cast<uint8>(State);
    if(GetBlackboardComponent() != nullptr)
    {
        GetBlackboardComponent()->SetValueAsEnum(FName("CurrentAIState"), Byte);
    }
    UpdatePerceptionDetails();
}

BeginPlay()

void ACustomAIController::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
 
    //GetPawn()->GetAITraitsComponent()->FactionType;
    //switch(EFactionType) TeamID = 1, 2, etc.
}

CharacterDeath()

void ACustomAIController::CharacterDeath ( FPlayerDeath & DeathInfo, APawn * PawnThatDied )

protected

{
    if(PerceptionComponent != nullptr)
    {
        PerceptionComponent->DestroyComponent();
    }
    if(Blackboard != nullptr)
    {
        Blackboard->DestroyComponent();
    }
    if(BrainComponent != nullptr)
    {
        BrainComponent->StopLogic("Death");
    }
}

CheckAmmo()

bool ACustomAIController::CheckAmmo ( bool & bNeedToReload ) const

overrideprotectedvirtual

Returns if out of ammo

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->CheckAmmo(bNeedToReload);
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("CheckAmmo Failed in Custom AI Controller"));}
    return false;
}

CrouchAction()

void ACustomAIController::CrouchAction ( const bool bCrouch = true )

overrideprotectedvirtual

Will crouch the Character, defaults to true

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        CustomAICharacter->CrouchAction(bCrouch);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("Crouch Action Failed in Custom AI Controller"));}
}

ForgottenStimulus()

void ACustomAIController::ForgottenStimulus ( FAIStimulus Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::ForgottenStimulus);
    OnForgottenStimulusBP(Stimulus);
}

GetBestHostileActor()

AActor * ACustomAIController::GetBestHostileActor ( ) const

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(AITraitsComponentReference != nullptr)
    {
        return AITraitsComponentReference->GetBestHostileActor();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetBestHostileActor Failed in Custom AI Controller"));}
    return nullptr;
}

GetFocalPointOnActor()

FVector ACustomAIController::GetFocalPointOnActor ( const AActor * Actor ) const

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::GetFocalPointOnActor);
    const IInteractionInterface* InteractableActor = Cast<IInteractionInterface>(Actor);
    if(InteractableActor != nullptr)
    {
        return InteractableActor->GetInteractionLocation();
    }
    const APawn* FocusPawn = Cast<APawn>(Actor);
    if (FocusPawn)
    {
        // Focus on pawn's eye view point
        return FocusPawn->GetPawnViewLocation();
    }
    return Super::GetFocalPointOnActor(Actor);
}

GetGenericTeamId()

virtual FGenericTeamId ACustomAIController::GetGenericTeamId ( ) const

inlineoverridevirtual

{return MyTeamID;};

GetHasWeapon()

bool ACustomAIController::GetHasWeapon ( ) const

overrideprotectedvirtual

Returns if has a weapon

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->GetHasWeapon();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetHasWeapon Failed in Custom AI Controller"));}
    return false;
}

GetHostileActors()

TArray< AActor * > ACustomAIController::GetHostileActors ( ) const

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(AITraitsComponentReference != nullptr)
    {
        return AITraitsComponentReference->GetHostileActors();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetHostileActors Failed in Custom AI Controller"));}
    TArray<AActor*> Empty;
    return Empty;
}

GetLastKnownLocation()

FVector ACustomAIController::GetLastKnownLocation ( AActor * TargetActor, const TArray< EAISense > & Senses )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::GetLastKnownLocation);
    FVector Location = FVector::ZeroVector;
    FActorPerceptionBlueprintInfo ActorInfo;
    if(PerceptionComponent == nullptr){return Location;}
    float Age = 999.0f;
    if(PerceptionComponent->GetActorsPerception(TargetActor, ActorInfo))
    {
        for(const auto& Stimuli : ActorInfo.LastSensedStimuli)
        {
            if(Senses.Contains(UAIBPLib::GetSenseFromStimulus(Stimuli)) && Stimuli.WasSuccessfullySensed())
            {
                if(Stimuli.GetAge() < Age)
                {
                    Age = Stimuli.GetAge();
                    Location = Stimuli.StimulusLocation;
                }
            }
        }
    }
    return Location;
}

GetMaxHealth()

float ACustomAIController::GetMaxHealth ( ) const

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->GetMaxHealth();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetMaxHealth Failed in Custom AI Controller"));}
    return 0.0f;
}

GetPerceivedObjects()

TArray< AActor * > ACustomAIController::GetPerceivedObjects ( const TArray< EAIStimuliType > Filters ) const

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::GetPerceivedObjects);
    TArray<AActor*> Actors;
    if(AIPerceptionComponent != nullptr)
    {
        TArray<AActor*> AllActors;
        AIPerceptionComponent->GetKnownPerceivedActors(nullptr, AllActors);
        if(bDebuggingMode){UE_LOG(LogCustomCharacters, Warning, TEXT("Known Perceived Actors: %i"), AllActors.Num());}
        for(auto Actor : AllActors)
        {
            IBaseInterface* BaseActor = Cast<IBaseInterface>(Actor);
            if(BaseActor != nullptr)
            {
                if(Filters.Contains(BaseActor->GetInteractionData().StimuliType) || Filters.IsEmpty())
                {
                    Actors.Add(Actor);
                }
            }
        }
        if(bDebuggingMode){UE_LOG(LogCustomCharacters, Warning, TEXT("Known Perceived Objects: %i"), Actors.Num());}
    }
    return Actors;
}

GetTeamAttitudeTowards()

ETeamAttitude::Type ACustomAIController::GetTeamAttitudeTowards ( const AActor & Other ) const

overridevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::GetTeamAttitudeTowards);
    const EFactionType OwnerFaction = UAIBPLib::GetFactionFromTeamID(TeamID);
    if(const APawn* OtherPawn = Cast<APawn>(&Other))
    {
        const IGenericTeamAgentInterface* TeamAgent = Cast<IGenericTeamAgentInterface>(OtherPawn);
        if(TeamAgent == nullptr){TeamAgent = Cast<IGenericTeamAgentInterface>(OtherPawn->GetController());}
        if(TeamAgent !=  nullptr)
        {
            const FGenericTeamId OtherTeamID = TeamAgent->GetGenericTeamId();
            const EFactionType OtherPawnFaction = UAIBPLib::GetFactionFromTeamID(OtherTeamID);
            bool bSuccess = false;
            const FFactionRelationship Relationship = UAIBPLib::GetFactionRelationship(this, OwnerFaction, OtherPawnFaction, bSuccess);
            if(bDebuggingMode){UE_LOG(LogCustomCharacters, Warning, TEXT("Get Attitude Toward - Owner: %s "), *GetHumanReadableName());}
 
            if(bSuccess)
            {
                switch (Relationship.RelationshipStatus)
                {
                case ERelationshipStatus::Friendly:
                case ERelationshipStatus::Allied:
                    // UE_LOG(LogCustomCharacters, Warning, TEXT("TEAM: Friendship"));
                    return ETeamAttitude::Friendly;
                case ERelationshipStatus::Default:
                case ERelationshipStatus::Neutral:
                case ERelationshipStatus::UnFriendly:
                    // UE_LOG(LogCustomCharacters, Warning, TEXT("TEAM: Neutral"));
                    return ETeamAttitude::Neutral;
                case ERelationshipStatus::Hostile:
                case ERelationshipStatus::Enemy:
                    // UE_LOG(LogCustomCharacters, Warning, TEXT("TEAM: Hostile"));
                    return ETeamAttitude::Hostile;
                }
            }
        }
    }
    return ETeamAttitude::Neutral;
}

GetTeamID()

int32 ACustomAIController::GetTeamID ( ) const

inline

{return (MyTeamID == FGenericTeamId::NoTeam) ? INDEX_NONE : (int32)MyTeamID;};

GetWeaponFireMode()

uint8 ACustomAIController::GetWeaponFireMode ( ) const

overrideprotectedvirtual

Returns Weapon Fire Mode
0 - Single
1 - Burst
2 - FullAuto
3 - Charge

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->GetWeaponFireMode();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetWeaponFireMode Failed in Custom AI Controller"));}
    return false;
}

GetWeaponFireRate()

float ACustomAIController::GetWeaponFireRate ( ) const

overrideprotectedvirtual

Return Weapon Fire Rate per Min

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->GetWeaponFireRate();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("GetWeaponFireRate Failed in Custom AI Controller"));}
    return false;
}

MeleeAttack()

float ACustomAIController::MeleeAttack ( )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->MeleeAttack();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("MeleeAttack Failed in Custom AI Controller"));}
    return 0.0f;
}

OnForgottenStimulusBP()

void ACustomAIController::OnForgottenStimulusBP ( FAIStimulus Stimulus )

protected

OnPerceptionUpdatedBP()

void ACustomAIController::OnPerceptionUpdatedBP ( const TArray< AActor * > & UpdatedActors )

protected

OnPossess()

void ACustomAIController::OnPossess ( APawn * InPawn )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::OnPossess);
    Super::OnPossess(InPawn);
    if(Behaviour != nullptr)
    {
        RunBehaviorTree(Behaviour);
    }
    CustomAICharacter = Cast<ACustomAICharacter>(InPawn);
    if(CustomAICharacter != nullptr)
    {
        AITraitsComponentReference = CustomAICharacter->GetTraitsComponent();
        CustomAICharacter->OnCharacterDeath.AddUniqueDynamic(this, &ACustomAIController::CharacterDeath);
        // AITraitsComponentReference->SetBlackboard(Blackboard);
    }
    if(AIPerceptionComponent != nullptr)
    {
        AIPerceptionComponent->OnForgottenStimulus.AddUniqueDynamic(this, &ACustomAIController::ForgottenStimulus);
        AIPerceptionComponent->OnTargetPerceptionForgotten.AddUniqueDynamic(this, &ACustomAIController::TargetPerceptionForgotten);
        AIPerceptionComponent->OnPerceptionUpdated.AddUniqueDynamic(this, &ACustomAIController::PerceptionUpdated);
        AIPerceptionComponent->OnTargetPerceptionUpdated.AddUniqueDynamic(this, &ACustomAIController::TargetPerceptionUpdated);
        AIPerceptionComponent->OnTargetPerceptionInfoUpdated.AddUniqueDynamic(this, &ACustomAIController::TargetPerceptionInfoUpdated);
        // AIPerceptionComponent->On
        
        //- Set Perception Based on Skills  //
        UpdatePerceptionDetails();
    }
    if(AITraitsComponentReference != nullptr)
    {
        AITraitsComponentReference->OnAIStateChangedDelegate.AddUniqueDynamic(this, &ACustomAIController::AIStateChanged);
        AITraitsComponentReference->SetBlackboardComponent(GetBlackboardComponent());
        TeamID = UAIBPLib::GetTeamIDFromFaction(AITraitsComponentReference->GetFaction());
        SetGenericTeamId(FGenericTeamId(TeamID));
        UE_LOG(LogTemp, Warning, TEXT("TEAM ID: %i "), TeamID);
    }
}

OnRep_MyTeamID()

void ACustomAIController::OnRep_MyTeamID

(

FGenericTeamId

OldTeamID

)

{
    if(OldTeamID != MyTeamID)
    {
        //broadcastTeamChange
    }
}

OnTargetActionUpdated()

void ACustomAIController::OnTargetActionUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetDamageUpdated()

void ACustomAIController::OnTargetDamageUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetHearingUpdated()

void ACustomAIController::OnTargetHearingUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetPerceptionForgottenBP()

void ACustomAIController::OnTargetPerceptionForgottenBP ( AActor * Actor )

protected

OnTargetPerceptionInfoUpdatedBP()

void ACustomAIController::OnTargetPerceptionInfoUpdatedBP ( FActorPerceptionUpdateInfo UpdateInfo )

protected

OnTargetPerceptionUpdatedBP()

void ACustomAIController::OnTargetPerceptionUpdatedBP ( AActor * Actor, FAIStimulus Stimulus )

protected

This function is called when the perception of a specific actor (target) by the AI has been updated. It provides details about the perceived actor and the updated perception data (like sight, hearing, etc.) Use this when your AI behavior depends on the perception status of individual targets. For example, if you need to execute specific logic when an enemy becomes visible or when the sound of a specific ally is heard.

OnTargetPredictionUpdated()

void ACustomAIController::OnTargetPredictionUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetSightUpdated()

void ACustomAIController::OnTargetSightUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetTeamUpdated()

void ACustomAIController::OnTargetTeamUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

OnTargetTouchUpdated()

void ACustomAIController::OnTargetTouchUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

PerceptionUpdated()

void ACustomAIController::PerceptionUpdated ( const TArray< AActor * > & UpdatedActors )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::PerceptionUpdated);
    OnPerceptionUpdatedBP(UpdatedActors);
}

PickupObject()

bool ACustomAIController::PickupObject ( const AActor * TargetObject )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->PickupObject(TargetObject);
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("PickupObject Failed in Custom AI Controller"));}
    return false;
}

PlayAnimationMontage()

float ACustomAIController::PlayAnimationMontage ( UAnimMontage * Montage, const float PlayRate = 1.0f, const float InTimeToStartMontageAt = 0.0f, const bool bStopAllMontages = true )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::PlayAnimationMontage);
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->PlayAnimationMontage(Montage, PlayRate, InTimeToStartMontageAt, bStopAllMontages);
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("MeleeAttack Failed in Custom AI Controller"));}
    return 0.0f;
}

PredictLocation()

FVector ACustomAIController::PredictLocation ( AActor * TargetActor )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::PredictLocation);
    //@ TODO Check if this works like the BP one    //
    if(AIPerceptionComponent != nullptr && CustomAICharacter != nullptr && AITraitsComponentReference != nullptr)
    {
        UAISense_Prediction::RequestPawnPredictionEvent(CustomAICharacter, TargetActor, AITraitsComponentReference->GetPredictionTime());
        FActorPerceptionBlueprintInfo TargetInfo;
        AIPerceptionComponent->GetActorsPerception(TargetActor, TargetInfo);
        for(const auto& Stimuli : TargetInfo.LastSensedStimuli)
        {
            if(UAIBPLib::GetSenseFromStimulus(Stimuli) == EAISense::Prediction)
            {
                return Stimuli.StimulusLocation;
            }
        }
    }
    UE_LOG(LogCustomCharacters, Error, TEXT("PredictLocation Failed in Custom AI Controller"))
    return FVector::ZeroVector;
}

Reload()

float ACustomAIController::Reload ( )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        return CustomAICharacter->Reload();
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("Reload Action Failed in Custom AI Character"));}
    return 0.0f;
}

SetGenericTeamId()

void ACustomAIController::SetGenericTeamId ( const FGenericTeamId & NewTeamID )

overridevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::SetGenericTeamId);
    if(HasAuthority())
    {
        const FGenericTeamId OldTeamID = MyTeamID;
 
        // MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, MyTeamID, this);
        MyTeamID = NewTeamID;
        if(bDebuggingMode){ UE_LOG(LogTemp, Error, TEXT("team %i"), NewTeamID.GetId());}
        // ConditionalBroadcastTeamChanged(this, OldTeamID, NewTeamID);
    }
    else
    {
        if(bDebuggingMode){UE_LOG(LogTemp, Error, TEXT("Cannot set team for %s on non-authority"), *GetPathName(this));}
    }
}

ShootAction()

void ACustomAIController::ShootAction ( const bool bStartShooting = true )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        CustomAICharacter->ShootAction(bStartShooting);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("Shoot Action Failed in Custom AI Controller"));}
}

ShootAtTargetAction()

void ACustomAIController::ShootAtTargetAction ( const bool bStartShooting = true, const FVector & TargetLocation = FVector::ZeroVector )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        CustomAICharacter->ShootAtTargetAction(bStartShooting, TargetLocation);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("ShootAtTargetAction Failed in Custom AI Controller"));}
}

TargetActionUpdated()

void ACustomAIController::TargetActionUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetActionUpdated);
    if(Actor == this){return;}
    if(AITraitsComponentReference != nullptr)
    {
        AITraitsComponentReference->ActionReceived(Actor, Stimulus);
    }
    OnTargetActionUpdated(Actor, Stimulus);
}

TargetDamageUpdated()

void ACustomAIController::TargetDamageUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetDamageUpdated);
    OnTargetDamageUpdated(Actor, Stimulus);
}

TargetHearingUpdated()

void ACustomAIController::TargetHearingUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetHearingUpdated);
    if(Actor != nullptr && GetTeamAttitudeTowards(*Actor) == ETeamAttitude::Hostile)
    {
        //- Doesn't need to be character as player should be able to throw something    //
        if(AITraitsComponentReference != nullptr && Stimulus.WasSuccessfullySensed())
        {
            AITraitsComponentReference->SoundDetected(Actor, Stimulus);
        }
    }
    OnTargetHearingUpdated(Actor, Stimulus);
}

TargetPerceptionForgotten()

void ACustomAIController::TargetPerceptionForgotten ( AActor * Actor )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetPerceptionForgotten);
    if(Actor == nullptr){return;}
    if(AITraitsComponentReference != nullptr)
    {
        // if(Actor == AITraitsComponentReference->GetCurrentTargetActor())
        // {
        //  AITraitsComponentReference->StopDetecting();
        // }
    }
    OnTargetPerceptionForgottenBP(Actor);
}

TargetPerceptionInfoUpdated()

void ACustomAIController::TargetPerceptionInfoUpdated ( const FActorPerceptionUpdateInfo & UpdateInfo )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetPerceptionInfoUpdated);
    
    // if(AITraitsComponentReference != nullptr)
    // {
    //  if(UpdateInfo.Target != nullptr && UpdateInfo.Target.Get() == AITraitsComponentReference->GetTargetActor())
    //  {
    //      if(bDebuggingMode){UE_LOG(LogCustomCharacters, Warning, TEXT("Target Actor: %s Info Updated"), *UpdateInfo.Target.Get()->GetName());}
    //      AITraitsComponentReference->StartDetecting(UpdateInfo.Target.Get(), UpdateInfo.Stimulus);
    //  }
    // }
    OnTargetPerceptionInfoUpdatedBP(UpdateInfo);
}

TargetPerceptionUpdated()

void ACustomAIController::TargetPerceptionUpdated ( AActor * Actor, FAIStimulus Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetPerceptionUpdated);
    // SCOPE_CYCLE_COUNTER(STAT_AIPerceptionUpdated);
    if(Actor == GetPawn() || Actor == this || AITraitsComponentReference == nullptr){return;}
    switch(UAIBPLib::GetSenseFromStimulus(Stimulus))
    {
    default:
    case EAISense::Sight:
        TargetSightUpdated(Actor, Stimulus);
        break;
    case EAISense::Hearing:
        TargetHearingUpdated(Actor, Stimulus);
        break;
    case EAISense::Prediction:
        TargetPredictionUpdated(Actor, Stimulus);
        break;
    case EAISense::Damage:
        TargetDamageUpdated(Actor, Stimulus);
        break;
    case EAISense::Team:
        TargetTeamUpdated(Actor, Stimulus);
        break;
    case EAISense::Action:
        TargetActionUpdated(Actor, Stimulus);
        break;
    case EAISense::Touch:
        TargetTouchUpdated(Actor, Stimulus);
        break;
    }
    OnTargetPerceptionUpdatedBP(Actor, Stimulus);
}

TargetPredictionUpdated()

void ACustomAIController::TargetPredictionUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetPredictionUpdated);
    OnTargetPredictionUpdated(Actor, Stimulus);
}

TargetSightUpdated()

void ACustomAIController::TargetSightUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetSightUpdated);
    if(Actor == nullptr){return;}
    if(Stimulus.WasSuccessfullySensed())
    {
        AITraitsComponentReference->SightDetected(Actor, Stimulus);
    }
    else
    {
        AITraitsComponentReference->SightLost(Actor, Stimulus);
    }
 
    //@TODO Check if Character Is Known //
    // const IBaseInterface* BaseActor = Cast<IBaseInterface>(Actor);
    // //- Doesn't need to be character as player should be able to throw something //
    // if(BaseActor != nullptr && AITraitsComponentReference != nullptr /*&& BaseActor->GetIsCharacter()*/ && Stimulus.WasSuccessfullySensed())
    // {
    //  // AIPerceptionComponent->
    //  //- Need to check if it's still percevied //
    // }
 
    // const IBaseInterface* BaseActor = Cast<IBaseInterface>(Actor);
    // //- Doesn't need to be character as player should be able to throw something //
    // if(BaseActor != nullptr && AITraitsComponentReference != nullptr/*&& BaseActor->GetIsCharacter()*/)
    // {
    //  AITraitsComponentReference->StartDetecting(Actor, Stimulus);
    //  // AITraitsComponentReference->DetectActor(Actor);
    //  
    //  // bool bSuccess = false;
    //  // const FFactionRelationship Relationship = UAIBPLib::GetFactionRelationship(GetWorld(), AITraitsComponentReference->GetFaction(),
    //  //  TargetCharacter->GetCharacterFaction(), bSuccess);
    //  // if(!bHostile && bSuccess)
    //  // {
    //  //  AITraitsComponentReference->AddFriendlyActor(Actor);
    //  //  // AITraitsComponentReference->StartDetecting(Actor);
    //  // }
    //  // else
    //  // {
    //  //  
    //  // }
    // }
    OnTargetSightUpdated(Actor, Stimulus);
}

TargetTeamUpdated()

void ACustomAIController::TargetTeamUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetTeamUpdated);
    OnTargetTeamUpdated(Actor, Stimulus);
}

TargetTouchUpdated()

void ACustomAIController::TargetTouchUpdated ( AActor * Actor, const FAIStimulus & Stimulus )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::TargetTouchUpdated);
    if(Actor == nullptr){return;}
    if(AITraitsComponentReference != nullptr && Stimulus.WasSuccessfullySensed())
    {
        AITraitsComponentReference->TouchedByActor(Actor, Stimulus);
    }
    OnTargetTouchUpdated(Actor, Stimulus);
}

UpdateMovementSpeed()

void ACustomAIController::UpdateMovementSpeed ( const EAIMovementSpeed MovementSpeed = EAIMovementSpeed::Running, const EAIMovementType MovementType = EAIMovementType::Normal )

overrideprotectedvirtual

Implements IAIActionsInterface.

{
    if(CustomAICharacter != nullptr)
    {
        CustomAICharacter->UpdateMovementSpeed(MovementSpeed, MovementType);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogCustomCharacters, Error, TEXT("UpdateMovementSpeed Failed in Custom AI Controller"));}
}

UpdatePerceptionDetails()

void ACustomAIController::UpdatePerceptionDetails

(

)

const

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACustomAIController::UpdatePerceptionDetails);
    if(AIPerceptionComponent != nullptr && AITraitsComponentReference != nullptr)
    {
        AIPerceptionComponent->SetHearingRange(AITraitsComponentReference->GetHearingRange());
        //@BUG Max Age Doesn't Work in the Perception System    //
        //@see https://forums.unrealengine.com/t/aiperception-max-age-broken-or-not-implemented-correctly-while-setting-up-senses-in-editor/318932
        // AIPerceptionComponent->SetMaxAge(HearingConfig->StaticClass(), AITraitsComponentReference->GetHearingMaxAge());
        // AIPerceptionComponent->SetMaxAge(SightConfig->StaticClass(), AITraitsComponentReference->GetSightMaxAge());
        // AIPerceptionComponent->SetHearingMaxAge(AITraitsComponentReference->GetHearingMaxAge());
        AIPerceptionComponent->SetSightRange(AITraitsComponentReference->GetSightRange());
        AIPerceptionComponent->SetLoseSightRange(AITraitsComponentReference->GetLoseSightRange());
        AIPerceptionComponent->SetVisionAngle(AITraitsComponentReference->GetSightAngle());
        AIPerceptionComponent->SetAutoSuccessRange(AITraitsComponentReference->GetSightAutoDetectRange());
        AIPerceptionComponent->SetPOVBackwardOffset(AITraitsComponentReference->GetSightPOVBackwardsOffset());
        // AIPerceptionComponent->SetSightMaxAge(AITraitsComponentReference->GetSightMaxAge());
        // SetNearClippingRadius
        
        const EDifficultyLevel DifficultyLevel = UMenuBPLib::GetCurrentDifficultyLevel(this);
        switch (DifficultyLevel) {
        case EDifficultyLevel::Assisted:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), false);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), false);
            break;
        case EDifficultyLevel::Easy:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), false);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), false);
            break;
        case EDifficultyLevel::Normal:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), false);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), true);
            break;
        case EDifficultyLevel::Hard:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), true);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), true);
            break;
        case EDifficultyLevel::Expert:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), true);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), true);
            break;
        case EDifficultyLevel::Master:
            AIPerceptionComponent->SetSenseEnabled(UAISense_Actions::StaticClass(), true);
            AIPerceptionComponent->SetSenseEnabled(UAISense_Hearing::StaticClass(), true);
            break;
        }
    }
}

Member Data Documentation

ActionsConfig

class UAISenseConfig_Actions* ACustomAIController::ActionsConfig

protected

AIPerceptionComponent

class UAdvancedAIPerceptionComponent* ACustomAIController::AIPerceptionComponent

protected

AITraitsComponentReference

class UAITraitsComponent* ACustomAIController::AITraitsComponentReference

protected

bDebuggingMode

bool ACustomAIController::bDebuggingMode = false

protected

Behaviour

TObjectPtr<UBehaviorTree> ACustomAIController::Behaviour = nullptr

protected

CustomAICharacter

class ACustomAICharacter* ACustomAIController::CustomAICharacter = nullptr

protected

DamageConfig

class UAISenseConfig_Damage* ACustomAIController::DamageConfig

protected

HearingConfig

class UAISenseConfig_Hearing* ACustomAIController::HearingConfig

protected

MyTeamID

FGenericTeamId ACustomAIController::MyTeamID

PredictionConfig

class UAISenseConfig_Prediction* ACustomAIController::PredictionConfig

protected

SightConfig

class UAISenseConfig_Sight* ACustomAIController::SightConfig

protected

TeamConfig

class UAISenseConfig_Team* ACustomAIController::TeamConfig

protected

TeamID

uint8 ACustomAIController::TeamID = 2

protected

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/CustomALS/Source/CustomALS/Public/Character/CustomAIController.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/CustomALS/Source/CustomALS/Private/Character/CustomAIController.cpp