FQuestObjectivesStatus Struct Reference

#include <QuestData.h>

Public Member Functions
float	GetElapsedTime () const
float	GetStartTime () const
void	StartObjective (const UObject *Owner)
void	SetObjectiveNotYetStarted ()
float	SaveObjectiveTime (const UObject *Owner)
void	ResumeFromElapsedTime ()
bool	GetIsFailed (const int32 RequiredFailProgress) const
bool	GetDidCompleteInTime (const bool bObjectiveTimed=false, const float TimeToComplete=0.0f) const
	Not sure if works becuase it needs to stop counting once objective is complete //.
bool	IsFinished (const int32 RequiredFailProgress, const int32 RequiredProgress) const
bool	IsSuccessful (const int32 RequiredFailProgress, const int32 RequiredProgress) const
bool	Complete (const int32 RequiredFailProgress, const int32 RequiredProgress) const
EQuestStatus	GetStatus () const
bool	IsActive () const
bool	GetIsStarted () const
bool	GetIsNotYetStarted () const
bool	AddProgress (const int32 Amount, const int32 RequiredProgress)
bool	AddFailProgress (const int32 Amount, const int32 RequiredFailProgress)
int32	GetCurrentProgress () const
int32	GetFailProgress () const
void	SetUniqueID (const int32 NewUID)
int32	GetUniqueID () const

Protected Attributes
EQuestStatus	Status = EQuestStatus::NotStarted
int32	UniqueID = -1
float	StartTimeInSeconds = -1.0f
float	ElapsedTime = -1.0f
int32	FailProgress = 0
int32	CurrentProgress = 0

Member Function Documentation

AddFailProgress()

bool FQuestObjectivesStatus::AddFailProgress ( const int32 Amount, const int32 RequiredFailProgress )

inline

Returns if Completed

    {
        FailProgress += Amount;
        if(FailProgress >= RequiredFailProgress)
        {
            FailProgress = RequiredFailProgress;
            if(Status == EQuestStatus::Active)
            {
                Status = EQuestStatus::Failed;
                return true;
            }
        }
        return false;
    }

AddProgress()

bool FQuestObjectivesStatus::AddProgress ( const int32 Amount, const int32 RequiredProgress )

inline

Returns if Completed

    {
        CurrentProgress += Amount;
        if(CurrentProgress >= RequiredProgress)
        {
            CurrentProgress = RequiredProgress;
            if(Status == EQuestStatus::Active)
            {
                Status = EQuestStatus::Completed;
                return true;
            }
        }
        return false;
    }

Complete()

bool FQuestObjectivesStatus::Complete ( const int32 RequiredFailProgress, const int32 RequiredProgress ) const

inline

    {
        if(FailProgress >= RequiredFailProgress)
        {
            return true;
        }
        return CurrentProgress >= RequiredProgress;
    }

GetCurrentProgress()

int32 FQuestObjectivesStatus::GetCurrentProgress ( ) const

inline

    {
        return CurrentProgress;
    }

GetDidCompleteInTime()

bool FQuestObjectivesStatus::GetDidCompleteInTime ( const bool bObjectiveTimed = false, const float TimeToComplete = 0.0f ) const

inline

Not sure if works becuase it needs to stop counting once objective is complete //.

    {
        //- Sets ElapsedTime    //
        if(bObjectiveTimed && StartTimeInSeconds >= 0.0f)
        {
            return ElapsedTime <= TimeToComplete;
        }
        return true;
    }

GetElapsedTime()

float FQuestObjectivesStatus::GetElapsedTime ( ) const

inline

    {
        return ElapsedTime;
    }

GetFailProgress()

int32 FQuestObjectivesStatus::GetFailProgress ( ) const

inline

    {
        return FailProgress;
    }

GetIsFailed()

bool FQuestObjectivesStatus::GetIsFailed ( const int32 RequiredFailProgress ) const

inline

    {
        if(FailProgress >= RequiredFailProgress)
        {
            return true;
        }
        return Status == EQuestStatus::Failed;
    }

GetIsNotYetStarted()

bool FQuestObjectivesStatus::GetIsNotYetStarted ( ) const

inline

    {
        return Status == EQuestStatus::NotStarted;
    }

GetIsStarted()

bool FQuestObjectivesStatus::GetIsStarted ( ) const

inline

    {
        return (Status != EQuestStatus::NotAvailable && Status != EQuestStatus::NotStarted);
    }

GetStartTime()

float FQuestObjectivesStatus::GetStartTime ( ) const

inline

For Calculating time after save

    {
        return StartTimeInSeconds;
    }

GetStatus()

EQuestStatus FQuestObjectivesStatus::GetStatus ( ) const

inline

    {
        return Status;
    }

GetUniqueID()

int32 FQuestObjectivesStatus::GetUniqueID ( ) const

inline

    {
        return UniqueID;
    }

IsActive()

bool FQuestObjectivesStatus::IsActive ( ) const

inline

    {
        return (Status == EQuestStatus::Active);
    }

IsFinished()

bool FQuestObjectivesStatus::IsFinished ( const int32 RequiredFailProgress, const int32 RequiredProgress ) const

inline

Returns if the objective progress is hit OR fail progress is hit

    {
        return (FailProgress >= RequiredFailProgress) || (CurrentProgress >= RequiredProgress);
    }

IsSuccessful()

bool FQuestObjectivesStatus::IsSuccessful ( const int32 RequiredFailProgress, const int32 RequiredProgress ) const

inline

    {
        return (CurrentProgress >= RequiredProgress) && (FailProgress < RequiredFailProgress);
    }

ResumeFromElapsedTime()

void FQuestObjectivesStatus::ResumeFromElapsedTime ( )

inline

    {
        if(Status != EQuestStatus::Active){return;}
        StartTimeInSeconds = -ElapsedTime;
    }

SaveObjectiveTime()

float FQuestObjectivesStatus::SaveObjectiveTime ( const UObject * Owner )

inline

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

SetObjectiveNotYetStarted()

void FQuestObjectivesStatus::SetObjectiveNotYetStarted ( )

inline

    {
        Status = EQuestStatus::NotStarted;
    }

SetUniqueID()

void FQuestObjectivesStatus::SetUniqueID ( const int32 NewUID )

inline

    {
        UniqueID = NewUID;
    }

StartObjective()

void FQuestObjectivesStatus::StartObjective ( const UObject * Owner )

inline

    {
        if(GetIsStarted() == false)
        {
            Status = EQuestStatus::Active;
            // bInProgress = true; 
            if(const UWorld* World = GEngine->GetWorldFromContextObject(Owner, EGetWorldErrorMode::LogAndReturnNull))
            {
                StartTimeInSeconds = World->GetTimeSeconds();
            }
        }
        // 
        else
        {
            
        }
    }

Member Data Documentation

CurrentProgress

int32 FQuestObjectivesStatus::CurrentProgress = 0

protected

ElapsedTime

float FQuestObjectivesStatus::ElapsedTime = -1.0f

protected

FailProgress

int32 FQuestObjectivesStatus::FailProgress = 0

protected

StartTimeInSeconds

float FQuestObjectivesStatus::StartTimeInSeconds = -1.0f

protected

Status

EQuestStatus FQuestObjectivesStatus::Status = EQuestStatus::NotStarted

protected

UniqueID

int32 FQuestObjectivesStatus::UniqueID = -1

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