QuestData.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 "GameplayTagContainer.h"
#include "Data/BaseData.h"
#include "Engine/DataTable.h"
#include "UObject/UnrealType.h"
#include "QuestData.generated.h"
 
 
struct FGameplayTag;
DECLARE_LOG_CATEGORY_CLASS(LogQuestSystem, Display, All);
 
DECLARE_STATS_GROUP(TEXT("Quest System Stat Group"), STATGROUP_Quests, STATCAT_Advanced)
DECLARE_CYCLE_STAT(TEXT("Player Component"), STATGROUP_Quests_PlayerComponent, STATGROUP_Quests);
DECLARE_CYCLE_STAT(TEXT("BPLib"), STATGROUP_Quests_BPLib, STATGROUP_Quests);
DECLARE_CYCLE_STAT(TEXT("Game Component"), STATGROUP_Quests_GameComponent, STATGROUP_Quests);
DECLARE_CYCLE_STAT(TEXT("All Widgets"), STATGROUP_Quests_Widgets, STATGROUP_Quests);
DECLARE_CYCLE_STAT(TEXT("Goal Component"), STATGROUP_Quests_GoalComponents, STATGROUP_Quests);
 
 
 
 
UENUM(Blueprintable, BlueprintType, meta = (ScriptName = "EFilterQuestTypePython"))
enum class EFilterQuestType : uint8
{
    All UMETA(DisplayName = "All"),
    Main UMETA(DisplayName = "Main"),
    Side UMETA(DisplayName = "Side"),
    HumanQuest UMETA(DisplayName = "Human"),
    AlienQuest UMETA(DisplayName = "Alien"),
    RaiderQuest UMETA(DisplayName = "Raider"),
    RobotQuest UMETA(DisplayName = "Robot"),
    ZombieQuest UMETA(DisplayName = "Zombie"),
    Completed UMETA(DisplayName = "Completed"),
    Failed UMETA(DisplayName = "Failed"),
    Abandoned UMETA(DisplayName = "Abandoned"),
    Single UMETA(DisplayName = "Single"),
    Multiple UMETA(DisplayName = "Multiple")
};
 
//  Quest Faction: Robots
//  Quest Category: Main
//  Quest Status: Current
 
 
UENUM(Blueprintable, BlueprintType, meta = (ScriptName = "EQuestLocationPython"))
enum class EQuestLocation : uint8
{
    PlayerShip,
};
 
UENUM(Blueprintable, BlueprintType, meta = (ScriptName = "EQuestOutcomePython"))
enum class EQuestStatus : uint8
{
    NotStarted  UMETA(DisplayName = "Not Started"),
    Active      UMETA(DisplayName = "Active"),
    Completed   UMETA(DisplayName = "Completed"),
    Failed      UMETA(DisplayName = "Failed"),
    Abandoned   UMETA(DisplayName = "Abandoned"),
    NotAvailable UMETA(DisplayName = "Not Available") // When quest goes down an alternative path
};
 
 
// USTRUCT(BlueprintType)
// struct FQuestID
// {
//  GENERATED_BODY()
//  
//  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
//  FString ID = "ID";
//
//  void SetUniqueNumber(const int32 NewID)
//  {
//      UniqueID = NewID;
//  }
//  int32 GetUniqueNumber() const
//  {
//      return UniqueID;
//  }
//
//
//  FQuestID()
//  {
//      
//  }
//  explicit FQuestID(const FString& NewID)
//  {
//      ID = NewID;
//  };
//  explicit FQuestID(const FString& NewID, const int32 NewUniqueID)
//  {
//      ID = NewID;
//      UniqueID = NewUniqueID;
//  };
//
//  bool IsValid() const
//  {
//      bool bValid = false;
//      if(ID != "ID"){bValid = true;};
//      return bValid;
//  }
//  bool operator==(const FQuestID& Other) const
//  {
//      return (ID == Other.ID) && (UniqueID == Other.UniqueID);
//  }
//  bool operator!=(const FQuestID& Other) const
//  {
//      return (ID != Other.ID) || (ID == Other.ID && UniqueID != Other.UniqueID);
//  }
// protected:
//  UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="General")
//  int32 UniqueID = 0;
//
// };
 
USTRUCT(BlueprintType)
struct FQuestGoal
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    FString ObjectiveID = "Default";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    int32 ObjectiveAmount = 0;
 
    //- Maybe?  //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System")
    bool bHasWorldMarker = false;
 
};
 
 
 
USTRUCT(BlueprintType)
struct FQuestItemData
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    FString QuestItemID = "Default";
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    // FString QuestItemID = "Default";
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    FString ObjectiveID = {""};
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    int32 ObjectiveAmount = 0;
    
    //@TODO For multiple Objectives
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System|Goal")
    // TArray<FString> ObjectiveIDs = {""};
 
    //? Maybe Have TMAP for ObjectiveID and Objective Amount 
 
    //- Maybe?  //
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Quest System")
    // bool bHasWorldMarker = false;
 
};
 
USTRUCT(BlueprintType)
struct FQuestReward
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Reward")
    int32 Experience = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Reward")
    int32 Credits = 0;
    //@ TODO reward Items 
    // UPROPERTY(BlueprintReadWrite, Category="Quest System")
    // TMap<FString, int32> Items;
    
    FQuestReward()
    {
        
    }
};
 
USTRUCT(BlueprintType)
struct FQuestObjectivesStatus
{
    GENERATED_BODY()
    
    // Returns the elapsed time after updating it
    float GetElapsedTime() const
    {
        return ElapsedTime;
    }
    float GetStartTime() const
    {
        return StartTimeInSeconds;
    }
 
    void StartObjective(const UObject* Owner)
    {
        if(GetIsStarted() == false)
        {
            Status = EQuestStatus::Active;
            // bInProgress = true; 
            if(const UWorld* World = GEngine->GetWorldFromContextObject(Owner, EGetWorldErrorMode::LogAndReturnNull))
            {
                StartTimeInSeconds = World->GetTimeSeconds();
            }
        }
        // 
        else
        {
            
        }
    }
    void SetObjectiveNotYetStarted()
    {
        Status = EQuestStatus::NotStarted;
    }
    float SaveObjectiveTime(const UObject* Owner)
    {
        if(Status != EQuestStatus::Active){return ElapsedTime;}
        if(const UWorld* World = GEngine->GetWorldFromContextObject(Owner, EGetWorldErrorMode::LogAndReturnNull))
        {
            const float CurrentTimeInSeconds = World->GetTimeSeconds();
            ElapsedTime = CurrentTimeInSeconds - StartTimeInSeconds;
        }
        return ElapsedTime;
    }
    void ResumeFromElapsedTime()
    {
        if(Status != EQuestStatus::Active){return;}
        StartTimeInSeconds = -ElapsedTime;
    }
    bool GetIsFailed(const int32 RequiredFailProgress) const
    {
        if(FailProgress >= RequiredFailProgress)
        {
            return true;
        }
        return Status == EQuestStatus::Failed;
    }
    bool GetDidCompleteInTime(const bool bObjectiveTimed = false, const float TimeToComplete = 0.0f) const 
    {
        //- Sets ElapsedTime    //
        if(bObjectiveTimed && StartTimeInSeconds >= 0.0f)
        {
            return ElapsedTime <= TimeToComplete;
        }
        return true;
    }
    bool IsFinished(const int32 RequiredFailProgress, const int32 RequiredProgress) const 
    {
        return (FailProgress >= RequiredFailProgress) || (CurrentProgress >= RequiredProgress);
    }
    bool IsSuccessful(const int32 RequiredFailProgress, const int32 RequiredProgress) const 
    {
        return (CurrentProgress >= RequiredProgress) && (FailProgress < RequiredFailProgress);
    }
    //- Will Return if Progress is At Required, Finished or Failed  
    bool Complete(const int32 RequiredFailProgress, const int32 RequiredProgress) const 
    {
        if(FailProgress >= RequiredFailProgress)
        {
            return true;
        }
        return CurrentProgress >= RequiredProgress;
    }
 
    EQuestStatus GetStatus() const 
    {
        return Status;
    }
    bool IsActive() const 
    {
        return (Status == EQuestStatus::Active);
    }
    bool GetIsStarted() const
    {
        return (Status != EQuestStatus::NotAvailable && Status != EQuestStatus::NotStarted);
    }
    bool GetIsNotYetStarted() const
    {
        return Status == EQuestStatus::NotStarted;
    }
 
    bool AddProgress(const int32 Amount, const int32 RequiredProgress)  
    {
        CurrentProgress += Amount;
        if(CurrentProgress >= RequiredProgress)
        {
            CurrentProgress = RequiredProgress;
            if(Status == EQuestStatus::Active)
            {
                Status = EQuestStatus::Completed;
                return true;
            }
        }
        return false;
    }
    bool AddFailProgress(const int32 Amount, const int32 RequiredFailProgress)  
    {
        FailProgress += Amount;
        if(FailProgress >= RequiredFailProgress)
        {
            FailProgress = RequiredFailProgress;
            if(Status == EQuestStatus::Active)
            {
                Status = EQuestStatus::Failed;
                return true;
            }
        }
        return false;
    }
    int32 GetCurrentProgress() const
    {
        return CurrentProgress;
    }
    int32 GetFailProgress() const
    {
        return FailProgress;
    }
    void SetUniqueID(const int32 NewUID)
    {
        UniqueID = NewUID;
    }
    int32 GetUniqueID() const
    {
        return UniqueID;
    }
 
 
protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    EQuestStatus Status = EQuestStatus::NotStarted;
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="ID")
    int32 UniqueID = -1;
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Timed")
    float StartTimeInSeconds = -1.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Timed")
    float ElapsedTime = -1.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Progress")
    int32 FailProgress = 0;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Progress")
    int32 CurrentProgress = 0;
};
 
 
 
 
USTRUCT(BlueprintType)
struct FQuestObjectives : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString ObjectiveID = "Default Quest Objective";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString ObjectiveDescription = "Default Description";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    TArray<FString> ObjectiveHints = {"Objective","Hint"};
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bHasWorldMarker = false;
    //@TODO World Markers per Objecive, or have on like Quest Goal
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    // TArray<AActor*> WorldMarkers;
    //@TODO World marker after certain progress
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Status")
    bool bIsOptional = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    int32 RequiredFailProgress = 100;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    int32 RequiredProgress = 100;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    bool bShowProgress = true;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    bool bShowFailProgress = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    bool bDynamicProgress = false;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress")
    bool bIsUnlockedAtCertainProgress = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Progress", meta=(EditCondition=bIsUnlockedAtCertainProgress))
    int32 UnlockProgressNeeded = 15;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Timed")
    bool bObjectiveTimed = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Timed", meta=(EditCondition=bObjectiveTimed))
    float TimeToComplete = 10.0f;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Reward")
    FQuestReward RewardBonus;
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    FQuestObjectivesStatus ObjectiveStatus;
    
    //@ TODO Add Branch to complete, finished etc.
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    bool bBranchObjective = false;
    
    FQuestObjectives()
    {
    
    }
    bool AddProgress(const int32 Amount)  
    {
        return ObjectiveStatus.AddProgress(Amount, RequiredProgress);
    }
    bool AddFailProgress(const int32 Amount)  
    {
        return ObjectiveStatus.AddFailProgress(Amount, RequiredFailProgress);
    }
    void StartObjective(const UObject* Owner)
    {
        if(bIsUnlockedAtCertainProgress && CanStart(GetCurrentProgress()) == false)
        {
            ObjectiveStatus.SetObjectiveNotYetStarted();
            return;
        }
        ObjectiveStatus.StartObjective(Owner);
    }
    void StartObjective(const UObject* Owner, const int32 QuestProgress)
    {
        if(bIsUnlockedAtCertainProgress && CanStart(QuestProgress) == false)
        {
            ObjectiveStatus.SetObjectiveNotYetStarted();
            return;
        }
        ObjectiveStatus.StartObjective(Owner);
    }
    void ResumeFromElapsedTime()
    {
        ObjectiveStatus.ResumeFromElapsedTime();
    }
    float SaveObjectiveTime(const UObject* Owner)
    {
        return ObjectiveStatus.SaveObjectiveTime(Owner);
    }
 
    void SetUniqueID(const int32 ID)
    {
        ObjectiveStatus.SetUniqueID(ID);
    }
 
 
 
    //~     Getters         ~//
    
    FUniqueID GetUniqueID() const
    {
        FUniqueID ID = FUniqueID(ObjectiveID);
        ID.SetUniqueNumber(ObjectiveStatus.GetUniqueID());
        return ID;
    }
 
    
    // Returns the elapsed time after updating it
    float GetElapsedTime() const
    {
        return ObjectiveStatus.GetElapsedTime();
    }
    float GetStartTime() const
    {
        return ObjectiveStatus.GetStartTime();
    }
    bool GetDidCompleteInTime() const 
    {
        return ObjectiveStatus.GetDidCompleteInTime(bObjectiveTimed, TimeToComplete);
    }
    int32 GetCurrentProgress() const
    {
        return ObjectiveStatus.GetCurrentProgress();
    }
    int32 GetFailProgress() const
    {
        return ObjectiveStatus.GetFailProgress();
    }
    float GetCurrentProgressPercent() const
    {
        return static_cast<float>(GetCurrentProgress()) / static_cast<float>(RequiredProgress);
    }
    float GetFailProgressPercent() const
    {
        return static_cast<float>(GetFailProgress()) / static_cast<float>(RequiredFailProgress);
    }
 
    bool CanStart(const int32 TotalProgress) const 
    {
        if(bIsUnlockedAtCertainProgress)
        {
            return TotalProgress >= UnlockProgressNeeded;
        }
        return true;
    }
    bool GetIsFailed() const
    {
        return ObjectiveStatus.GetIsFailed(RequiredFailProgress);
    }
    bool GetIsActive() const 
    {
        return ObjectiveStatus.IsActive();
    }
    bool GetIsStarted() const 
    {
        return ObjectiveStatus.GetIsStarted();
    }
    bool GetIsNotYetStarted() const
    {
        return ObjectiveStatus.GetIsNotYetStarted();
    }
 
    bool GetIsFinished() const 
    {
        return ObjectiveStatus.IsFinished(RequiredFailProgress, RequiredProgress);
    }
    bool GetIsSuccessful() const 
    {
        return ObjectiveStatus.IsSuccessful(RequiredFailProgress, RequiredProgress);
    }
    //- Will Return if Progress is At Required, Finished or Failed  
    bool GetIsComplete() const 
    {
        return ObjectiveStatus.Complete(RequiredFailProgress, RequiredProgress);
    }
    EQuestStatus GetStatus() const
    {
        return ObjectiveStatus.GetStatus();
    }
    
    bool operator==(const FQuestObjectives& Other) const
    {
        return (ObjectiveID == Other.ObjectiveID) && (GetUniqueID() == Other.GetUniqueID());
    }
    bool operator!=(const FQuestObjectives& Other) const
    {
        return (ObjectiveID != Other.ObjectiveID) || ((ObjectiveID == Other.ObjectiveID) && (GetUniqueID() != Other.GetUniqueID()));
    }
    //@ TODO Does the objective need to be marked unique? 
    bool operator==(const FUniqueID& OtherID) const
    {
        return (GetUniqueID() == OtherID);
        // if(bUnique){return (GetUniqueID() == OtherID);}
        // return (ObjectiveID == OtherID.ID);
    }
    bool operator!=(const FUniqueID& OtherID) const
    {
        return (GetUniqueID() != OtherID);
        // if(bUnique){return (GetUniqueID() != OtherID);}
        // return (ObjectiveID != OtherID.ID);
    }
 
    // bool operator==(const FString& OtherID, const int32 OtherUniqueID) const
    // {
    //  return ObjectiveID == OtherID && (UniqueID == OtherUniqueID);
    // }
    // bool operator!=(const FString& OtherID, const int32 OtherUniqueID) const
    // {
    //  return ObjectiveID != OtherID && (UniqueID == OtherUniqueID);
    // }
};
 
 
 
USTRUCT(BlueprintType)
struct FQuestInfoStatus
{
    GENERATED_BODY()
 
    void StartQuest(const UObject* Owner)
    {
        if(GetQuestStatus() == EQuestStatus::Active){return;}
        SetStatus(EQuestStatus::Active);
        if(const UWorld* World = GEngine->GetWorldFromContextObject(Owner, EGetWorldErrorMode::LogAndReturnNull))
        {
            StartTimeInSeconds = World->GetTimeSeconds();
        }
    }
    void SetStatus(const EQuestStatus NewQuestStatus)
    {
        QuestStatus = NewQuestStatus;
    }
    bool GetIsActive() const
    {
        return QuestStatus == EQuestStatus::Active;
    }
    EQuestStatus GetQuestStatus() const
    {
        return QuestStatus;
    }
    TArray<FString> GetAllObjectiveIDs() const
    {
        TArray<FString> AllObjectiveIDs;
        for(const auto& Objective: ObjectiveReferences)
        {
            if(Objective == nullptr){continue;}
            AllObjectiveIDs.AddUnique(Objective->ObjectiveID);
        }
        return AllObjectiveIDs;
    }
    int32 GetObjectivesNum() const
    {
        return ObjectiveReferences.Num();
    }
    int32 GetTotalProgress() const
    {
        int32 TotalProgress = 0;
        for(const auto& Objective : ObjectiveReferences)
        {
            if(Objective == nullptr){continue;}
            if(!Objective->bIsOptional)
            {
                TotalProgress += Objective->GetCurrentProgress();
            }
        }
        return TotalProgress;
    }
    
    int32 GetTotalRequiredProgress() const
    {
        int32 TotalRequired = 0;
        for(const auto& Objective : ObjectiveReferences)
        {
            if(Objective == nullptr){continue;}
            if(!Objective->bIsOptional)
            {
                TotalRequired += Objective->RequiredProgress;
            }
        }
        return TotalRequired;
    }
    float SaveQuestTime(const UObject* Owner)
    {
        if(GetIsActive())
        {
            if(const UWorld* World = GEngine->GetWorldFromContextObject(Owner, EGetWorldErrorMode::LogAndReturnNull))
            {
                const float CurrentTimeInSeconds = World->GetTimeSeconds();
                ElapsedTime = CurrentTimeInSeconds - StartTimeInSeconds;
            }
        }
        return ElapsedTime;
    }
    void ResumeFromElapsedTime()
    {
        if(QuestStatus != EQuestStatus::Active){return;}
        StartTimeInSeconds = -ElapsedTime;
    }
    bool GetDidCompleteInTime(const float TimeToComplete) const 
    {
        //- Sets ElapsedTime    //
        if(StartTimeInSeconds >= 0.0f)
        {
            return ElapsedTime <= TimeToComplete;
        }
        return false;
    }
    //@ TODO Check over this logic
    bool GetCanBeCompleted(const UObject* Owner, EQuestStatus& QuestOutcome)
    {
        //- Sets Elapsed Time   //
        SaveQuestTime(Owner);
        QuestOutcome = QuestStatus;
        if(QuestOutcome != EQuestStatus::Active){return false;}
        //@ TODO add this function to Player Quest Status, which can check Objectives too 
        for(const FQuestObjectives* QuestObjective : ObjectiveReferences)
        {
            //- Don't Check Optional Objectives //
            if(QuestObjective->bIsOptional){continue;}
            if(QuestObjective->GetIsFailed())
            {
                QuestOutcome = EQuestStatus::Failed;
                return true;
            }
            if(QuestObjective->bObjectiveTimed && !QuestObjective->GetDidCompleteInTime())
            {
                QuestOutcome = EQuestStatus::Failed;
                return true;
            }
            //- If any of the non optional Objectives aren't complete   //
            if(QuestObjective->GetIsFinished() == false)
            {
                QuestOutcome = EQuestStatus::Active;
                return false;
            }
        }
        //- All Objectives Complete //
        QuestOutcome = EQuestStatus::Completed;
        return true;
    }
    float GetElapsedTime() const
    {
        return ElapsedTime;
    }
    float GetStartTime() const
    {
        return StartTimeInSeconds;
    }
    int32 GetUniqueID() const
    {
        return UniqueID;
    }
    void SetUniqueID(const int32 ID)
    {
        UniqueID = ID;
    }
 
 
    TArray<FString> GetActiveObjectiveIDs() const
    {
        TArray<FString> ActiveObjectiveIDs;
        for(const auto& Objective : ObjectiveReferences)
        {
            if(Objective != nullptr)
            {
                if(Objective->GetIsActive())
                {
                    ActiveObjectiveIDs.Add(Objective->ObjectiveID);
                }
            }
        }
        return ActiveObjectiveIDs;
    }
    TArray<FString> GetNotStartedObjectiveIDs() const
    {
        TArray<FString> NotStartedObjectiveIDs;
        for(const auto& Objective : ObjectiveReferences)
        {
            if(Objective != nullptr)
            {
                if(Objective->GetIsNotYetStarted())
                {
                    NotStartedObjectiveIDs.Add(Objective->ObjectiveID);
                }
            }
        }
        return NotStartedObjectiveIDs;
    }
 
    TArray<FString> GetActiveObjectiveIDsWithMarkers() const
    {
        TArray<FString> ActiveObjectiveIDs;
        for(const auto& Objective : ObjectiveReferences)
        {
            if(Objective != nullptr)
            {
                if(Objective->GetIsActive())
                {
                    if(Objective->bHasWorldMarker)
                    {
                        ActiveObjectiveIDs.Add(Objective->ObjectiveID);
                    }
                }
            }
        }
        return ActiveObjectiveIDs;
    }
    
    TArray<const FQuestObjectives*> ObjectiveReferences;
 
protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    EQuestStatus QuestStatus = EQuestStatus::NotStarted;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    int32 UniqueID = 0;
 
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Timed")
    float StartTimeInSeconds = -1.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Timed")
    float ElapsedTime = -1.0f;
 
    // bool b
 
};
 
 
USTRUCT(BlueprintType)
struct FQuestInfo : public FTableRowBase
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString QuestID = "QID_01";
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString QuestName = "Quest Name";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FString Description = "Quest Description";
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    TArray<FString> ObjectiveIDs = {"QOID_01", "QOID_02"};
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Status")
    bool bUniqueObjectives = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bShowOverallProgress = false;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    FQuestReward Reward = FQuestReward();
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Requirements")
    TArray<FString> RequiredQuests;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    TArray<FString> QuestsToBeAddedAfterCompletion;
    //- Abandoned == Can be retried //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="State")
    bool bCanQuestBeAbandoned = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="State")
    bool bCanQuestFail = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="State")
    bool bCanRetry = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="State")
    bool bRepeatable = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Status")
    FQuestInfoStatus Status;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Timed")
    bool bQuestTimed = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Timed", meta=(EditCondition=bQuestTimed))
    float TimeToComplete = 10.0f;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Category")
    FGameplayTag CategoryTag;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Category")
    EFilterQuestType Category = EFilterQuestType::Main;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Category")
    EQuestLocation Location = EQuestLocation::PlayerShip;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Category")
    FGameplayTag LocationTag;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Requirements")
    int32 RecommendedLevel = 0;
 
 
    FQuestInfo()
    {
        
    }
 
    explicit FQuestInfo(const FQuestInfoStatus& QuestStatus)
    {
        Status = QuestStatus;
    }
        
    // Implementing the '==' operator for the struct
    bool operator==(const FQuestInfo& Other) const
    {
        // Define what makes two FQuestInfo structs equal.
        // In this example, we assume two FQuestInfo are equal if their QuestIDs are equal.
        // You may need to adjust this based on what makes sense for your use case.
        return (QuestID == Other.QuestID) && (GetUniqueID() == Other.GetUniqueID());
    }
    bool operator!=(const FQuestInfo& Other) const
    {
        // Define what makes two FQuestInfo structs equal.
        // In this example, we assume two FQuestInfo are equal if their QuestIDs are equal.
        // You may need to adjust this based on what makes sense for your use case.
        return (QuestID != Other.QuestID) || (GetUniqueID() != Other.GetUniqueID());
    }
    bool operator==(const FUniqueID& OtherID) const
    {
        if(bUniqueObjectives){return (GetUniqueID() == OtherID);}
        return (QuestID == OtherID.ID);
    }
    bool operator!=(const FUniqueID& OtherID) const
    {
        if(bUniqueObjectives){return (GetUniqueID() != OtherID);}
        return (QuestID != OtherID.ID);
    }
 
    bool IsValid() const
    {
        if(QuestID == "Default Quest"){return false;}
        if(QuestName == "Default Name"){return false;}
        if(Status.GetObjectivesNum() == 0){return false;}
        return true;
    }
    static FQuestInfo Empty()
    {
        FQuestInfo EmptyQuestInfo;
        return EmptyQuestInfo;
    }
 
    bool GetIsActive() const
    {
        return Status.GetIsActive();
    }
    EQuestStatus GetQuestStatus() const
    {
        return Status.GetQuestStatus();
    }
    void SetUniqueID(const int32 ID)
    {
        Status.SetUniqueID(ID);
    }
    FUniqueID GetUniqueID() const
    {
        FUniqueID ID = FUniqueID(QuestID);
        ID.SetUniqueNumber(Status.GetUniqueID());
        return ID;
    }
    void SetStatus(const EQuestStatus NewQuestStatus)
    {
        Status.SetStatus(NewQuestStatus);
    }
    int32 GetObjectivesNum() const
    {
        return Status.ObjectiveReferences.Num();
    }
    int32 GetTotalProgress() const
    {
        return Status.GetTotalProgress();
    }
    
    int32 GetTotalRequiredProgress() const
    {
        return Status.GetTotalRequiredProgress();
    }
 
    float GetElapsedTime() const
    {
        return Status.GetElapsedTime();
    }
    float GetStartTime() const
    {
        return Status.GetStartTime();
    }
 
    //- Timer   //
    void StartQuest(const UObject* Owner)
    {
        Status.StartQuest(Owner);
    }
    float SaveQuestTime(const UObject* Owner)
    {
        const float ElapsedTime = Status.SaveQuestTime(Owner);
        return ElapsedTime;
    }
    void ResumeFromElapsedTime()
    {
        Status.ResumeFromElapsedTime();
    }
    bool GetIsQuestInTime() const
    {
        if(bQuestTimed)
        {
            return Status.GetDidCompleteInTime(TimeToComplete);
        }
        return true;
    }
    //-         //
 
    //@ TODO Change to getting from the pointers, then maybe just remove and put in PlayerQuestStatus
    TArray<FQuestObjectives> GetCompletedObjectives() const
    {
        TArray<FQuestObjectives> CompletedObjectives;
        for(const auto& Objective : Status.ObjectiveReferences)
        {
            if(Objective == nullptr){continue;}
            if(Objective->GetIsComplete())
            {
                CompletedObjectives.AddUnique(*Objective);
            }
        }
        return CompletedObjectives;
    }
    TArray<FString> GetActiveObjectiveIDs() const
    {
        return Status.GetActiveObjectiveIDs();
    }
    TArray<FString> GetNotStartedObjectiveIDs() const
    {
        return Status.GetNotStartedObjectiveIDs();
    }
    TArray<FString> GetActiveObjectiveIDsWithMarkers() const
    {
        return Status.GetActiveObjectiveIDsWithMarkers();
    }
    FQuestReward GetFullQuestReward() const
    {
        FQuestReward FullReward = Reward;
        for(const auto& Objective : GetCompletedObjectives())
        {
            FullReward.Credits += Objective.RewardBonus.Credits;
            FullReward.Experience += Objective.RewardBonus.Experience;
        }
        return FullReward;
    }
    TArray<FQuestObjectives> GetObjectives() const
    {
        TArray<FQuestObjectives> Objectives;
        for(const auto Objective : Status.ObjectiveReferences)
        {
            if(Objective == nullptr || Objective->ObjectiveID.IsEmpty())
            {
                UE_LOG(LogTemp, Warning, TEXT("Null objective pointer"));
                continue;
            }
            const FQuestObjectives ObjectiveCopy = *Objective;
            Objectives.Add(ObjectiveCopy);
        }
        return Objectives;
    }
 
    
    bool GetCanBeCompleted(const UObject* Owner, EQuestStatus& QuestOutcome)
    {
        //- Sets Elapsed Time   //
        SaveQuestTime(Owner);
        if(GetIsQuestInTime())
        {
            return Status.GetCanBeCompleted(Owner, QuestOutcome);
        }
        QuestOutcome = EQuestStatus::Failed;
        return true;
    }
    //  QuestOutcome = EQuestStatus::Active;
    //  for(FQuestObjectives& QuestObjective : Objectives)
    //  {
    //      //- Don't Check Optional Objectives //
    //      if(QuestObjective.bIsOptional){continue;}
    //      if(QuestObjective.GetIsFailed())
    //      {
    //          QuestOutcome = EQuestStatus::Failed;
    //          return true;
    //      }
    //      if(QuestObjective.bObjectiveTimed && !QuestObjective.GetDidCompleteInTime(Owner))
    //      {
    //          QuestOutcome = EQuestStatus::Failed;
    //          return true;
    //      }
    //      //- If any of the non optional Objectives aren't complete   //
    //      if(QuestObjective.IsFinished() == false)
    //      {
    //          QuestOutcome = EQuestStatus::Active;
    //          return false;
    //      }
    //  }
    //  //- All Objectives Complete //
    //  if(bQuestTimed)
    //  {
    //      if(!GetDidCompleteInTime(Owner))
    //      {
    //          QuestOutcome = EQuestStatus::Failed;
    //          return true;
    //      }
    //  }
    //  QuestOutcome = EQuestStatus::Completed;
    //  return true;
    // }
};
 
FORCEINLINE uint32 GetTypeHash(const FQuestInfo& QuestInfo)
{
    // Hash based on a unique property of FQuestInfo, or combine multiple properties
    return FCrc::MemCrc32(&QuestInfo.QuestID, sizeof(QuestInfo.QuestID));
}
 
USTRUCT(BlueprintType)
struct FQuestOutcome
{
    GENERATED_BODY()
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Quest System")
    FUniqueID QuestID;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Quest System")
    FString QuestName = "Name";
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Quest System")
    TArray<FQuestObjectives> CompletedObjectives;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Quest System")
    EQuestStatus Outcome = EQuestStatus::Completed;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Quest System")
    FQuestReward Reward;
    
    FQuestOutcome()
    {
        
    }
 
    explicit FQuestOutcome(const TArray<FQuestObjectives>& NewCompletedObjectives)
    {
        CompletedObjectives = NewCompletedObjectives;
    }
    explicit FQuestOutcome(const TArray<FQuestObjectives>& NewCompletedObjectives, const EQuestStatus FinishedOutcome)
    {
        CompletedObjectives = NewCompletedObjectives;
        Outcome = FinishedOutcome;
    }
};
 
 
USTRUCT(BlueprintType)
struct FPlayerQuestStatus : public FTableRowBase
{
    GENERATED_BODY()
 
    FPlayerQuestStatus(){}
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="General")
    TArray<FQuestInfo> ActiveQuests;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Stats")
    int32 Credits = 0;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Stats")
    int32 Experience = 0;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Other")
    int32 MaximumActiveQuests = 999;
 
 
    TArray<FQuestOutcome> CanQuestsBeCompleted(const UObject* Owner)
    {
        SaveTimes(Owner);
        TArray<FQuestOutcome> AllOutcomes; 
        for(auto& Quest : ActiveQuests)
        {
            FQuestOutcome Outcome;
            EQuestStatus QuestOutcome; 
            if(Quest.GetCanBeCompleted(Owner, QuestOutcome))
            {
                Outcome.Outcome = QuestOutcome;
                Outcome.CompletedObjectives = Quest.GetCompletedObjectives();
                Outcome.QuestID = Quest.GetUniqueID();
                Outcome.QuestName = Quest.QuestName;
                AllOutcomes.Add(Outcome);
            }
        }
        return AllOutcomes;
    }
 
    
    bool AddObjective(const FQuestObjectives& ObjectiveInfo)
    {
        const FQuestObjectives* ExistingPtr = Objectives.FindByPredicate(
        [&](const FQuestObjectives& Obj)
        {
            return (Obj.ObjectiveID == ObjectiveInfo.ObjectiveID && Obj.GetUniqueID() == ObjectiveInfo.GetUniqueID());
        });
 
        if(ExistingPtr)
        {
            AddObjectiveToQuests(ExistingPtr); 
            return true;
        }
        const int32 Index = Objectives.AddUnique(ObjectiveInfo);
        const FQuestObjectives* NewPtr = &Objectives[Index];
        AddObjectiveToQuests(NewPtr);
        return true;
        
        //@TODO if Objective is not Unique 
        // const int32 Index = Objectives.AddUnique(ObjectiveInfo);
        // TSharedPtr<FQuestObjectives> ObjectivePtr = MakeShared<FQuestObjectives>(Objectives[Index]);
        // if(ObjectivePtr == nullptr){return false;}
        // AddObjectiveToQuests(ObjectivePtr);
        // return true;
    }
    // @TODO move to Protected 
    bool AddObjectiveToQuests(const FQuestObjectives* Objective)
    {
        if(Objective == nullptr){return false;}
        for(auto& Quest : ActiveQuests)
        {
            //@ TODO Check
            if(Quest.bUniqueObjectives && Quest.GetUniqueID().GetUniqueNumber() != Objective->GetUniqueID().GetUniqueNumber())
            {
                continue;
            }
            //- @TODO And need to check if Unique 
            if(Quest.ObjectiveIDs.Contains(Objective->ObjectiveID))
            {
                const bool bAlreadyAdded = Quest.Status.ObjectiveReferences.ContainsByPredicate(
                [&](const FQuestObjectives* Existing)
                {
                    return Existing == Objective;
                });
 
                if(!bAlreadyAdded)
                {
                    Quest.Status.ObjectiveReferences.Add(Objective);
                }
            }
        }
        return true;
    }
    int32 GetNewUniqueID(const FString& QuestID) const
    {
        int32 UniqueID = 1;
        for(const auto& Quest :ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                if(UniqueID <= Quest.GetUniqueID().GetUniqueNumber())
                {
                    UniqueID = Quest.GetUniqueID().GetUniqueNumber() + 1;
                }
            }
        }
        return UniqueID;
    }
    int32 StartQuest(const UObject* Owner, FQuestInfo& QuestInfo)
    {
        QuestInfo.StartQuest(Owner);
        if(QuestInfo.bUniqueObjectives)
        {
            const int32 UniqueID = GetNewUniqueID(QuestInfo.QuestID);
            QuestInfo.SetUniqueID(UniqueID);
            return ActiveQuests.Add(QuestInfo);
        }
        // QuestInfo.GetTotalProgress()
        
        //@ TODO add seperate Objectives function? or should GScomp just start the objectives when they're found from DT ?  
        // StartObjectives();
        for(auto& Objective : Objectives)
        {
            //@ TODO is there better way to check? is this just 2 for loops?
            // if(Objective.ObjectiveID == )
            if(QuestInfo.ObjectiveIDs.Contains(Objective.ObjectiveID))
            {
                Objective.StartObjective(Owner);
            }
        }
        return ActiveQuests.AddUnique(QuestInfo);
    }
    void StartObjectives(const UObject* Owner)
    {
        for(auto& ActiveQuest : ActiveQuests)
        {
            //- If We have unique Objectives, Update them with the Unique progress 
            if(ActiveQuest.bUniqueObjectives)
            {
                for(auto& Objective : Objectives)
                {
                    if(ActiveQuest.ObjectiveIDs.Contains(Objective.ObjectiveID))
                    {
                        if(ActiveQuest.GetUniqueID().GetUniqueNumber() == Objective.GetUniqueID().GetUniqueNumber())
                        {
                            Objective.StartObjective(Owner, ActiveQuest.GetTotalProgress());
                        }
                    }
                }
            }
            else
            {
                for(auto& Objective : Objectives)
                {
                    if(Objective.GetUniqueID().IsUnique()){continue;}
                    if(ActiveQuest.GetUniqueID().GetUniqueNumber() == Objective.GetUniqueID().GetUniqueNumber())
                    {
                        Objective.StartObjective(Owner);
                    }
                }
        
            }
        }
    }
 
    bool AddObjectiveAmount(const FString& ObjectiveID, const int32 Amount)
    {
        bool bCompleted = false;
        // Go through each Objective
        for(FQuestObjectives& Objective : Objectives)
        {
            // Ignore complete ones, or Unactive ones //! Potentially redundant before ID check as only the matching ID will work be edited 
            if(Objective.GetIsComplete() || Objective.GetIsActive() == false){continue;}
            //- if It's the Correct ID 
            if(ObjectiveID == Objective.ObjectiveID)
            {
                const bool bFinishedObjective = Objective.AddProgress(Amount);
                if(bCompleted == false)
                {
                    bCompleted = bFinishedObjective;
                }
            }
        }
        return bCompleted;
    }
    
    bool AddObjectiveAmount(const FUniqueID& ObjectiveID, const int32 Amount)
    {
        bool bCompleted = false;
        // Go through each Objective
        for(FQuestObjectives& Objective : Objectives)
        {
            // Ignore complete ones, or Unactive ones //! Potentially redundant before ID check as only the matching ID will work be edited 
            if(Objective.GetIsComplete() || Objective.GetIsActive() == false){continue;}
            //- if It's the Correct ID 
            if(ObjectiveID == Objective.GetUniqueID())
            {
                bCompleted = Objective.AddProgress(Amount);
            }
        }
        return bCompleted;
    }
 
    bool AddObjectiveFailAmount(const FString& ObjectiveID, const int32 Amount)
    {
        bool bCompleted = false;
        // Go through each Objective
        for(FQuestObjectives& Objective : Objectives)
        {
            // Ignore complete ones, or Unactive ones //! Potentially redundant before ID check as only the matching ID will work be edited 
            if(Objective.GetIsComplete() || Objective.GetIsActive() == false){continue;}
            //- if It's the Correct ID 
            if(ObjectiveID == Objective.ObjectiveID)
            {
                bCompleted = Objective.AddFailProgress(Amount);
            }
        }
        return bCompleted;
    }
    bool AddObjectiveFailAmount(const FUniqueID& ObjectiveID, const int32 Amount)
    {
        bool bCompleted = false;
        // Go through each Objective
        for(FQuestObjectives& Objective : Objectives)
        {
            // Ignore complete ones, or Unactive ones //! Potentially redundant before ID check as only the matching ID will work be edited 
            if(Objective.GetIsComplete() || Objective.GetIsActive() == false){continue;}
            //- if It's the Correct ID 
            if(ObjectiveID == Objective.GetUniqueID())
            {
                bCompleted = Objective.AddFailProgress(Amount);
            }
        }
        return bCompleted;
    }
 
    bool GetQuestObjectivesIDs(const FString& QuestID, TArray<FString>& ObjectiveIDs) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                ObjectiveIDs = Quest.ObjectiveIDs;
                return true;
            }
        }
        return false;
    }
    bool GetQuestActiveObjectivesIDs(const FString& QuestID, TArray<FString>& ObjectiveIDs) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                ObjectiveIDs = Quest.GetActiveObjectiveIDs();
                return true;
            }
        }
        return false;
    }
    
    bool GetQuestActiveObjectivesIDsWithMarkers(const FUniqueID& QuestID, TArray<FString>& ObjectiveIDs) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                ObjectiveIDs = Quest.GetActiveObjectiveIDsWithMarkers();
                return true;
            }
        }
        return false;
    }
    bool GetDoesObjectiveHaveWorldMarker(const FString& ObjectiveID) const
    {
        for(const auto& Objective : Objectives)
        {
            if(Objective.ObjectiveID == ObjectiveID)
            {
                return Objective.bHasWorldMarker;
            }
        }
        return false;
    }
    bool GetQuestIndex(const FQuestInfo& QuestInfo, int32& Index) const
    {
        for(int32 i = 0; i < ActiveQuests.Num(); i++)
        {
            if(ActiveQuests[i].GetUniqueID() == QuestInfo.GetUniqueID())
            {
                Index = i;
                return true;
            }
        }
        return false;
    }
    bool GetQuestIndex(const FUniqueID& QuestID, int32& Index) const
    {
        for(int32 i = 0; i < ActiveQuests.Num(); i++)
        {
            if(ActiveQuests[i].GetUniqueID() == QuestID)
            {
                Index = i;
                return true;
            }
        }
        // if(ActiveQuests.Contains(QuestID))
        // {
        //  const int32 QuestIndex = ActiveQuests.IndexOfByKey(QuestID);
        //  Index = QuestIndex;
        //  return true;
        // }
        return false;
    }
    
    bool RemoveQuest(const FQuestInfo& QuestInfo)
    {
        int32 Index = 0;
        TArray<FString> ObjectiveIDs;
        bool bFound = false;
        for(int32 i = 0; i < ActiveQuests.Num(); i++)
        {
            if(ActiveQuests[i].GetUniqueID() == QuestInfo.GetUniqueID())
            {
                Index = i;
                ObjectiveIDs = ActiveQuests[Index].ObjectiveIDs;
                bFound = true;
                break;
            }
        }
        if(bFound)
        {
            ActiveQuests.RemoveAt(Index);
            CheckObjectives(ObjectiveIDs);
        }
        return bFound;
    }
    // bool RemoveQuest(const FString& QuestID)
    // {
    //  for(const FQuestInfo Quest : ActiveQuests)
    //  {
    //      if(Quest.QuestID == QuestID)
    //      {
    //          ActiveQuests.Remove(Quest);
    //          // ResetCurrentQuest();
    //          CheckObjectives(Quest.ObjectiveIDs);
    //          return true;
    //      }
    //  }
    //  return false;
    // }
    void CheckObjectives(TArray<FString> ObjectiveIDs)
    {
        for(const auto& ObjectiveID : ObjectiveIDs) // {QO_01 QO_02}
        {
            // Check if any other quest uses this objective 
            bool bUsedInOtherQuest = false;
            for(const FQuestInfo& Quest: ActiveQuests)
            {
                if(Quest.ObjectiveIDs.Contains(ObjectiveID))
                {
                    bUsedInOtherQuest = true;
                }
            }
            if(bUsedInOtherQuest)
            {
                
            }
            else
            {
                Objectives.RemoveAll([&](const FQuestObjectives& Old)
                {
                    return Old.ObjectiveID == ObjectiveID;  // uses operator== under the hood
                });
            }           
        }
    }
    void CheckAllObjectives()
    {
        TArray<FString> ObjectiveIDs;
        for(const FQuestInfo& Quest: ActiveQuests)
        {
            ObjectiveIDs.Append(Quest.ObjectiveIDs);
        }
 
        Objectives.RemoveAll([&](const FQuestObjectives& Old)
        {
            return !ObjectiveIDs.Contains(Old.ObjectiveID);
        });
    }
    TArray<FString> GetQuestsToBeAddedAfterCompletion(const FString& QuestID)
    {
        TArray<FString> QuestsToBeAdded;
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            if(QuestID == Quest.QuestID)
            {
                QuestsToBeAdded.Append(Quest.QuestsToBeAddedAfterCompletion);
            }
        }
        return QuestsToBeAdded;
    }
    FString GetQuestName(const FString& QuestID)
    {
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            if(QuestID == Quest.QuestID)
            {
                return Quest.QuestName;
            }
        }
        return "";
    }
 
    TArray<FString> GetQuestIDs()
    {
        TArray<FString> ActiveQuestIDs;
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            ActiveQuestIDs.Add(Quest.QuestID);
        }
        return ActiveQuestIDs;
    }
    TArray<FString> GetObjectiveIDs()
    {
        TArray<FString> ActiveObjectiveIDs;
        for (const auto& Objective: Objectives)
        {
            ActiveObjectiveIDs.Add(Objective.ObjectiveID);
        }
        return ActiveObjectiveIDs;
    }
    const FQuestObjectives* GetQuestObjectivePtr(const FUniqueID& ObjectiveID) const
    {
        return Objectives.FindByPredicate([&](const FQuestObjectives& Elem){ return Elem.GetUniqueID() == ObjectiveID;});
    }
 
    bool GetActiveQuest(const FUniqueID& QuestID, FQuestInfo& QuestInfo) 
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                QuestInfo = Quest;
                return true;
            }
        }
        return false;
    }
    bool GetIsQuestActive(const FString& QuestID) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                return Quest.GetIsActive();
            }
        }
        return false;
    }
    bool GetIsQuestActive(const FUniqueID& QuestID) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                return Quest.GetIsActive();
            }
        }
        return false;
    }
    bool GetIsQuestActive(const int32 QuestIndex) const
    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            return ActiveQuests[QuestIndex].GetIsActive();
        }
        return false;
    }
    bool GetQuest(const int32 QuestIndex, FQuestInfo& QuestInfo) const
    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            QuestInfo = ActiveQuests[QuestIndex];
            return true;
        }
        return false;
    }
    bool GetQuestID(const int32 QuestIndex, FUniqueID& QuestID) const
    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            QuestID = ActiveQuests[QuestIndex].GetUniqueID();
            return true;
        }
        return false;
    }
 
    EQuestStatus GetQuestStatus(const FString& QuestID) const
    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                return Quest.GetQuestStatus();
            }
        }
        return EQuestStatus::NotStarted;
    }
    int32 GetLevel() const
    {
        return FMath::Min(static_cast<int32>(Experience / XP_PER_LEVEL), MAX_SKILL_LEVEL); // Ensure Level does not exceed MaxLevel
    }
 
    void SaveTimes(const UObject* Owner)
    {
        SaveQuestTimes(Owner);
        SaveObjectiveTimes(Owner);
    }
    void ResumeQuestsAndObjectives()
    {
        for(auto& Quest : ActiveQuests)
        {
            if(Quest.GetIsActive())
            {
                Quest.ResumeFromElapsedTime();
            }
        }
        for(auto& Objective : Objectives)
        {
            if(Objective.GetIsActive())
            {
                Objective.ResumeFromElapsedTime();
            }
        }
    }
    //@ TODO 
    void UpdateQuestDetails(const FQuestInfo& UpdatedQuestInfo)
    {
        for(auto& OldQuest : ActiveQuests)
        {
            if(OldQuest.QuestID == UpdatedQuestInfo.QuestID)
            {
                FQuestInfo NewQuestDetails = UpdatedQuestInfo;
                NewQuestDetails.Status = OldQuest.Status;
                OldQuest = NewQuestDetails;
            }
        }
    }
    bool UpdateObjectiveDetails(const FQuestObjectives& UpdatedObjectiveInfo)
    {
        //- @TODO We need a case for when the objective is new and not in the array of objectives, or when it's not in the array
        for(auto& OldObjective : Objectives)
        {
            if(OldObjective.ObjectiveID == UpdatedObjectiveInfo.ObjectiveID)
            {
                FQuestObjectives NewObjectiveDetails = UpdatedObjectiveInfo;
                NewObjectiveDetails.ObjectiveStatus = OldObjective.ObjectiveStatus;
                OldObjective = NewObjectiveDetails;
                return true;
            }
        }
        //- Updated Objective Doesn't Exist? Add it to Array 
        Objectives.Add(UpdatedObjectiveInfo);
        return false;
 
        //- @TODO  Missing if an Objective gets Deleted
        
 
        // const int32 ObjectiveIndex = Objectives.Find(UpdatedObjectiveInfo);
        // //@TODO if it's not in the Objectives array, add it. 
        // if(Objectives.IsValidIndex(ObjectiveIndex))
        // {
        //  // BUG NOT FINISHED
        //  
        //  Objectives[ObjectiveIndex];
        //  return true;
        // }
        // Objectives.Add(UpdatedObjectiveInfo);
        // for(auto& Objective : Objectives)
        // {
        //  if(Objective.ObjectiveID == UpdatedObjectiveInfo.ObjectiveID)
        //  {
        //      FQuestObjectives NewObjectiveInfo = UpdatedObjectiveInfo;
        //      NewObjectiveInfo.ObjectiveStatus = Objective.ObjectiveStatus;
        //      Objective = NewObjectiveInfo;
        //  }
        // }
    }
    bool UpdateQuestStatus(FQuestOutcome& Outcome)
    {
        for(auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == Outcome.QuestID)
            {
                switch(Outcome.Outcome)
                {
                case EQuestStatus::NotStarted:
                    Quest.SetStatus(Outcome.Outcome);
                    break;
                case EQuestStatus::Active:
                    Quest.SetStatus(Outcome.Outcome);
                    break;
                case EQuestStatus::Completed:
                    Quest.SetStatus(Outcome.Outcome);
                    Outcome.Reward = Quest.GetFullQuestReward();
                    break;
                case EQuestStatus::Failed:
                    if(Quest.bCanQuestFail)
                    {
                        Outcome.Reward = Quest.GetFullQuestReward();
                        Quest.SetStatus(Outcome.Outcome);
                    }
                    else
                    {
                        return false;
                    }
                    break;
                case EQuestStatus::Abandoned:
                    if(Quest.bCanQuestBeAbandoned)
                    {
                        Quest.SetStatus(Outcome.Outcome);
                    }
                    else
                    {
                        return false;
                    }
                    break;
                case EQuestStatus::NotAvailable:
                    Quest.SetStatus(Outcome.Outcome);
                    break;
                }
                return true;
            }
        }
        return false;
    }
 
    TArray<FQuestInfo> FilterQuests(const EQuestStatus QuestFilter)
    {
        TArray<FQuestInfo> FilteredQuests;
        for(auto& Quest : ActiveQuests)
        {
            if(Quest.GetQuestStatus() == QuestFilter)
            {
                FilteredQuests.Add(Quest);
            }
        }
        return FilteredQuests;
    }
    
    //- Checks if was made valid in constructor //
    bool IsValid() const
    {
        return bValid;
    }
protected:
    void SaveQuestTimes(const UObject* Owner)
    {
        for(auto& ActiveQuest : ActiveQuests)
        {
            ActiveQuest.SaveQuestTime(Owner);
        }
    }
    void SaveObjectiveTimes(const UObject* Owner)
    {
        for(auto& Objective : Objectives)
        {
            Objective.SaveObjectiveTime(Owner);
        }
    }
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="General")
    TArray<FQuestObjectives> Objectives;
    
private:
 
    bool bValid = true;
};