AIDataTypes.h

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/DataTable.h"
#include "Interfaces/StealthInterface.h"
#include "AIDataTypes.generated.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogAIToolKit, Display, All);
 
 
namespace AIRelationShipVars
{
 
    
    inline float TrustLevelFriendly = 100.0f;
    inline float HostilityLevelFriendly = 0.0f;
 
    inline float TrustLevelAllied = 40.0f;
    inline float HostilityLevelAllied = HostilityLevelFriendly;
 
    inline float TrustLevelNeutral = 0.0f;
    inline float HostilityLevelNeutral = 20.0f;
    
    inline float TrustLevelHostile = -40.0f;
    inline float HostilityLevelHostile = 100.0f;
    
    inline float TrustLevelEnemy = -100.0f;
    inline float HostilityLevelEnemy= 200.0f;
}
 
 
 
UENUM(BlueprintType)
enum class EAIResponse : uint8
{
    Dialogue,
    Command,
    Trade,
    
    // Combat,
    // Fetch,
};
 
 
 
UENUM(BlueprintType, meta = (ScriptName = "EAISensePython"))
enum class EAISense : uint8
{
    Sight,
    Hearing,
    Damage,
    Team,
    Prediction,
    Touch,
    Action,
    Custom
};
 
UENUM(BlueprintType)
enum class ECharacterType : uint8
{
    Human,
    Alien,
    Robot,
    Zombie,
    Raider,
    Defence
};
 
UENUM(BlueprintType)
enum class EAIMovementSpeed : uint8
{
    Walking,
    Jogging,
    Running,
    Sprinting,
};
 
UENUM(BlueprintType)
enum class EAIMovementType : uint8
{
    Normal,
    Injured,
    Responsive,
    Sluggish,
};
 
 
UENUM(BlueprintType)
enum class EFactionType : uint8
{
    Default,
    Alliance, //- Space cops, Trying to bring peace
    Militia,    //- Military who will forcefully bring peace 
    Vipers, //- Free Roaming Humans who don't obey the law of the alliance, but are not hostile,  //
    Jackals,    //- Raiders who will kill anyone
    TheBrotherhood, //- Kidnap and Sacrifice people to become zombies, keep zombies as weapons  have slaves //
    Robots, //- AI Machines who think humans are destroying themselves, willing to destroy some for the good of all
    ChurchOfTheMachine, //- Humans who worship Robots and agree, even when the robots don't agree with them //
    Zombies,    //-  eat brain  //
    None,   //- Vehicle, etc.   //
};
 
 
//@ TODO Possibly split these into two, AIState - the Alert level state,
//@ TODO and AITask which would be the current job the AI is trying to do   
UENUM(BlueprintType)    
enum class EAIStateType : uint8
{
    Default,
    Patrol, //- the AI character follows a designated route or area, keeping a vigilant eye for any unusual activities or intruders. They maintain a sense of alertness while monitoring their surroundings and ensuring the designated area remains secure
    Searching, //- This state occurs when the AI character is actively searching for something specific, such as a missing item, a hidden passage, or a particular individual. They meticulously investigate the surroundings, perform thorough searches, and employ various techniques to locate the desired target or object
    Protect, //- When in the Protect state, the AI character focuses on safeguarding a specific target or area. This could involve escorting a VIP, defending a valuable asset, or securing a critical location. They actively respond to threats, engage in combat if necessary, and prioritize the protection of the assigned target or area.
    Hostile, //- the AI character is actively aggressive and ready to engage in combat. They pursue and attack any perceived threats or targets, using their skills and weapons to eliminate adversaries and defend their territory
    Working, //- character focuses on performing their assigned tasks or duties. This could involve operating ship systems, managing resources, or fulfilling maintenance responsibilities. They carry out their duties efficiently, ensuring the smooth functioning of the ship and its operations.
    Sleeping, //- character rests and recharges. They find a designated sleeping area, such as crew quarters or sleeping pods, and go through a period of inactivity to restore their energy and stamina.
    Relaxed, //- character takes a break from their regular duties. They engage in leisure activities, such as reading, listening to music, or enjoying recreational areas on the ship. This state allows them to unwind and rejuvenate before returning to their assigned tasks.
    Mingle, //- socialize with other crew members, fostering connections and building relationships. They engage in conversations, share stories, and participate in communal activities, contributing to a sense of camaraderie and cohesion among the crew.
    Investigate, //- This state would be triggered when the AI detects something suspicious or unusual. It would involve the AI moving to the location, examining the area, and potentially alerting others if necessary
    Alert, //- This state would occur when the AI becomes aware of a potential threat or danger. They would take defensive positions, call for backup, or actively search for the source of the threat.
    Scavenging, //- In this state, the AI would actively search for resources or valuable items within their environment
    Training, //- AI characters in this state would be engaged in physical or mental training activities, honing their combat skills, or improving their knowledge and abilities
    Evading, //-  when the AI character is trying to escape or avoid being detected by enemies or pursuing threats
};
 
UENUM(BlueprintType)
enum class ERelationshipStatus : uint8
{
    Enemy,
    Hostile,
    UnFriendly,
    Neutral,
    Default,
    Allied,
    Friendly,
};
 
UENUM(BlueprintType)
enum class EAlignment : uint8
{
    Lawful,
    Chaotic,
    Neutral,
    Good,
    Evil
};
 
// UENUM(BlueprintType)
// enum class ELookBehavior : uint8
// {
//  LB_Rotate       UMETA(DisplayName="Rotate"),
//  LB_LookAround   UMETA(DisplayName="Look Around"),
//  LB_LookUp       UMETA(DisplayName="Look Up"),
// };
 
static ERelationshipStatus GetRelationship(const float TrustLevel, const float HostilityLevel)
{
    //- Hostility is higher or equal than 200.0f OR if Trust is below or equal -100.f   //
    if(HostilityLevel >= AIRelationShipVars::HostilityLevelEnemy || TrustLevel <= AIRelationShipVars::TrustLevelEnemy)
    {
        return ERelationshipStatus::Enemy;
    }
    //- Hostility is higher or equal than 100.0f OR if Trust is below or equal -40.f //
    if(HostilityLevel >= AIRelationShipVars::HostilityLevelHostile || TrustLevel <= AIRelationShipVars::TrustLevelHostile)
    {
        return ERelationshipStatus::Hostile;
    }
    
    //- If they have MAX Trust, & No Hostility  //
    if(TrustLevel >= AIRelationShipVars::TrustLevelFriendly && HostilityLevel == AIRelationShipVars::HostilityLevelFriendly)
    {
        return ERelationshipStatus::Friendly;
    }
    //- If above 40 Trust, & No Hostility   //
    if(TrustLevel >= AIRelationShipVars::TrustLevelAllied && HostilityLevel == AIRelationShipVars::HostilityLevelAllied)
    {
        return ERelationshipStatus::Allied;
    }
    //- If Trust is above or equal 0 & Hostility is Lower or equal than 20  //
    if(TrustLevel >= AIRelationShipVars::TrustLevelNeutral && HostilityLevel <= AIRelationShipVars::HostilityLevelNeutral)
    {
        return ERelationshipStatus::Neutral;
    }
    //- Should cover everything else?   //
    //- If Trust is above Hostile (-40.f) & Hostility is Lower than Hostile (100.0f)    //
    if(TrustLevel >= AIRelationShipVars::TrustLevelHostile && HostilityLevel <= AIRelationShipVars::HostilityLevelHostile)
    {
        return ERelationshipStatus::UnFriendly;
    }
    return ERelationshipStatus::Default;
    // //- if Trust is above -40 & Hostility is higher than 100.0f  //
    // if(TrustLevel >= AIRelationShipVars::TrustLevelHostile && HostilityLevel >= AIRelationShipVars::HostilityLevelHostile)
    // {
    //  return ERelationshipStatus::Hostile;
    // }
    // //- if Trust is above -100.0f & Hostility is Higher than 200.0f  //
    // if(TrustLevel >= AIRelationShipVars::TrustLevelEnemy && HostilityLevel >= AIRelationShipVars::HostilityLevelEnemy)
    // {
    //  return ERelationshipStatus::Enemy;
    // }
    // Handle any other case, possibly setting to Default or another status
}
 
 
USTRUCT(BlueprintType)
struct FStealthData
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    TArray<UAnimMontage*> NonLethalTakedownAnims;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    TArray<UAnimMontage*> UnarmedTakedownAnims;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    TArray<UAnimMontage*> KnifeTakedownAnims;
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    float StealthTakedownDamage = 20000.0f;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    float StealthActorDistance = -175.0f;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Stealth")
    FName StealthTakedownName = "Stealth_Attack_NonLethal_01";
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Stealth")
    AActor* StealthActor = nullptr;
 
    bool bStealthTakedownAvailable = false; 
    bool bPerformingStealthTakedown = false;
 
    
    
    class IStealthInterface* StealthActorInterface = nullptr;
    FTimerHandle StealthTakedownTimerHandle;
 
    FStealthData()
    {
        
    }
 
    bool SetStealthActor(AActor* Actor)
    {
        if(Actor != nullptr)
        {
            StealthActor = Actor;
            IStealthInterface* StealthActorInterfaceRef = Cast<IStealthInterface>(Actor);
            if(StealthActorInterfaceRef != nullptr)
            {
                StealthActorInterface = StealthActorInterfaceRef;
                return true;
            }
        }
        return false;
    }
 
};
 
 
USTRUCT(BlueprintType)
struct FFactionRelationship : public FTableRowBase
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    ERelationshipStatus RelationshipStatus = ERelationshipStatus::Default;
 
    //- Faction to Compare to   //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    EFactionType OtherFaction = EFactionType::Default;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float TrustLevel = 0.0f;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float HostilityLevel = 0.0f;
 
    void AddHostility(const float Value)
    {
        HostilityLevel += Value;
        UpdateRelationshipStatus();
    }
    void AddTrust(const float Value)
    {
        TrustLevel += Value;
        UpdateRelationshipStatus();
    }
    
    void UpdateRelationshipStatus()
    {
        if (TrustLevel >= 100 && HostilityLevel == 0)
        {
            RelationshipStatus = ERelationshipStatus::Friendly;
        }
        else if (TrustLevel >= 40 && HostilityLevel == 0)
        {
            RelationshipStatus = ERelationshipStatus::Allied;
        }
        else if (TrustLevel >= 20 && HostilityLevel <= 20)
        {
            RelationshipStatus = ERelationshipStatus::Neutral;
        }
        else if (TrustLevel == 0 && HostilityLevel >= 40)
        {
            RelationshipStatus = ERelationshipStatus::UnFriendly;
        }
        else if (TrustLevel <= -40 && HostilityLevel >= 100)
        {
            RelationshipStatus = ERelationshipStatus::Hostile;
        }
        else if (TrustLevel <= -100 && HostilityLevel >= 200)
        {
            RelationshipStatus = ERelationshipStatus::Enemy;
        }
        else
        {
            // Handle any other case, possibly setting to Default or another status
            RelationshipStatus = ERelationshipStatus::Default;
        }
    }
 
    
    bool IsHostile() const
    {
        if(HostilityLevel >= 100.0f)
        {
            return true;
        }
        return false;
    }
    
    static FFactionRelationship Empty()
    {
        FFactionRelationship EmptyData;
        return EmptyData;
    }
};
 
USTRUCT(BlueprintType)
struct FCharacterEmotions
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float FearLevel = 0.0f;
    //- perception
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float ReactionTime = 1.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float Accuracy = 1.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float AggressiveLevel = 0.0f;
    //- higher with lower Intelegence
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float RecklessnessLevel = 0.0f;
    //- perception
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float AlertnessLevel = 0.0f;
    //- Extra Perception    //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Traits")
    float KnowledgeOfPlayerLocation = 0.0f; 
};
 
 
USTRUCT(BlueprintType)
struct FHostileActorInfo
{
    GENERATED_BODY()
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    AActor* HostileActor = nullptr;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    FVector LastSeenLocation = FVector::ZeroVector;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float DetectionLevel = 0.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    bool bDetected = false;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    bool bInvestigate = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    bool bDead = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float DamageReceivedByOwner = 0.0f;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float DamageDealtToOwner = 0.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float VisibilityScore = 0.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float TotalScore = 0.0f;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float TrustScore = 0.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float HostilityScore = 100.0f;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float TrustDecreaseFactor = 10.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="AI")
    float HostilityIncreaseFactor = 0.2f;
 
    FHostileActorInfo()
    {
        
    };
    explicit FHostileActorInfo(AActor* Actor)
    {
        HostileActor = Actor;
    };
    explicit FHostileActorInfo(AActor* Actor, const FFactionRelationship& Relationship)
    {
        HostileActor = Actor;
        TrustScore = Relationship.TrustLevel;
        HostilityScore = Relationship.HostilityLevel;
    };
 
    //- Tracks how much Damage Owner has done to this character //
    void AddDamageReceivedByOwner(const float Value)
    {
        DamageReceivedByOwner += Value;
        //@TODO current doesn't do anything.
    }
 
 
    //- Tracks how much Damage the character has done, Also Adds Detection Level if not Yet Detected    //
    void AddDamageDealtToOwner(const float Value)
    {
        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;
    }
    void AddHostility(const float Value)
    {
        HostilityScore += Value;
    }
 
    void AddVisibility(const float Value)
    {
        VisibilityScore += Value;
    }
    void AddDetection(const float Value, const float MaxDetection, const float InvestigateDetection)
    {
        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();
        }
    }
    void LostSightOnTarget()
    {
        if(HostileActor == nullptr){return;}
        LastSeenLocation = HostileActor->GetActorLocation();
    }
 
    void LostTarget(const float InvestigateDetection)
    {
        DetectionLevel = InvestigateDetection;
        bInvestigate = true;
    }
 
    void ClearDetection()
    {
        DetectionLevel = 0.0f;
        bInvestigate = false;
        bDetected = false;
    }
 
 
    static FHostileActorInfo Empty()
    {
        const FHostileActorInfo EmptyData;
        return EmptyData;
    }
    bool operator==(const FHostileActorInfo& Other) const
    {
        return HostileActor == Other.HostileActor;
    }
    bool IsValid() const
    {
        return HostileActor != nullptr;
    }
    //@TODO check these, Make Global vars for Numbers
    bool IsHostile() const
    {
        if(HostilityScore >= AIRelationShipVars::HostilityLevelHostile)
        {
            return true;
        }
        return false;
    }
    bool IsFriendly() const
    {
        if(TrustScore >= AIRelationShipVars::TrustLevelFriendly && HostilityScore <= AIRelationShipVars::HostilityLevelFriendly)
        {
            return true;
        }
        return false;
    }
    bool IsAllied() const
    {
        if(TrustScore >= 40.0f && HostilityScore <= 20.0f)
        {
            return true;
        }
        return false;
    }
    bool IsNeutral() const
    {
        if(TrustScore <= 0.0f && HostilityScore >= 40.0f)
        {
            return true;
        }
        return false;
    }
 
    ERelationshipStatus GetRelationshipStatus() const
    {
        return GetRelationship(TrustScore, HostilityScore);
    }
 
    FVector GetLocation() const
    {
        if(HostileActor == nullptr && !LastSeenLocation.IsNearlyZero()){return LastSeenLocation;}
        if(HostileActor == nullptr){return FVector::ZeroVector;}
        return HostileActor->GetActorLocation();
    }
 
 
    // bool IsEnemy() const
    // {
    //  if(TrustScore <= -100.0f && HostilityScore >= 200.0f)
    //  {
    //      return true;
    //  }
    //  return false;
    // }
 
 
};
 
 
USTRUCT(BlueprintType)
struct FFactionRelationshipTotal : public FTableRowBase
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    EFactionType FactionType = EFactionType::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    TArray<FFactionRelationship> Relationships;
    
    static FFactionRelationshipTotal Empty()
    {
        FFactionRelationshipTotal EmptyData;
        return EmptyData;
    }
 
};
 
 
USTRUCT(BlueprintType)
struct FFactionData: public FTableRowBase
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    EFactionType FactionType = EFactionType::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float Strength = 50.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    int32 Members = 100;
    //- Army size //
    //- Weapons //
};
 
 
//-     How One Faction is Seen by Player   //
USTRUCT(BlueprintType)
struct FFactionStats: public FTableRowBase
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    EFactionType FactionType = EFactionType::Default;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float TrustLevel = 0.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float HostilityLevel = 0.0f;
    //- Will Improve or harm players standing with factions
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float ReputationPoints = 0.0f;
    //- How much Completing Quests for or against influences reputation //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float QuestInfluenceMultiplier = 0.0f;
    //- Affects Dialogue options, unlocks quests and info   //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Factions")
    float DialogueInfluence = 0.0f;
 
    // TMap<EFactionType, FFactionRelationship> OtherFactionRelationships;
 
    //TArray<FPerks> EarnedPerks
    
    // bool IsHostile(const FFactionStats& Other) const
    // bool IsHostile() const
    // {
    //  if(HostilityLevel >= 100.0f)
    //  {
    //      return true;
    //  }
    //  return false;
    // }
    
    // bool IsFaction(const FFactionStats& Other) const
    // {
    //  return FactionType == Other.FactionType;
    // }
};
 
 
 
// https://forums.unrealengine.com/t/how-do-i-use-the-ai-perception-teams/120837/2
// UENUM(BlueprintType)    
// enum class EGameTeam  : uint8
// {
//  Neutral, //Everyone ignores this team
//  RedTeam,
//  BlueTeam,
//  TeamA,
//  TeamB 
// };
//
// USTRUCT(BlueprintType)
// struct FTeamAttitude
// {
//  GENERATED_BODY()
// public:
//  UPROPERTY(BlueprintReadWrite, EditAnywhere)
//  TArray<TEnumAsByte<ETeamAttitude::Type>> Attitude;
//
//  FTeamAttitude() {};
//
//  FTeamAttitude(std::initializer_list<TEnumAsByte<ETeamAttitude::Type>> attitudes):
//      Attitude(std::move(attitudes))
//  { };
// };
 
 
USTRUCT(BlueprintType)
struct FAISpawnLocationData
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    TSubclassOf<APawn> ActorToSpawn;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    int32 AmountToSpawn = 1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    float InitialDelay = 0.2f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    float TimeBetweenSpawnsMin = 1.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    float TimeBetweenSpawnsMax = 10.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    FString CharacterName = "Default Name";
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit")
    EAIStateType CharacterState = EAIStateType::Default;
    //- Where should the AI stand?
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Location")
    AActor* StationaryLocation = nullptr;
    //- What path should the AI follow?
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Location")
    TArray<AActor*> PathLocations;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Location")
    bool bUseSpawnLocations = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Location")
    bool bUseSpawnLocationsGlobal = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Location", meta=(EditCondition=bUseSpawnLocations))
    TArray<FVector> SpawnLocations;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Random")
    bool bUseRandomSpawnNumber = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Random")
    int32 SpawnMin = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="AI Tool Kit|Random")
    int32 SpawnMax = 1;
    
};
 
// USTRUCT(BlueprintType)
// struct FActorPerceptionInfoBP
// {
//  GENERATED_BODY()
//
//  
//  TWeakObjectPtr<AActor> Target;
//
//  // TArray<FAIStimulus> LastSensedStimuli;
//
//  /** if != MAX indicates the sense that takes precedense over other senses when it comes
//      to determining last stimulus location */
//  // FAISenseID DominantSense;
//
//  /** indicates whether this Actor is hostile to perception holder */
//  uint32 bIsHostile : 1;
//  
//  // FActorPerceptionInfo(AActor* InTarget = NULL)
//  //  : Target(InTarget), DominantSense(FAISenseID::InvalidID())
//  // {
//  //  LastSensedStimuli.AddDefaulted(FAISenseID::GetSize());
//  // }
//
//  /** Retrieves last known location. Active (last reported as "successful")
//   *  stimuli are preferred. */
//  // FVector GetLastStimulusLocation(float* OptionalAge = NULL) 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;
//  // }
//
//  /** it includes both currently live (visible) stimulus, as well as "remembered" ones */
//  // 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;
//  // }
//
//  /** Indicates currently live (visible) stimulus from any sense */
//  // 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;
//  // }
//
//  // /** Retrieves location of the last sensed stimuli for a given sense
//  // * @param Sense   The AISenseID of the sense
//  // *
//  // * @return Location of the last sensed stimuli or FAISystem::InvalidLocation if given sense has never registered related Target actor or if last stimuli has expired.
//  // */
//  // FORCEINLINE FVector GetStimulusLocation(FAISenseID Sense) const
//  // {
//  //  return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false)) ? LastSensedStimuli[Sense].StimulusLocation : FAISystem::InvalidLocation;
//  // }
//
//  /** Retrieves receiver location of the last sense stimuli for a given sense
//  * @param Sense  The AISenseID of the sense
//  *
//  * @return Location of the receiver for the last sensed stimuli or FAISystem::InvalidLocation if given sense has never registered related Target actor or last stimuli has expired.
//  */
//  FORCEINLINE FVector GetReceiverLocation(FAISenseID Sense) const
//  {
//      return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false)) ? LastSensedStimuli[Sense].ReceiverLocation : FAISystem::InvalidLocation;
//  }
//
//  UE_DEPRECATED(4.23, "This method is identical to IsSenseActive and will be removed in future versions. Please use IsSenseActive to check for a currently active stimuli or HasKnownStimulusOfSense for an active or remembered stimuli.")
//  FORCEINLINE bool IsSenseRegistered(FAISenseID Sense) const
//  {
//      return LastSensedStimuli.IsValidIndex(Sense) && LastSensedStimuli[Sense].IsActive();
//  }
//
//  /** Indicates a currently active or "remembered" stimuli for a given sense
//  * @param Sense  The AISenseID of the sense
//  *
//  * @return True if a target has been registered (even if not currently sensed) for the given sense and the stimuli is not expired.
//  */
//  FORCEINLINE bool HasKnownStimulusOfSense(FAISenseID Sense) const
//  {
//      return LastSensedStimuli.IsValidIndex(Sense) && (LastSensedStimuli[Sense].IsValid() && (LastSensedStimuli[Sense].IsExpired() == false));
//  }
//
//  /** Indicates a currently active stimuli for a given sense
//  * @param Sense  The AISenseID of the sense
//  *
//  * @return True if a target is still sensed for the given sense and the stimuli is not expired.
//  */
//  FORCEINLINE bool IsSenseActive(FAISenseID Sense) const
//  {
//      return LastSensedStimuli.IsValidIndex(Sense) && LastSensedStimuli[Sense].IsActive();
//  }
//  
//  /** takes all "newer" info from Other and absorbs it */
//  void Merge(const FActorPerceptionInfo& Other);
// };
//