UMiniGameWidget Class Reference

#include <MiniGameWidget.h>

Inheritance diagram for UMiniGameWidget:

Public Member Functions
virtual void	Start () override
virtual EMiniGameStatus	Select () override
virtual void	Reset () override
virtual float	GetRetryDelay () const override
virtual float	GetRoundTime () const override
virtual EMiniGameStatus	GetResult () const override
void	SetComplete (const bool bValue)
void	SetResult (const EMiniGameStatus Status)
void	SetIntroComplete ()
bool	GetShouldShowIntro () const
void	StartIntro ()
virtual void	ProgressSelect ()
void	OnProgressSelect ()
virtual bool	StartMiniGame (const int32 Level)
bool	ReceiveStartMiniGame (const int32 Level)
void	StartMiniGameEvent (const int32 Level)
void	MiniGamePassed ()
void	MiniGameComplete (const EMiniGameStatus Status)

Protected Member Functions
virtual void	NativeConstruct () override
virtual void	NativePreConstruct () override
virtual void	RoundOver ()

Protected Attributes
bool	bHasIntro = true
bool	bTimedMiniGame = true
float	RoundTime = 5.0f
int32	Attempts = 3
int32	Levels = 3
bool	bSkippable = false
bool	bCanRetry = false
float	RetryDelay = 5.0f
bool	bComplete = false
bool	bShowIntro = true
bool	bIntroPlaying = false
bool	bWaiting = false
TEnumAsByte< EMiniGameStatus >	Result = EMiniGameStatus::InProgress
int32	CurrentLevel = 1
int32	CurrentAttempt = 1

Private Attributes
FTimerHandle	RoundTimerHandle

Member Function Documentation

GetResult()

virtual EMiniGameStatus UMiniGameWidget::GetResult ( ) const

inlineoverridevirtual

Implements IMiniGame.

{return Result;};

GetRetryDelay()

virtual float UMiniGameWidget::GetRetryDelay ( ) const

inlineoverridevirtual

Implements IMiniGame.

{if(bCanRetry){return RetryDelay;}return -1.0f;}; 

GetRoundTime()

virtual float UMiniGameWidget::GetRoundTime ( ) const

inlineoverridevirtual

Implements IMiniGame.

{return RoundTime;};

GetShouldShowIntro()

bool UMiniGameWidget::GetShouldShowIntro

(

)

const

{
    if(bHasIntro == false)
    {
        return false;
    }
    if(bIntroPlaying)
    {
        return false;
    }
    return bShowIntro;
}

MiniGameComplete()

void UMiniGameWidget::MiniGameComplete

(

const EMiniGameStatus

Status

)

MiniGamePassed()

void UMiniGameWidget::MiniGamePassed

(

)

NativeConstruct()

void UMiniGameWidget::NativeConstruct ( )

overrideprotectedvirtual

Reimplemented in UHackingWidget, and UTimedMiniGameWidget.

{
    Super::NativeConstruct();
    Reset();
}

NativePreConstruct()

void UMiniGameWidget::NativePreConstruct ( )

overrideprotectedvirtual

Reimplemented in UHackingWidget, and UTimedMiniGameWidget.

{
    Super::NativePreConstruct();
    Reset();
}

OnProgressSelect()

void UMiniGameWidget::OnProgressSelect

(

)

ProgressSelect()

void UMiniGameWidget::ProgressSelect ( )

virtual

Reimplemented in UHackingWidget.

{
    OnProgressSelect();
}

ReceiveStartMiniGame()

bool UMiniGameWidget::ReceiveStartMiniGame

(

const int32

Level

)

Reset()

void UMiniGameWidget::Reset ( )

overridevirtual

Implements IMiniGame.

Reimplemented in UHackingWidget, and UTimedMiniGameWidget.

{
    bShowIntro = true;
    bComplete = false;
    CurrentLevel = 1;
    CurrentAttempt = 1;
    if(bHasIntro == false)
    {
        bShowIntro = false;
    }
    Result = InProgress;
}

RoundOver()

void UMiniGameWidget::RoundOver ( )

protectedvirtual

{
    CurrentLevel++;
    if(CurrentAttempt > Attempts)
    {
        MiniGameComplete(Failed);
        SetResult(Failed);
    }
    if(CurrentLevel < Levels)
    {
        MiniGameComplete(Passed);
        SetResult(Passed);
    }
    MiniGameComplete(Complete);
    SetResult(Complete);
}

Select()

EMiniGameStatus UMiniGameWidget::Select ( )

overridevirtual

Implements IMiniGame.

Reimplemented in UTimedMiniGameWidget.

{
    bool bPassed = Result == Passed;
    if(bTimedMiniGame)
    {
        if(Result == Ready)
        {
            bWaiting = true;
            StartMiniGame(CurrentLevel);
            Result = InProgress;
            return Result;
        }
        if(bWaiting)
        {
            ProgressSelect();
            return InProgress;
        }
    }
    else
    {
        bPassed = StartMiniGame(CurrentLevel);
    }
    if(bPassed)
    {
        CurrentLevel++;
        MiniGamePassed();
    }
    else
    {
        CurrentAttempt++;
    }
    if(CurrentAttempt > Attempts)
    {
        MiniGameComplete(Failed);
        return Failed;
    }
    if(CurrentLevel < Levels)
    {
        MiniGameComplete(Passed);
        return Passed;
    }
    MiniGameComplete(Complete);
    return Complete;
}

SetComplete()

void UMiniGameWidget::SetComplete

(

const bool

bValue

)

{
    bComplete = bValue;
}

SetIntroComplete()

void UMiniGameWidget::SetIntroComplete

(

)

{
    bIntroPlaying = false;
}

SetResult()

void UMiniGameWidget::SetResult

(

const EMiniGameStatus

Status

)

{
    Result = Status;
    bWaiting = false;
}

Start()

void UMiniGameWidget::Start ( )

overridevirtual

Implements IMiniGame.

{
    if(GetShouldShowIntro())
    {
        bIntroPlaying = true;
        StartIntro();
        SetResult(InProgress);
    }
}

StartIntro()

void UMiniGameWidget::StartIntro

(

)

StartMiniGame()

bool UMiniGameWidget::StartMiniGame ( const int32 Level )

virtual

Reimplemented in UHackingWidget, and UTimedMiniGameWidget.

{
    if(bTimedMiniGame)
    {
        GetWorld()->GetTimerManager().SetTimer(RoundTimerHandle, this, &UMiniGameWidget::RoundOver, RoundTime);
    }
    
    StartMiniGameEvent(Level);
    return ReceiveStartMiniGame(Level);
}

StartMiniGameEvent()

void UMiniGameWidget::StartMiniGameEvent

(

const int32

Level

)

Member Data Documentation

Attempts

int32 UMiniGameWidget::Attempts = 3

protected

bCanRetry

bool UMiniGameWidget::bCanRetry = false

protected

bComplete

bool UMiniGameWidget::bComplete = false

protected

bHasIntro

bool UMiniGameWidget::bHasIntro = true

protected

bIntroPlaying

bool UMiniGameWidget::bIntroPlaying = false

protected

bShowIntro

bool UMiniGameWidget::bShowIntro = true

protected

bSkippable

bool UMiniGameWidget::bSkippable = false

protected

bTimedMiniGame

bool UMiniGameWidget::bTimedMiniGame = true

protected

bWaiting

bool UMiniGameWidget::bWaiting = false

protected

CurrentAttempt

int32 UMiniGameWidget::CurrentAttempt = 1

protected

CurrentLevel

int32 UMiniGameWidget::CurrentLevel = 1

protected

Levels

int32 UMiniGameWidget::Levels = 3

protected

Result

TEnumAsByte<EMiniGameStatus> UMiniGameWidget::Result = EMiniGameStatus::InProgress

protected

RetryDelay

float UMiniGameWidget::RetryDelay = 5.0f

protected

RoundTime

float UMiniGameWidget::RoundTime = 5.0f

protected

RoundTimerHandle

FTimerHandle UMiniGameWidget::RoundTimerHandle

private

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/Interaction/Source/Interaction/Public/Widgets/MiniGames/MiniGameWidget.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/Interaction/Source/Interaction/Private/Widgets/MiniGames/MiniGameWidget.cpp