FHostileActorInfo Struct Reference

#include <AIDataTypes.h>

Public Member Functions
	FHostileActorInfo ()
	FHostileActorInfo (AActor *Actor)
	FHostileActorInfo (AActor *Actor, const FFactionRelationship &Relationship)
void	AddDamageReceivedByOwner (const float Value)
void	AddDamageDealtToOwner (const float Value)
void	AddHostility (const float Value)
void	AddVisibility (const float Value)
void	AddDetection (const float Value, const float MaxDetection, const float InvestigateDetection)
void	LostSightOnTarget ()
void	LostTarget (const float InvestigateDetection)
void	ClearDetection ()
bool	operator== (const FHostileActorInfo &Other) const
bool	IsValid () const
bool	IsHostile () const
bool	IsFriendly () const
bool	IsAllied () const
bool	IsNeutral () const
ERelationshipStatus	GetRelationshipStatus () const
FVector	GetLocation () const

Static Public Member Functions
static FHostileActorInfo	Empty ()

Public Attributes
AActor *	HostileActor = nullptr
FVector	LastSeenLocation = FVector::ZeroVector
float	DetectionLevel = 0.0f
bool	bDetected = false
bool	bInvestigate = false
bool	bDead = false
float	DamageReceivedByOwner = 0.0f
float	DamageDealtToOwner = 0.0f
float	VisibilityScore = 0.0f
float	TotalScore = 0.0f
float	TrustScore = 0.0f
float	HostilityScore = 100.0f
float	TrustDecreaseFactor = 10.0f
float	HostilityIncreaseFactor = 0.2f

Constructor & Destructor Documentation

FHostileActorInfo() [1/3]

FHostileActorInfo::FHostileActorInfo ( )

inline

    {
        
    };

FHostileActorInfo() [2/3]

FHostileActorInfo::FHostileActorInfo ( AActor * Actor )

inlineexplicit

    {
        HostileActor = Actor;
    };

FHostileActorInfo() [3/3]

FHostileActorInfo::FHostileActorInfo ( AActor * Actor, const FFactionRelationship & Relationship )

inlineexplicit

    {
        HostileActor = Actor;
        TrustScore = Relationship.TrustLevel;
        HostilityScore = Relationship.HostilityLevel;
    };

Member Function Documentation

AddDamageDealtToOwner()

void FHostileActorInfo::AddDamageDealtToOwner ( const float Value )

inline

    {
        DamageDealtToOwner += Value;
 
        // if(!bDetected)
        // {
        //  AddDetection(Value, MaxDetection, InvestigateDetection);
        // }
 
        //- @TODO Figure out formula for trust changing //
        TrustScore -= ((DamageDealtToOwner / TrustDecreaseFactor));
        HostilityScore += (DamageDealtToOwner / HostilityIncreaseFactor);
        // / (abs(TrustScore) / 100.0f)
 
        //- Scales, moves slower around 100 and -100    //
        // const float TrustFactor = abs(MaxTrust / (TrustScore + 0.1f));
        // FMath::Clamp(TrustFactor, 0.0, 0.0);
        
        
        
        // const float DecreaseScore = abs(TrustDecreaseFactor * (MaxTrust / (TrustScore + 0.1)) * DamageDealt);
        // TrustScore -= (DecreaseScore * Value);
 
        
        
        //- Max Trust = 100.0f  
        // TrustScore = (0.1f + (MaxTrust - TrustScore) / TrustDecreaseFactor) * DamageDealt;
    }

AddDamageReceivedByOwner()

void FHostileActorInfo::AddDamageReceivedByOwner ( const float Value )

inline

    {
        DamageReceivedByOwner += Value;
        //@TODO current doesn't do anything.
    }

AddDetection()

void FHostileActorInfo::AddDetection ( const float Value, const float MaxDetection, const float InvestigateDetection )

inline

    {
        DetectionLevel += Value;
        if(DetectionLevel >= InvestigateDetection)
        {
            bInvestigate = true;
        }
        if(DetectionLevel >= MaxDetection)
        {
            bDetected = true;
        }
        if(DetectionLevel < 0.0f)
        {
            DetectionLevel = 0.0f;
        }
        //- Only Save on Increase   //
        if(Value >= 0 && HostileActor != nullptr)
        {
            LastSeenLocation = HostileActor->GetActorLocation();
        }
    }

AddHostility()

void FHostileActorInfo::AddHostility ( const float Value )

inline

    {
        HostilityScore += Value;
    }

AddVisibility()

void FHostileActorInfo::AddVisibility ( const float Value )

inline

    {
        VisibilityScore += Value;
    }

ClearDetection()

void FHostileActorInfo::ClearDetection ( )

inline

    {
        DetectionLevel = 0.0f;
        bInvestigate = false;
        bDetected = false;
    }

Empty()

static FHostileActorInfo FHostileActorInfo::Empty ( )

inlinestatic

    {
        const FHostileActorInfo EmptyData;
        return EmptyData;
    }

GetLocation()

FVector FHostileActorInfo::GetLocation ( ) const

inline

    {
        if(HostileActor == nullptr && !LastSeenLocation.IsNearlyZero()){return LastSeenLocation;}
        if(HostileActor == nullptr){return FVector::ZeroVector;}
        return HostileActor->GetActorLocation();
    }

GetRelationshipStatus()

ERelationshipStatus FHostileActorInfo::GetRelationshipStatus ( ) const

inline

    {
        return GetRelationship(TrustScore, HostilityScore);
    }

IsAllied()

bool FHostileActorInfo::IsAllied ( ) const

inline

    {
        if(TrustScore >= 40.0f && HostilityScore <= 20.0f)
        {
            return true;
        }
        return false;
    }

IsFriendly()

bool FHostileActorInfo::IsFriendly ( ) const

inline

    {
        if(TrustScore >= AIRelationShipVars::TrustLevelFriendly && HostilityScore <= AIRelationShipVars::HostilityLevelFriendly)
        {
            return true;
        }
        return false;
    }

IsHostile()

bool FHostileActorInfo::IsHostile ( ) const

inline

    {
        if(HostilityScore >= AIRelationShipVars::HostilityLevelHostile)
        {
            return true;
        }
        return false;
    }

IsNeutral()

bool FHostileActorInfo::IsNeutral ( ) const

inline

    {
        if(TrustScore <= 0.0f && HostilityScore >= 40.0f)
        {
            return true;
        }
        return false;
    }

IsValid()

bool FHostileActorInfo::IsValid ( ) const

inline

Returns

if Hostile Actor is Set

    {
        return HostileActor != nullptr;
    }

LostSightOnTarget()

void FHostileActorInfo::LostSightOnTarget ( )

inline

    {
        if(HostileActor == nullptr){return;}
        LastSeenLocation = HostileActor->GetActorLocation();
    }

LostTarget()

void FHostileActorInfo::LostTarget ( const float InvestigateDetection )

inline

    {
        DetectionLevel = InvestigateDetection;
        bInvestigate = true;
    }

operator==()

bool FHostileActorInfo::operator== ( const FHostileActorInfo & Other ) const

inline

    {
        return HostileActor == Other.HostileActor;
    }

Member Data Documentation

bDead

bool FHostileActorInfo::bDead = false

bDetected

bool FHostileActorInfo::bDetected = false

bInvestigate

bool FHostileActorInfo::bInvestigate = false

DamageDealtToOwner

float FHostileActorInfo::DamageDealtToOwner = 0.0f

Damage Dealt to Owner

DamageReceivedByOwner

float FHostileActorInfo::DamageReceivedByOwner = 0.0f

Damage Owner has done to this Character

DetectionLevel

float FHostileActorInfo::DetectionLevel = 0.0f

HostileActor

AActor* FHostileActorInfo::HostileActor = nullptr

HostilityIncreaseFactor

float FHostileActorInfo::HostilityIncreaseFactor = 0.2f

HostilityScore

float FHostileActorInfo::HostilityScore = 100.0f

LastSeenLocation

FVector FHostileActorInfo::LastSeenLocation = FVector::ZeroVector

TotalScore

float FHostileActorInfo::TotalScore = 0.0f

TrustDecreaseFactor

float FHostileActorInfo::TrustDecreaseFactor = 10.0f

TrustScore

float FHostileActorInfo::TrustScore = 0.0f

VisibilityScore

float FHostileActorInfo::VisibilityScore = 0.0f

---

The documentation for this struct was generated from the following file:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Public/Data/AIDataTypes.h