BaseData.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 "BaseGameplayTags.h"
#include "Engine/DataTable.h"
#include "BaseData.generated.h"
 
 
class UInputAction;
 
DECLARE_LOG_CATEGORY_EXTERN(LogBaseHelpers, Display, All);
DECLARE_LOG_CATEGORY_CLASS(LogBasePlayerState, Display, All);
 
DECLARE_STATS_GROUP(TEXT("Base Helpers"), STATGROUP_BaseHelpers, STATCAT_Advanced)
DECLARE_CYCLE_STAT_EXTERN(TEXT("BPLib"), STATGROUP_BaseHelpers_BPLib, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Character Component"), STATGROUP_BaseHelpers_CharacterComp, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Player Controller Component"), STATGROUP_BaseHelpers_PlayerControllerComp, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("GameMode"), STATGROUP_BaseHelpers_GameMode, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("GameState"), STATGROUP_BaseHelpers_GameState, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Common Actor Component"), STATGROUP_BaseHelpers_ActorComp, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Character Base"), STATGROUP_BaseHelpers_CharacterBase, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("PlayerController Base"), STATGROUP_BaseHelpers_PlayerControllerBase, STATGROUP_BaseHelpers, BASEHELPERS_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Actor Base"), STATGROUP_BaseHelpers_ActorBase, STATGROUP_BaseHelpers, BASEHELPERS_API);
 
 
static int32 DebugCharacterComponents = 0;
 
 
UENUM(Blueprintable, BlueprintType, meta = (ScriptName = "EDamageTypePython"))
enum class EDamageType : uint8
{
    Default,
    Base,
    Bullet,
    Laser,
    Plasma,
    Electrical,
    Explosive,
    Fall,
    Fire,
    Melee,
    NonLethalBase,
    NonLethalMelee,
    NonLethalBullet,
    Poison,
    Water,
};
 
UENUM(BlueprintType)
enum class EDeathType : uint8
{
    Default,
    Headshot,
    Bullet,
    Laser,
    Plasma,
    Fire,
    Explosion,
    Electrical,
    Fall,
    Hit,
    Melee,
    Water,
    Zombie,
    Poison,
    NonLethal,
};
 
UENUM(BlueprintType, meta = (ScriptName = "ESoundSourcePython"))
enum class ESoundSource : uint8
{
    Footstep,
    Jump,
    DryFire,
    BulletFire,
    SilencedBulletFire,
    BulletImpact,
    Melee,
    MeleeWeapon,
    Reload,
    Interaction,
    Door,
    Voice,
    Explosion,
    Gadget,
    Alarms, //Alerts
    Climbing,
    Distractions,
    EnvironmentalHazards,
};
 
 
UENUM(BlueprintType)
enum class EGameControllerType : uint8
{
    Keyboard,
    XboxSeries,
    XboxOne,
    Playstation5,
    Playstation4,
    SwitchPro,
    SwitchJoyCon,
    SteamDeck,
    Generic,
};
 
UENUM(BlueprintType)
enum class ESize : uint8
{
    ExtraSmall,
    Small,
    SmallMedium,
    Medium,
    MediumLarge,
    Large,
    ExtraLarge,
};
 
//@TODO 
UENUM(BlueprintType)
enum class EVehicleMode : uint8
{
    None,
    Driver,
    Passenger,
    Gunner,
};
 
UENUM(Blueprintable, BlueprintType)
enum class EBodyPartName : uint8
{
    Pelvis,
    Head,
    Spine,
    RightArm,
    LeftArm,
    RightHand,
    LeftHand,
    RightLeg,
    LeftLeg,
};
 
 
//@TODO maybe not needed for interaction part, can just change prompt
UENUM(BlueprintType, meta = (ScriptName = "EInteractionTypePython"))
enum class EInteractionType : uint8
{
    Default,
    Interact,
    Use,
    Talk,
    Trade,
    Buy,
    Sell,
    Switch,
    TurnOn,
    TurnOff,
    Hack,
    Pickup,
    Open,
    Close,
    Lock,
    Unlock,
    Inspect,
    Tie,
    Untie,
    Eat,
    Drink,
    Swap,
    Sleep,
    Wakeup,
    Climb,
    Push,
    Pull,
    Craft,
    Build,
    Repair,
    Takedown,
    KnockOut,
    Pilot,
    Enter,
    Delete,
    Full,
    Exit,
    
    Command,
    Attack,
    Follow,
    Wait,
 
    None,
};
 
UENUM(BlueprintType)
enum class EAIStimuliType : uint8
{
    Default,
    Door,
    Defence,
    AutomaticDoor,
    Item,
    Switch,
    WeaponPickup,
    MeleeWeaponPickup,
    WeaponAmmo,
    WeaponAttachment,
    Health,
    Character,
    DeadBody,
    PatrolPoint,
    PatrolPath,
    Vehicle
};
 
UENUM(BlueprintType)
enum class EAIActionType : uint8
{
    Default,
    Patrol,
    PatrolTaken,
    JoinGroup, //- Add AI to Group who now follow Leader    //
    Attack,
    TargetFound,
    TargetLost,
    TargetDown,
    Help,
    //? Heal,
    Retreat,
    Flank,
    //? Regroup,
    Search, //- Unsure if found person, ask everyone to start Searching the whole area  
    Investigate, //- Heard Noise or saw something, Search Particular Area   //
    Alert,  //- Everyone be on Alert    //
    Protect,    //- Protect Specified Actor //
    
    //@TODO Fill out more actions
    
};
 
// UENUM(BlueprintType)
// enum class EButtonPressType : uint8
// {
//  Hold,
//  Press,
//  Tap,
//  DoubleTap,
// };
 
USTRUCT(BlueprintType)
struct FUniqueID
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString ID = "ID";
 
    void SetUniqueNumber(const int32 NewID)
    {
        UniqueID = NewID;
    }
    int32 GetUniqueNumber() const
    {
        return UniqueID;
    }
    bool IsUnique() const
    {
        return UniqueID != -1;
    }
 
 
    FUniqueID()
    {
        
    }
    explicit FUniqueID(const FString& NewID)
    {
        ID = NewID;
    };
    explicit FUniqueID(const FString& NewID, const int32 NewUniqueID)
    {
        ID = NewID;
        UniqueID = NewUniqueID;
    };
 
    bool IsValid() const
    {
        bool bValid = false;
        if(ID != "ID"){bValid = true;};
        if(ID.IsEmpty()){bValid = false;}
        return bValid;
    }
    bool operator==(const FUniqueID& Other) const
    {
        return (ID == Other.ID) && (UniqueID == Other.UniqueID);
    }
    bool operator!=(const FUniqueID& Other) const
    {
        return (ID != Other.ID) || (ID == Other.ID && UniqueID != Other.UniqueID);
    }
protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="General")
    int32 UniqueID = -1;
};
 
// Use For Dialogue/Interactions 
USTRUCT(BlueprintType)
struct FCharacterInfo
{
    GENERATED_BODY()
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Base Actor")
    AActor* Actor = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Base Actor")
    FText DisplayName;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Base Actor")
    UTexture2D* DisplayImage = nullptr;
 
    
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Base Actor")
    // FTransform ActorTransform = FTransform(FVector::ZeroVector);
};
 
 
 
USTRUCT(BlueprintType)
struct FInteractionType
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    EInteractionType InteractionType = EInteractionType::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bHold = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bAvailable = true;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bHide = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bShowButton = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bCustomInteraction = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    FString CustomInteractionText = "Default";
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    // UTexture2D* Icon = nullptr;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    float InteractTimeMultiplier = 1.0f;
    
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction", meta=(DisplayThumbnail = false))
    UInputAction* MappingContext = nullptr;
    
    
 
    FInteractionType()
    {
        
    }
    explicit FInteractionType(const EInteractionType Type)
    {
        InteractionType = Type;
    }
    explicit FInteractionType(const EInteractionType Type, const bool bStartHidden)
    {
        InteractionType = Type;
        bHide = bStartHidden;
    }
    explicit FInteractionType(const FString& CustomText)
    {
        bCustomInteraction = true;
        CustomInteractionText = CustomText;
    }
    explicit FInteractionType(const FString& CustomText, const bool bShowButtonPrompt)
    {
        bCustomInteraction = true;
        CustomInteractionText = CustomText;
        bShowButton = bShowButtonPrompt;
    }
    static FInteractionType None()
    {
        const FInteractionType None;
        return None;
    }
    bool operator==(const FInteractionType& Other) const
    {
        bool bEqual = true;
        if(InteractionType != Other.InteractionType)
        {
            bEqual = false;
        }
        // if(bHold != Other.bHold)
        // {
        //  bEqual = false;
        // }
        // if(bAvailable != Other.bAvailable)
        // {
        //  bEqual = false;
        // }
        // if(bAvailable != Other.bHide)
        // {
        //  bEqual = false;
        // }
        return bEqual;
    }
};
 
 
 
USTRUCT(BlueprintType)
struct FInteractionData
{
    GENERATED_BODY()
 
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Interaction")
    // FText Name;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Interaction")
    FCharacterInfo DisplayInfo;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    TArray<FInteractionType> InteractionTypes;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    EAIStimuliType StimuliType = EAIStimuliType::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bAIControlled = false;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bShowMenu = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    bool bShowDefault = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    int32 DefaultInteraction = 0;
 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction", meta=(EditCondition="bShowMenu"))
    // int32 MenuItems = 3;
 
    
 
    FInteractionData()
    {
        
    };
    
    explicit FInteractionData(const EInteractionType Default)
    {
        DefaultInteraction = InteractionTypes.Add(FInteractionType(Default));
        // InteractionStructTypes
    }
    explicit FInteractionData(const EInteractionType Default, const EAIStimuliType Stimuli)
    {
        DefaultInteraction = InteractionTypes.Add(FInteractionType(Default));
        StimuliType = Stimuli;
    }
    explicit FInteractionData(const FInteractionType Default, const EAIStimuliType Stimuli)
    {
        DefaultInteraction = InteractionTypes.Add(FInteractionType(Default));
        StimuliType = Stimuli;
    }
 
 
    bool GetDefaultInteraction(FInteractionType& Default) const
    {
        if(InteractionTypes.IsValidIndex(DefaultInteraction))
        {
            Default = InteractionTypes[DefaultInteraction];
            return true;
        }
        return false;
    }
 
    bool GetInteraction(FInteractionType& Type, const EInteractionType Interaction) const
    {
        for(const auto& InteractionType : InteractionTypes)
        {
            if(Interaction == InteractionType.InteractionType)
            {
                Type = InteractionType;
                return true;
            }
        }
        return false;
    }
    
    bool SetInteractionHidden(const EInteractionType Interaction, const bool bValue)
    {
        for(auto& InteractionType : InteractionTypes)
        {
            if(Interaction == InteractionType.InteractionType)
            {
                InteractionType.bHide = bValue;
                return true;
            }
        }
        return false;
    }
    void SetOnlyInteractionVisible(const EInteractionType Interaction)
    {
        for(auto& InteractionType : InteractionTypes)
        {
            InteractionType.bHide = true;
            if(Interaction == InteractionType.InteractionType)
            {
                InteractionType.bHide = false;
            }
        }
    }
    void SetOnlyInteractionVisible(const FString& Interaction)
    {
        for(auto& InteractionType : InteractionTypes)
        {
            InteractionType.bHide = true;
            if(Interaction == InteractionType.CustomInteractionText)
            {
                InteractionType.bHide = false;
            }
        }
    }
 
    bool SetInteractionAvailable(const EInteractionType Interaction, const bool bValue)
    {
        for(auto& InteractionType : InteractionTypes)
        {
            if(Interaction == InteractionType.InteractionType)
            {
                InteractionType.bAvailable = bValue;
                return true;
            }
        }
        return false;
    }
    bool SetInteractionHold(const EInteractionType Interaction, const bool bValue)
    {
        for(auto& InteractionType : InteractionTypes)
        {
            if(Interaction == InteractionType.InteractionType)
            {
                InteractionType.bHold = bValue;
                return true;
            }
        }
        return false;
    }
 
    TArray<FInteractionType> GetVisibleInteractions() const
    {
        TArray<FInteractionType> VisibleInteractions;
        for(const auto& Interaction : InteractionTypes)
        {
            if(Interaction.bHide == false)
            {
                VisibleInteractions.Add(Interaction);
            }
        }
        return VisibleInteractions;
    }
 
 
    void SetDefault(const EInteractionType Default, const bool bRemoveOthers = true)
    {
        if(bRemoveOthers)
        {
            InteractionTypes.Empty();
        }
        DefaultInteraction = InteractionTypes.Add(FInteractionType(Default));
        if(Default == EInteractionType::None)
        {
            DefaultInteraction = -1;
        }
    }
 
    static FInteractionData None()
    {
        FInteractionData None;
        None.SetDefault(EInteractionType::None);
        None.bShowDefault = true;
        return None;
    }
 
    bool operator==(const FInteractionData& Other) const
    {
        bool bEqual = true;
        if(InteractionTypes != Other.InteractionTypes)
        {
            bEqual = false;
        }
        if(DefaultInteraction != Other.DefaultInteraction)
        {
            bEqual = false;
        }
        if(bShowDefault != Other.bShowDefault)
        {
            bEqual = false;
        }
        return bEqual;
    }
};
 
//@TODO Check all this, remove any extras
USTRUCT(BlueprintType)
struct FPlayerDeath
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    FString Attacker = "Attacker";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    FString Victim = "Victim";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    AActor* AttackerActor = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    AActor* VictimActor = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    class APlayerState* AttackerPlayerState = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    class APlayerState* VictimPlayerState = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    int32 AttackerTeamID = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    int32 VictimTeamID = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    EDeathType CauseOfDeath = EDeathType::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    FString WeaponID = "Weapon";
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    bool bAIAttacker = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    bool bAIVictim = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    bool bSelfDeath = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    bool bTeamKill = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Player Death")
    bool bStealthKill = false;
};
 
 
// USTRUCT(BlueprintType)
// struct FBaseActorInfo
// {
//  GENERATED_BODY()
//
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Base Actor")
//  FTransform ActorTransform = FTransform(FVector::ZeroVector);
//
//  // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Base Actor")
//  // bool b
// };
 
 
 
USTRUCT(BlueprintType)
struct FInputIcon : public FTableRowBase
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FString Name;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FSlateBrush Icon;
};
 
 
USTRUCT(BlueprintType)
struct FCharacterKarma
{
    GENERATED_BODY()
 
    // The overall Karma level (positive = good, negative = bad)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    float Level = 0.0f;
    // // Time-stamped log of key karma-related actions (optional)
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // TArray<FString> KarmaHistory;
    // // Weighted breakdown of karma by category
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // TMap<FName, float> KarmaByCategory;
    // // Whether this character is known for high or low karma
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // bool bIsKarmaKnown = false;
    // // Flags for unique moral decisions that affect storylines
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // TSet<FName> MoralDecisions;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // TMap<FName, float> KarmaByFaction;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Karma")
    // TMap<FName, float> KarmaByRegion;
};
 
static int32 MAX_SKILL_LEVEL = 10;
static int32 XP_PER_LEVEL = 1000;
static int32 MIN_SKILL_LEVEL = 1;
 
USTRUCT(BlueprintType)
struct FCharacterSkill
{
    GENERATED_BODY()
 
    
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Character Traits")
    // FString Name = "Strength";
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Character Traits")
    FGameplayTag Name = SkillTags::Strength;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    int32 Level = 1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    float XP = 0.0f;
    
    FCharacterSkill()
    {
        
    }
    explicit FCharacterSkill(const FGameplayTag SkillName)
    {
        Name = SkillName;
    }
    explicit FCharacterSkill(const FGameplayTag SkillName, const int32 StartingLevel)
    {
        Name = SkillName;
        Level = StartingLevel;
        XP = StartingLevel * XP_PER_LEVEL;
    }
    //@ todo Depricate don't need XP, characters choose levels
    bool AddXP(const float Value)
    {
        const int32 LevelBefore = XP / XP_PER_LEVEL; // Level before adding XP
        XP += Value;
        // Level = XP / 1000;
        //- Level after adding XP
        Level = FMath::Min(static_cast<int32>(XP / XP_PER_LEVEL), MAX_SKILL_LEVEL); // Ensure Level does not exceed MaxLevel
        return Level > LevelBefore;
    }
    //@TODO Check it doesn't go below 0
    // Returns if changed
    bool AddLevel(const bool bIncrease)
    {
        int32 PrevLevel = Level;
        if(bIncrease)
        {
            Level++;
        }
        else
        {
            Level--;
        }
        Level = FMath::Min(FMath::Max(MIN_SKILL_LEVEL, Level), MAX_SKILL_LEVEL); // Ensure Level does not exceed MaxLevel
        return Level != PrevLevel;
    }
};
 
USTRUCT(BlueprintType)
struct FSkill
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="General")
    FString Name = "Health";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    float Value = 0.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    float Value2 = 0.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FText ValueFormat = FText::FromString("{0}/{1}");
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bEditable = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    UTexture2D* Icon = nullptr;
    
    explicit FSkill(const FCharacterSkill& CharacterSkill)
    {
        FString LastTagPart = "";
        CharacterSkill.Name.GetTagName().ToString().Split(TEXT("."), nullptr, &LastTagPart, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
        Name =  LastTagPart;
        Value = CharacterSkill.Level;
        Value2 = CharacterSkill.XP;
        ValueFormat = FText::FromString("{0}");
        bEditable = true;
    }
    FSkill()
    {
        
    }
};
 
 
USTRUCT(BlueprintType)
struct FCharacterBaseSkills
{
    GENERATED_BODY()
 
    //- Melee Damage, How Easily Pushed Over    //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Strength = FCharacterSkill(SkillTags::Strength, 1);
    int32 GetStrength() const {return Strength.Level;};
    bool AddStrengthXP(const float Value) {return Strength.AddXP(Value);};
    
    //- How quickly spotting Enemies    //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Perception = FCharacterSkill(SkillTags::Perception, 1);
    int32 GetPerception() const {return Perception.Level;};
    bool AddPerceptionXP(const float Value) {return Perception.AddXP(Value);};
    
    //- Health Points, hp of body parts, 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Endurance = FCharacterSkill(SkillTags::Endurance, 1);
    int32 GetEndurance() const {return Endurance.Level;};
    bool AddEnduranceXP(const float Value) {return Endurance.AddXP(Value);};
    
    //- Companion Health,  
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Charisma = FCharacterSkill(SkillTags::Charisma, 1);
    int32 GetCharisma() const {return Charisma.Level;};
    bool AddCharismaXP(const float Value) {return Charisma.AddXP(Value);};
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Intelligence = FCharacterSkill(SkillTags::Intelligence, 1);
    int32 GetIntelligence() const {return Intelligence.Level;};
    bool AddIntelligenceXP(const float Value) {return Intelligence.AddXP(Value);};
    
    //- Stamina bar, 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Agility = FCharacterSkill(SkillTags::Agility, 1);
    int32 GetAgility() const {return Agility.Level;};
    bool AddAgilityXP(const float Value) {return Agility.AddXP(Value);};
    
    //- Accuracy + 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill WeaponSkill = FCharacterSkill(SkillTags::WeaponSkill, 1);
    int32 GetWeaponSkill() const {return WeaponSkill.Level;};
    bool AddWeaponSkillXP(const float Value) {return WeaponSkill.AddXP(Value);};
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Stealth = FCharacterSkill(SkillTags::Stealth, 1);
    int32 GetStealth() const {return Stealth.Level;};
    bool AddStealthXP(const float Value) {return Stealth.AddXP(Value);};
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Character Traits")
    FCharacterSkill Luck = FCharacterSkill(SkillTags::Luck, 1);
    int32 GetLuck() const {return Luck.Level;};
    bool AddLuckXP(const float Value) {return Luck.AddXP(Value);};
 
    int32 GetSkillPoints() const {return SkillPoints;};
 
 
    //~~            ~~//
    void AddSkillXP(const FGameplayTag& Name, const int32 Value)
    {
        for(const auto& Skill : GetAllSkillsRef())
        {
            if(Skill == nullptr){continue;}
            if(Skill->Name == Name)
            {
                Skill->AddXP(Value);
            }
        }
    }
    void AddSkillLevel(const FGameplayTag& Name, const bool bIncrease)
    {
        for(const auto& Skill : GetAllSkillsRef())
        {
            if(Skill == nullptr){continue;}
            if(Skill->Name == Name)
            {
                Skill->AddLevel(bIncrease);
            }
        }
    }
    void AddSkillLevelByName(const FString& Name, const bool bIncrease)
    {
        FCharacterSkill* Skill = GetSkillByName(Name);
        if(Skill == nullptr){UE_LOG(LogBaseHelpers, Warning, TEXT("FCharacterBaseSkills::AddSkillLevelByName Skill: %s Not found.."), *Name);return;}
        // Get All Skill Points,
        // Check we Have enough to Add.
        // If Not, Return
        // If true Add Level
        // Mofify SkillPoints.
        if(bIncrease && GetSkillPoints() <= 0)
        {
            return;
        }
        const bool bChangedLevel = Skill->AddLevel(bIncrease);
        if(bChangedLevel == false){return;}
        if(bIncrease)
        {
            SkillPoints--;
        }
        else
        {
            SkillPoints++;
        }
    }
 
    FCharacterSkill* GetSkillByName(const FString& Name)
    {
        for(const auto& Skill : GetAllSkillsRef())
        {
            FString LastTagPart = "";
            Skill->Name.GetTagName().ToString().Split(TEXT("."), nullptr, &LastTagPart, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
            if(Name == LastTagPart)
            {
                return Skill;
            }
        }
        return nullptr;
    }
    FCharacterSkill* GetSkillByTag(const FGameplayTag& Name)
    {
        for(const auto& Skill : GetAllSkillsRef())
        {
            if(Skill == nullptr){continue;}
            if(Skill->Name == Name)
            {
                return Skill;
            }
        }
        return nullptr;
    }
 
    
    //~~    Helpers     ~~//
    
    TArray<FCharacterSkill> GetAllSkills() const
    {
        TArray<FCharacterSkill> Skills;
        Skills.Add(Strength);
        Skills.Add(Perception);
        Skills.Add(Endurance);
        Skills.Add(Charisma);
        Skills.Add(Intelligence);
        Skills.Add(Agility);
        Skills.Add(WeaponSkill);
        Skills.Add(Stealth);
        Skills.Add(Luck);
        return Skills;
    }
    TArray<FCharacterSkill*> GetAllSkillsRef()
    {
        TArray<FCharacterSkill*> Skills;
        Skills.Add(&Strength);
        Skills.Add(&Perception);
        Skills.Add(&Endurance);
        Skills.Add(&Charisma);
        Skills.Add(&Intelligence);
        Skills.Add(&Agility);
        Skills.Add(&WeaponSkill);
        Skills.Add(&Stealth);
        Skills.Add(&Luck);
        return Skills;
    }
 
    int32 GetNumberOfSkills() const
    {
        return GetAllSkills().Num();
    }
 
    
    FCharacterBaseSkills()
    {
        
    }
 
    
protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Character Traits")
    int32 SkillPoints = 10;
 
};
 
 
 
 
// UENUM(BlueprintType)
// enum class EGamepadButton : uint8
// {
//  GamepadFaceButtonBottom,
//  
//  
// };
 
// UENUM(BlueprintType)
// enum class EKeyboardMouseButton : uint8
// {
//  LeftMouseButton,
//  
//  
// };
 
// USTRUCT(BlueprintType)
// struct FCharacterComponentRequirements
// {
//  GENERATED_BODY()
//  
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bController = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bPlayerController = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bAIController = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bSkeletalMesh = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bAnimationInstance = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bPawn = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bHUDReference = false;
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
//  bool bShouldDestroyOnDeath = false;
// };
 
 
UENUM(Blueprintable, BlueprintType)
enum class EUnlockableCategory : uint8
{
    Default,
    Achievement,
    Challenge,
    Level,
    Seasonal,
};
 
UENUM(BlueprintType)
enum class EDifficultyLevel : uint8
{
    Assisted,
    Easy,
    Normal,
    Hard,
    Expert,
    Master
};
 
 
 
UENUM(Blueprintable, BlueprintType, meta = (ScriptName = "EMatchStatePython"))
enum class EMatchState : uint8
{
    Default,
    Lobby,
    WaitingToStart,
    PreMatch,
    InProgress,
    PostMatch,
    Finished
};
 
USTRUCT(BlueprintType)
struct FMatchState
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    EMatchState MatchState = EMatchState::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    bool bMatchTimed = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    int32 TimeRemaining = 0;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    EMatchState RoundState = EMatchState::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    int32 Round = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    bool bRoundTimed = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Match State")
    int32 RoundTimeRemaining = 0;
 
 
    static FMatchState Empty()
    {
        const FMatchState EmptyMatchState;
        return EmptyMatchState;
    }
 
};
 
USTRUCT(BlueprintType)
struct FUnlockItemMethod : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    bool bRequiresUnlock = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    int32 RequiredLevel = -1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    int32 RequiredAchievementID = -1;
    //-     Mod / Beta Tester / Special Player  //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    int32 RequiredPlayerStatusID = -1;
    
};
 
 
USTRUCT(BlueprintType)
struct FProfilePicture : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    class UTexture2D* Image = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    bool bHasTooltip = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    int32 ID = 1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    FString Name = "Default";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    EUnlockableCategory Category = EUnlockableCategory::Default;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Profile Picture")
    FString Description = "Default Description";
    
};
 
 
USTRUCT(BlueprintType)
struct FAchievement : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    int32 ID = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    FString Name = "Default";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    FString Description = "Default Description";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    class UTexture2D* Image = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    TArray<bool> Requirements;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    int32 Score = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    bool bHidden = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    bool bUnlocked = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    float Progress = 0.0f;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Achievements")
    // Reward;
    
    // Implementing the '==' operator for the struct
    bool operator==(const FAchievement& Other) const
    {
        return ID == Other.ID;
    }
};
 
//- Stats for the current multiplayer game  //
USTRUCT(BlueprintType)
struct FMultiplayerPlayerStats : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    FString DisplayName = "Name";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 Kills = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 TeamKills = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 SelfKills = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 Deaths = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 Assists = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    int32 Headshots = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Mutliplayer")
    float XP = 0;
 
    // TArray<FPlayerDeath> Deaths
    bool IsValid() const
    {
        if(DisplayName == "Name"){return false;}
        return true;
    }
    FMultiplayerPlayerStats AddKill()
    {
        Kills++;
        return *this;
    }
    FMultiplayerPlayerStats AddTeamKill()
    {
        TeamKills++;
        return *this;
    }
    FMultiplayerPlayerStats AddSelfKill()
    {
        SelfKills++;
        return *this;
    }
 
    FMultiplayerPlayerStats AddDeath()
    {
        Deaths++;
        return *this;
    }
    FMultiplayerPlayerStats AddXP(const float Amount)
    {
        XP = FMath::Max(0.0f, XP + Amount);
        return *this;
    }
};
 
 
 
USTRUCT(BlueprintType)
struct FUserProfile : public FTableRowBase
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    FString DisplayName = "Name";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    FString Nickname = "Name";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    FString ID = "12";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 ProfilePictureID = 1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    TArray<int32> Achievements;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 XP = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 QuestsCompleted = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    float TotalPlayTime = 0.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 MatchesWon = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 MatchesPlayed = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 Kills = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 Deaths = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 Assists = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 Headshots = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    float HighestGameScore = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 ChallengesCompleted = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    int32 Collectables = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    FString TopWeapon = "Weapon";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    FString TopCharacter = "Character";
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="User Profile")
    bool bReady = false;
 
 
    //@TODO Create Formula for XP Curve
    int32 XPToLevelUp = 1000;//(999 * ((XP + 1) / 100));
 
    bool IsValid() const
    {
        if(DisplayName == "Name"){return false;}
        return true;
    }
    FUserProfile AddKill()
    {
        Kills++;
        return *this;
    }
    FUserProfile AddDeath()
    {
        Deaths++;
        return *this;
    }
    float XPProgress() const
    {
        return static_cast<float>(XP % XPToLevelUp) / static_cast<float>(XPToLevelUp);
    }
    FUserProfile AddXP(const int32 Value) 
    {
        XP += Value;
        return *this;
    }
 
    int32 GetPlayerLevel() const
    {
        return (XP / XPToLevelUp);
    }
 
 
 
    // Implementing the '==' operator for the struct
    bool operator==(const FUserProfile& Other) const
    {
        if(DisplayName == Other.DisplayName)
        {
            return true;
        }
        // if(ID == Other.ID &&
        //  DisplayName == Other.DisplayName)
        // {
        //  Result = true;
        // }
        return false;
    }
};