FPlayerQuestStatus Struct Reference

#include <QuestData.h>

Inheritance diagram for FPlayerQuestStatus:

Public Member Functions
	FPlayerQuestStatus ()
TArray< FQuestOutcome >	CanQuestsBeCompleted (const UObject *Owner)
bool	AddObjective (const FQuestObjectives &ObjectiveInfo)
bool	AddObjectiveToQuests (const FQuestObjectives *Objective)
int32	GetNewUniqueID (const FString &QuestID) const
int32	StartQuest (const UObject *Owner, FQuestInfo &QuestInfo)
void	StartObjectives (const UObject *Owner)
bool	AddObjectiveAmount (const FString &ObjectiveID, const int32 Amount)
bool	AddObjectiveAmount (const FUniqueID &ObjectiveID, const int32 Amount)
bool	AddObjectiveFailAmount (const FString &ObjectiveID, const int32 Amount)
bool	AddObjectiveFailAmount (const FUniqueID &ObjectiveID, const int32 Amount)
bool	GetQuestObjectivesIDs (const FString &QuestID, TArray< FString > &ObjectiveIDs) const
bool	GetQuestActiveObjectivesIDs (const FString &QuestID, TArray< FString > &ObjectiveIDs) const
bool	GetQuestActiveObjectivesIDsWithMarkers (const FUniqueID &QuestID, TArray< FString > &ObjectiveIDs) const
bool	GetDoesObjectiveHaveWorldMarker (const FString &ObjectiveID) const
bool	GetQuestIndex (const FQuestInfo &QuestInfo, int32 &Index) const
bool	GetQuestIndex (const FUniqueID &QuestID, int32 &Index) const
bool	RemoveQuest (const FQuestInfo &QuestInfo)
void	CheckObjectives (TArray< FString > ObjectiveIDs)
void	CheckAllObjectives ()
TArray< FString >	GetQuestsToBeAddedAfterCompletion (const FString &QuestID)
FString	GetQuestName (const FString &QuestID)
TArray< FString >	GetQuestIDs ()
TArray< FString >	GetObjectiveIDs ()
const FQuestObjectives *	GetQuestObjectivePtr (const FUniqueID &ObjectiveID) const
bool	GetActiveQuest (const FUniqueID &QuestID, FQuestInfo &QuestInfo)
bool	GetIsQuestActive (const FString &QuestID) const
bool	GetIsQuestActive (const FUniqueID &QuestID) const
bool	GetIsQuestActive (const int32 QuestIndex) const
bool	GetQuest (const int32 QuestIndex, FQuestInfo &QuestInfo) const
bool	GetQuestID (const int32 QuestIndex, FUniqueID &QuestID) const
EQuestStatus	GetQuestStatus (const FString &QuestID) const
int32	GetLevel () const
void	SaveTimes (const UObject *Owner)
void	ResumeQuestsAndObjectives ()
void	UpdateQuestDetails (const FQuestInfo &UpdatedQuestInfo)
	Check if this is worth doing with this or just putting in GameState component.
bool	UpdateObjectiveDetails (const FQuestObjectives &UpdatedObjectiveInfo)
bool	UpdateQuestStatus (FQuestOutcome &Outcome)
TArray< FQuestInfo >	FilterQuests (const EQuestStatus QuestFilter)
bool	IsValid () const

Public Attributes
TArray< FQuestInfo >	ActiveQuests
int32	Credits = 0
int32	Experience = 0
int32	MaximumActiveQuests = 999

Protected Member Functions
void	SaveQuestTimes (const UObject *Owner)
void	SaveObjectiveTimes (const UObject *Owner)

Protected Attributes
TArray< FQuestObjectives >	Objectives

Private Attributes
bool	bValid = true

Constructor & Destructor Documentation

FPlayerQuestStatus()

FPlayerQuestStatus::FPlayerQuestStatus ( )

inline

{}

Member Function Documentation

AddObjective()

bool FPlayerQuestStatus::AddObjective ( const FQuestObjectives & ObjectiveInfo )

inline

Adds objective to the Objective Array, and any Quests NOTE: add Quest First!

    {
        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;
    }

AddObjectiveAmount() [1/2]

bool FPlayerQuestStatus::AddObjectiveAmount ( const FString & ObjectiveID, const int32 Amount )

inline

    {
        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;
    }

AddObjectiveAmount() [2/2]

bool FPlayerQuestStatus::AddObjectiveAmount ( const FUniqueID & ObjectiveID, const int32 Amount )

inline

    {
        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;
    }

AddObjectiveFailAmount() [1/2]

bool FPlayerQuestStatus::AddObjectiveFailAmount ( const FString & ObjectiveID, const int32 Amount )

inline

    {
        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;
    }

AddObjectiveFailAmount() [2/2]

bool FPlayerQuestStatus::AddObjectiveFailAmount ( const FUniqueID & ObjectiveID, const int32 Amount )

inline

    {
        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;
    }

AddObjectiveToQuests()

bool FPlayerQuestStatus::AddObjectiveToQuests ( const FQuestObjectives * Objective )

inline

    {
        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;
    }

CanQuestsBeCompleted()

TArray< FQuestOutcome > FPlayerQuestStatus::CanQuestsBeCompleted ( const UObject * Owner )

inline

    {
        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;
    }

CheckAllObjectives()

void FPlayerQuestStatus::CheckAllObjectives ( )

inline

Check to Make sure all Objectives are valid to a quest

    {
        TArray<FString> ObjectiveIDs;
        for(const FQuestInfo& Quest: ActiveQuests)
        {
            ObjectiveIDs.Append(Quest.ObjectiveIDs);
        }
 
        Objectives.RemoveAll([&](const FQuestObjectives& Old)
        {
            return !ObjectiveIDs.Contains(Old.ObjectiveID);
        });
    }

CheckObjectives()

void FPlayerQuestStatus::CheckObjectives ( TArray< FString > ObjectiveIDs )

inline

After Removing a Quest, Check if the objectives are needed on other quests

@TODO FIX THIS

    {
        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
                });
            }           
        }
    }

FilterQuests()

TArray< FQuestInfo > FPlayerQuestStatus::FilterQuests ( const EQuestStatus QuestFilter )

inline

    {
        TArray<FQuestInfo> FilteredQuests;
        for(auto& Quest : ActiveQuests)
        {
            if(Quest.GetQuestStatus() == QuestFilter)
            {
                FilteredQuests.Add(Quest);
            }
        }
        return FilteredQuests;
    }

GetActiveQuest()

bool FPlayerQuestStatus::GetActiveQuest ( const FUniqueID & QuestID, FQuestInfo & QuestInfo )

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                QuestInfo = Quest;
                return true;
            }
        }
        return false;
    }

GetDoesObjectiveHaveWorldMarker()

bool FPlayerQuestStatus::GetDoesObjectiveHaveWorldMarker ( const FString & ObjectiveID ) const

inline

    {
        for(const auto& Objective : Objectives)
        {
            if(Objective.ObjectiveID == ObjectiveID)
            {
                return Objective.bHasWorldMarker;
            }
        }
        return false;
    }

GetIsQuestActive() [1/3]

bool FPlayerQuestStatus::GetIsQuestActive ( const FString & QuestID ) const

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                return Quest.GetIsActive();
            }
        }
        return false;
    }

GetIsQuestActive() [2/3]

bool FPlayerQuestStatus::GetIsQuestActive ( const FUniqueID & QuestID ) const

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                return Quest.GetIsActive();
            }
        }
        return false;
    }

GetIsQuestActive() [3/3]

bool FPlayerQuestStatus::GetIsQuestActive ( const int32 QuestIndex ) const

inline

    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            return ActiveQuests[QuestIndex].GetIsActive();
        }
        return false;
    }

GetLevel()

int32 FPlayerQuestStatus::GetLevel ( ) const

inline

    {
        return FMath::Min(static_cast<int32>(Experience / XP_PER_LEVEL), MAX_SKILL_LEVEL); // Ensure Level does not exceed MaxLevel
    }

GetNewUniqueID()

int32 FPlayerQuestStatus::GetNewUniqueID ( const FString & QuestID ) const

inline

    {
        int32 UniqueID = 1;
        for(const auto& Quest :ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                if(UniqueID <= Quest.GetUniqueID().GetUniqueNumber())
                {
                    UniqueID = Quest.GetUniqueID().GetUniqueNumber() + 1;
                }
            }
        }
        return UniqueID;
    }

GetObjectiveIDs()

TArray< FString > FPlayerQuestStatus::GetObjectiveIDs ( )

inline

    {
        TArray<FString> ActiveObjectiveIDs;
        for (const auto& Objective: Objectives)
        {
            ActiveObjectiveIDs.Add(Objective.ObjectiveID);
        }
        return ActiveObjectiveIDs;
    }

GetQuest()

bool FPlayerQuestStatus::GetQuest ( const int32 QuestIndex, FQuestInfo & QuestInfo ) const

inline

Returns if Quest Found

    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            QuestInfo = ActiveQuests[QuestIndex];
            return true;
        }
        return false;
    }

GetQuestActiveObjectivesIDs()

bool FPlayerQuestStatus::GetQuestActiveObjectivesIDs ( const FString & QuestID, TArray< FString > & ObjectiveIDs ) const

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                ObjectiveIDs = Quest.GetActiveObjectiveIDs();
                return true;
            }
        }
        return false;
    }

GetQuestActiveObjectivesIDsWithMarkers()

bool FPlayerQuestStatus::GetQuestActiveObjectivesIDsWithMarkers ( const FUniqueID & QuestID, TArray< FString > & ObjectiveIDs ) const

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.GetUniqueID() == QuestID)
            {
                ObjectiveIDs = Quest.GetActiveObjectiveIDsWithMarkers();
                return true;
            }
        }
        return false;
    }

GetQuestID()

bool FPlayerQuestStatus::GetQuestID ( const int32 QuestIndex, FUniqueID & QuestID ) const

inline

    {
        if(ActiveQuests.IsValidIndex(QuestIndex))
        {
            QuestID = ActiveQuests[QuestIndex].GetUniqueID();
            return true;
        }
        return false;
    }

GetQuestIDs()

TArray< FString > FPlayerQuestStatus::GetQuestIDs ( )

inline

    {
        TArray<FString> ActiveQuestIDs;
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            ActiveQuestIDs.Add(Quest.QuestID);
        }
        return ActiveQuestIDs;
    }

GetQuestIndex() [1/2]

bool FPlayerQuestStatus::GetQuestIndex ( const FQuestInfo & QuestInfo, int32 & Index ) const

inline

    {
        for(int32 i = 0; i < ActiveQuests.Num(); i++)
        {
            if(ActiveQuests[i].GetUniqueID() == QuestInfo.GetUniqueID())
            {
                Index = i;
                return true;
            }
        }
        return false;
    }

GetQuestIndex() [2/2]

bool FPlayerQuestStatus::GetQuestIndex ( const FUniqueID & QuestID, int32 & Index ) const

inline

    {
        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;
    }

GetQuestName()

FString FPlayerQuestStatus::GetQuestName ( const FString & QuestID )

inline

    {
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            if(QuestID == Quest.QuestID)
            {
                return Quest.QuestName;
            }
        }
        return "";
    }

GetQuestObjectivePtr()

const FQuestObjectives * FPlayerQuestStatus::GetQuestObjectivePtr ( const FUniqueID & ObjectiveID ) const

inline

    {
        return Objectives.FindByPredicate([&](const FQuestObjectives& Elem){ return Elem.GetUniqueID() == ObjectiveID;});
    }

GetQuestObjectivesIDs()

bool FPlayerQuestStatus::GetQuestObjectivesIDs ( const FString & QuestID, TArray< FString > & ObjectiveIDs ) const

inline

Gets all Objective IDs from Quest

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                ObjectiveIDs = Quest.ObjectiveIDs;
                return true;
            }
        }
        return false;
    }

GetQuestStatus()

EQuestStatus FPlayerQuestStatus::GetQuestStatus ( const FString & QuestID ) const

inline

    {
        for(const auto& Quest : ActiveQuests)
        {
            if(Quest.QuestID == QuestID)
            {
                return Quest.GetQuestStatus();
            }
        }
        return EQuestStatus::NotStarted;
    }

GetQuestsToBeAddedAfterCompletion()

TArray< FString > FPlayerQuestStatus::GetQuestsToBeAddedAfterCompletion ( const FString & QuestID )

inline

    {
        TArray<FString> QuestsToBeAdded;
        for (const FQuestInfo& Quest: ActiveQuests)
        {
            if(QuestID == Quest.QuestID)
            {
                QuestsToBeAdded.Append(Quest.QuestsToBeAddedAfterCompletion);
            }
        }
        return QuestsToBeAdded;
    }

IsValid()

bool FPlayerQuestStatus::IsValid ( ) const

inline

    {
        return bValid;
    }

RemoveQuest()

bool FPlayerQuestStatus::RemoveQuest ( const FQuestInfo & QuestInfo )

inline

    {
        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;
    }

ResumeQuestsAndObjectives()

void FPlayerQuestStatus::ResumeQuestsAndObjectives ( )

inline

    {
        for(auto& Quest : ActiveQuests)
        {
            if(Quest.GetIsActive())
            {
                Quest.ResumeFromElapsedTime();
            }
        }
        for(auto& Objective : Objectives)
        {
            if(Objective.GetIsActive())
            {
                Objective.ResumeFromElapsedTime();
            }
        }
    }

SaveObjectiveTimes()

void FPlayerQuestStatus::SaveObjectiveTimes ( const UObject * Owner )

inlineprotected

    {
        for(auto& Objective : Objectives)
        {
            Objective.SaveObjectiveTime(Owner);
        }
    }

SaveQuestTimes()

void FPlayerQuestStatus::SaveQuestTimes ( const UObject * Owner )

inlineprotected

    {
        for(auto& ActiveQuest : ActiveQuests)
        {
            ActiveQuest.SaveQuestTime(Owner);
        }
    }

SaveTimes()

void FPlayerQuestStatus::SaveTimes ( const UObject * Owner )

inline

    {
        SaveQuestTimes(Owner);
        SaveObjectiveTimes(Owner);
    }

StartObjectives()

void FPlayerQuestStatus::StartObjectives ( const UObject * Owner )

inline

    {
        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);
                    }
                }
        
            }
        }
    }

StartQuest()

int32 FPlayerQuestStatus::StartQuest ( const UObject * Owner, FQuestInfo & QuestInfo )

inline

Starts Quest timer and objective timers

    {
        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);
    }

UpdateObjectiveDetails()

bool FPlayerQuestStatus::UpdateObjectiveDetails ( const FQuestObjectives & UpdatedObjectiveInfo )

inline

    {
        //- @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;
        //  }
        // }
    }

UpdateQuestDetails()

void FPlayerQuestStatus::UpdateQuestDetails ( const FQuestInfo & UpdatedQuestInfo )

inline

Check if this is worth doing with this or just putting in GameState component.

    {
        for(auto& OldQuest : ActiveQuests)
        {
            if(OldQuest.QuestID == UpdatedQuestInfo.QuestID)
            {
                FQuestInfo NewQuestDetails = UpdatedQuestInfo;
                NewQuestDetails.Status = OldQuest.Status;
                OldQuest = NewQuestDetails;
            }
        }
    }

UpdateQuestStatus()

bool FPlayerQuestStatus::UpdateQuestStatus ( FQuestOutcome & Outcome )

inline

    {
        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;
    }

Member Data Documentation

ActiveQuests

TArray<FQuestInfo> FPlayerQuestStatus::ActiveQuests

bValid

bool FPlayerQuestStatus::bValid = true

private

Credits

int32 FPlayerQuestStatus::Credits = 0

Experience

int32 FPlayerQuestStatus::Experience = 0

MaximumActiveQuests

int32 FPlayerQuestStatus::MaximumActiveQuests = 999

Objectives

TArray<FQuestObjectives> FPlayerQuestStatus::Objectives

protected

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/QuestSystem/Source/QuestSystem/Public/Data/QuestData.h