ATerminal Class Reference

#include <Terminal.h>

Inheritance diagram for ATerminal:

Public Member Functions
	ATerminal ()
virtual void	ResetTerminal ()
void	LockTerminal (const float LockoutTime)
void	UpdateCaller () const
Public Member Functions inherited from AInteractableSwitch
	AInteractableSwitch ()
virtual void	ReceiveToggleSwitch (AActor *Caller, const bool bOn) override
Public Member Functions inherited from AInteractableActor
	AInteractableActor ()
virtual void	ReceiveOnEndInteract (AActor *Caller)
Public Member Functions inherited from AActorBase
	AActorBase ()
virtual bool	SaveGame () override
virtual bool	LoadGame () override
void	SetGravityEnabledEvent (const bool bValue)

Protected Member Functions
virtual void	BeginPlay () override
virtual void	ReceiveOnInteract (AActor *Caller, const EInteractionType InteractionType) override
virtual void	ReceiveStartFocus (AActor *Caller) override
virtual void	ReceiveEndFocus (AActor *Caller) override
virtual void	ReceiveOnOverlap (AActor *Caller) override
virtual void	ReceiveOnEndOverlap (AActor *Caller) override
Protected Member Functions inherited from AInteractableActor
virtual void	Tick (float DeltaTime) override
virtual void	SetMeshOutline (const bool bValue)
Protected Member Functions inherited from AActorBase
void	LogDebugError (const FString &Message) const
void	LogDebugError (const FString &Message, const int32 Value) const
void	LogDebugError (const FString &Message, const float Value) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugWarning (const FString &Message, const int32 Value) const
void	LogDebugWarning (const FString &Message, const float Value) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const
void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const
void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
UStaticMeshComponent *	MeshComponent
UBoxComponent *	BoxComponent
bool	bInUse = false
AActor *	CurrentCaller
UUserWidget *	HackingWidget = nullptr
bool	bHacked = false
Protected Attributes inherited from AInteractableSwitch
TArray< AActor * >	ActorsControlledBySwitch
Protected Attributes inherited from AInteractableActor
class UInteractableActorComponent *	InteractableActorComponent
class UAudioReactionComponent *	AudioReactionComponent
class UAIPerceptionStimuliSourceComponent *	PerceptionStimuliComponent
Protected Attributes inherited from AActorBase
FString	DisplayName = "Display Name"
bool	bDebuggingMode = false

Private Member Functions
void	SetHacked ()
void	DelayedPress ()

Private Attributes
TSubclassOf< UUserWidget >	HackingWidgetClass
IMiniGame *	MiniGame
FTimerHandle	LockedTimerHandle
FTimerHandle	RoundTimerHandle

Additional Inherited Members
Public Attributes inherited from AInteractableSwitch
bool	bSwitchOn = false

Constructor & Destructor Documentation

ATerminal()

ATerminal::ATerminal

(

)

{
    MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Static Mesh"));
    RootComponent = MeshComponent;
    BoxComponent = CreateDefaultSubobject<UBoxComponent>(TEXT("Box Component"));
    BoxComponent->SetupAttachment(MeshComponent);
    InteractableActorComponent->InteractionData = FInteractionData(EInteractionType::Use, EAIStimuliType::Switch);
    FInteractionType HackType;
    HackType.bAvailable = false;
    HackType.InteractionType = EInteractionType::Hack;
    InteractableActorComponent->InteractionData.InteractionTypes.Add(HackType);
    HackingWidgetClass = UBaseHelpersBPLib::GetDefaultWidgetBPClass("/Interaction/Widgets/MiniGames/WBP_Hacking");
}

Member Function Documentation

BeginPlay()

void ATerminal::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from AInteractableSwitch.

{
    Super::BeginPlay();
 
}

DelayedPress()

void ATerminal::DelayedPress ( )

private

{
    // if(MiniGame == nullptr){LogMissingPointer("MiniGame");return;}
    // const EMiniGameStatus MiniGameStatus = MiniGame->GetResult();
    // IPlayerControllerInterface*  PlayerController = Cast<IPlayerControllerInterface>(CurrentCaller->GetInstigatorController());
    // GetWorld()->GetTimerManager().ClearTimer(RoundTimerHandle);
    // switch (MiniGameStatus) {
    // case InProgress:
    //  GetWorld()->GetTimerManager().SetTimer(RoundTimerHandle, this, &ATerminal::DelayedPress,MiniGame->GetRoundTime());
    //  break;
    // case Passed:
    //  //@TODO could have optional wait time
    //      break;
    // case Complete:
    //  if(PlayerController != nullptr)
    //  {
    //      PlayerController->SetCharacterMode(FGameplayTag(CharacterModeTags::Default));
    //  }
    //  SetHacked();
    //  break;
    // case Failed:
    //  if(PlayerController != nullptr)
    //  {
    //      PlayerController->SetCharacterMode(FGameplayTag(CharacterModeTags::Default));
    //  }
    //  LockTerminal(MiniGame->GetRetryDelay());
    //  break;
    // }
}

LockTerminal()

void ATerminal::LockTerminal

(

const float

LockoutTime

)

{
    if(InteractableActorComponent != nullptr)
    {
        InteractableActorComponent->SetInteractionHidden(EInteractionType::Use, true);
    }
    if(LockoutTime < 0.0f)
    {
        return;
    }
    GetWorld()->GetTimerManager().SetTimer(LockedTimerHandle, this, &ATerminal::ResetTerminal, LockoutTime);
}

ReceiveEndFocus()

void ATerminal::ReceiveEndFocus ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveEndFocus(Caller);
}

ReceiveOnEndOverlap()

void ATerminal::ReceiveOnEndOverlap ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveOnEndOverlap(Caller);
    if(Caller == CurrentCaller)
    {
        ResetTerminal();
    }
}

ReceiveOnInteract()

void ATerminal::ReceiveOnInteract ( AActor * Caller, const EInteractionType InteractionType )

overrideprotectedvirtual

Reimplemented from AInteractableSwitch.

{
    Super::ReceiveOnInteract(Caller, InteractionType);
    if(Caller == nullptr || Caller->GetInstigatorController() == nullptr){return;}
    if(InteractableActorComponent == nullptr){return;}
    // FInteractionType InteractionType;
    // if(UBaseHelpersBPLib::GetInteraction(InteractionType, InteractionData, SelectedInteraction))
    // {
        if(InteractionType == EInteractionType::Hack)
        {
            CurrentCaller = Caller;
            IPlayerControllerInterface* PlayerController = Cast<IPlayerControllerInterface>(CurrentCaller->GetInstigatorController());
            if(PlayerController == nullptr){LogDebugError("Player Controller");return;}
            PlayerController->SetCharacterMode(CharacterModeTags::Talking);
            if(HackingWidgetClass == nullptr){LogDebugError("WidgetClass");return;}
            //@@ TODO we need to have a better way to control the widget, not through this terminal
            
            HackingWidget = CreateWidget(GetWorld(), HackingWidgetClass);
            if(HackingWidget == nullptr){LogDebugError("HackingWidget");return;}
            MiniGame = Cast<IMiniGame>(HackingWidget);
            if(MiniGame == nullptr){LogDebugError("MiniGame Interface");return;}
            HackingWidget->AddToPlayerScreen();
            bInUse = true;
            MiniGame->Start();
            InteractableActorComponent->SetInteractionHidden(EInteractionType::Hack, true);
            InteractableActorComponent->SetInteractionHidden(EInteractionType::Use, false);
            UpdateCaller();
        }
        if(InteractionType == EInteractionType::Use)
        {
            if(MiniGame == nullptr){LogDebugError("MiniGame");return;}
            // MiniGame->GetResult();
            // const EMiniGameStatus MiniGameStatus = MiniGame->Select();
 
            const EMiniGameStatus MiniGameStatus = MiniGame->Select();
            IPlayerControllerInterface* PlayerController = Cast<IPlayerControllerInterface>(CurrentCaller->GetInstigatorController());
            switch (MiniGameStatus) {
            case Ready:
                LogDebugMessage("Terminal Ready");
                break;
            case InProgress:
                LogDebugMessage("Terminal In Progress");
                // if(GetWorld()->GetTimerManager().IsTimerActive(RoundTimerHandle) == false)
                // {
                //  GetWorld()->GetTimerManager().SetTimer(RoundTimerHandle, this, &ATerminal::DelayedPress,MiniGame->GetRoundTime());
                // }
                break;
            case Passed:
                LogDebugMessage("Terminal Passed");
                //@TODO could have optional wait time
                break;
            case Complete:
                LogDebugMessage("Terminal Complete");
                if(PlayerController != nullptr)
                {
                    PlayerController->SetCharacterMode(FGameplayTag(CharacterModeTags::Default));
                }
                SetHacked();
                break;
            case Failed:
                LogDebugMessage("Terminal Failed");
                if(PlayerController != nullptr)
                {
                    PlayerController->SetCharacterMode(FGameplayTag(CharacterModeTags::Default));
                }
                LockTerminal(MiniGame->GetRetryDelay());
                break;
            }
        }
    // }
}

ReceiveOnOverlap()

void ATerminal::ReceiveOnOverlap ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveOnOverlap(Caller);
}

ReceiveStartFocus()

void ATerminal::ReceiveStartFocus ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveStartFocus(Caller);
}

ResetTerminal()

void ATerminal::ResetTerminal ( )

virtual

{
    GetWorld()->GetTimerManager().ClearTimer(LockedTimerHandle);
    if(MiniGame != nullptr)
    {
        MiniGame->Reset();
    }
    MiniGame = nullptr;
    if(HackingWidget != nullptr)
    {
        HackingWidget->RemoveFromParent();
    }
    HackingWidget = nullptr;
    if(InteractableActorComponent != nullptr)
    {
        InteractableActorComponent->SetInteractionHidden(EInteractionType::Hack, false);
    }
    UpdateCaller();
    CurrentCaller = nullptr;
}

SetHacked()

void ATerminal::SetHacked ( )

private

{
    bHacked = true;
    ReceiveToggleSwitch(CurrentCaller, !bSwitchOn);
    if(InteractableActorComponent != nullptr)
    {
        InteractableActorComponent->SetInteractionHidden(EInteractionType::Hack, true);
    }
    UpdateCaller();
    MiniGame = nullptr;
    if(HackingWidget != nullptr)
    {
        HackingWidget->RemoveFromParent();
    }
    HackingWidget = nullptr;
    CurrentCaller = nullptr;
}

UpdateCaller()

void ATerminal::UpdateCaller

(

)

const

{
    if(CurrentCaller == nullptr){return;}
    const IInteractionInterface* InteractableCaller = Cast<IInteractionInterface>(CurrentCaller);
    if(InteractableCaller == nullptr){LogDebugError("InteractableCaller");return;}
    InteractableCaller->InteractionDataUpdated();
}

Member Data Documentation

bHacked

bool ATerminal::bHacked = false

protected

bInUse

bool ATerminal::bInUse = false

protected

BoxComponent

UBoxComponent* ATerminal::BoxComponent

protected

CurrentCaller

AActor* ATerminal::CurrentCaller

protected

HackingWidget

UUserWidget* ATerminal::HackingWidget = nullptr

protected

HackingWidgetClass

TSubclassOf<UUserWidget> ATerminal::HackingWidgetClass

private

LockedTimerHandle

FTimerHandle ATerminal::LockedTimerHandle

private

MeshComponent

UStaticMeshComponent* ATerminal::MeshComponent

protected

MiniGame

IMiniGame* ATerminal::MiniGame

private

RoundTimerHandle

FTimerHandle ATerminal::RoundTimerHandle

private

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/Interaction/Source/Interaction/Public/Actors/Terminal.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/Interaction/Source/Interaction/Private/Actors/Terminal.cpp