AInteractableBox Class Reference

#include <InteractableBox.h>

Inheritance diagram for AInteractableBox:

Public Member Functions
	AInteractableBox ()
void	OnBoxOpened ()
void	Server_CalculateRandomNumber ()
void	Server_OpenBox (const FVector &Force)
Public Member Functions inherited from AInteractableActor
	AInteractableActor ()
virtual void	ReceiveOnEndInteract (AActor *Caller)
virtual void	ReceiveOnOverlap (AActor *Caller)
virtual void	ReceiveOnEndOverlap (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	ReceiveToggleSwitch (AActor *Caller, const bool bOn) override
virtual void	ReceiveStartFocus (AActor *Caller) override
virtual void	ReceiveEndFocus (AActor *Caller) override
void	SetMesh ()
void	OpenBox (const FVector &Force)
bool	IsValid () const
FVector	CalculateImpulse (const AActor *Caller) const
void	OnMeshTypeReplicated ()
void	OnOpenedReplicated ()
void	OnBoxDataReplicated ()
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 *	BaseMeshComponent
UStaticMeshComponent *	LidMeshComponent
class USphereComponent *	SphereComponent
bool	bOpened = false
bool	bUseBoxData = false
bool	bUseRandom = false
int32	MeshType = 0
TArray< UStaticMesh * >	BaseMeshes
TArray< UStaticMesh * >	LidMeshes
int32	Credits = 0
int32	XP = 0
float	DirectionalForce = 5200.0f
float	UpForce = 12500.0f
class USoundBase *	OpenSound
FBoxReplicationData	BoxReplicationData
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	DestroyLid ()

Private Attributes
bool	bLidDestroyed = false
float	LidDestroyTime = 20.0f
FTimerHandle	LidDestroyTimerHandle

Constructor & Destructor Documentation

AInteractableBox()

AInteractableBox::AInteractableBox ( )

explicit

{
    PrimaryActorTick.bCanEverTick = false;
    BaseMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>("Base Mesh");
    RootComponent = BaseMeshComponent;
    BaseMeshComponent->SetSimulatePhysics(true);
    BaseMeshComponent->BodyInstance.bNotifyRigidBodyCollision = true;
    LidMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>("Lid Mesh");
    LidMeshComponent->SetupAttachment(RootComponent);
    SphereComponent = CreateDefaultSubobject<USphereComponent>("Sphere");
    SphereComponent->SetupAttachment(RootComponent);
    bReplicates = true;
    SetReplicateMovement(true);
    FInteractionType OpenInteraction = FInteractionType(EInteractionType::Open);
    OpenInteraction.bHold = true;
    InteractableActorComponent->InteractionData = FInteractionData(OpenInteraction, EAIStimuliType::Item);
    InteractableActorComponent->bLoseFocusAfterInteract = true;
}

Member Function Documentation

BeginPlay()

void AInteractableBox::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::BeginPlay();
    if(bUseRandom)
    {
        if(HasAuthority())
        {
            Server_CalculateRandomNumber();
            OnMeshTypeReplicated();
            return;
        }
    }
    OnMeshTypeReplicated();
}

CalculateImpulse()

FVector AInteractableBox::CalculateImpulse ( const AActor * Caller ) const

protected

{
    if(Caller == nullptr){return FVector::ZeroVector;}
    const FRotator LookAtRotation = UKismetMathLibrary::FindLookAtRotation(Caller->GetActorLocation(), GetActorLocation());
    const FVector ForwardVector = LookAtRotation.Vector();
    return (ForwardVector * DirectionalForce) + (FVector::UpVector * UpForce);
}

DestroyLid()

void AInteractableBox::DestroyLid ( )

private

{
    if(LidMeshComponent != nullptr)
    {
        bLidDestroyed = true;
        LidMeshComponent->DestroyComponent();
        LidMeshComponent = nullptr;
    }
}

IsValid()

bool AInteractableBox::IsValid ( ) const

protected

{
    if(BaseMeshes.IsEmpty()){return false;}
    if(LidMeshes.IsEmpty()){return false;}
    if(BaseMeshComponent == nullptr){return false;}
    if(LidMeshComponent == nullptr && bLidDestroyed == false){return false;}
    if(BaseMeshes.IsValidIndex(MeshType) == false){return false;}
    if(LidMeshes.IsValidIndex(MeshType) == false){return false;}
    return true;
}

OnBoxDataReplicated()

void AInteractableBox::OnBoxDataReplicated ( )

protected

{
    // FInteractionType InteractionType;
    // if(UBaseHelpersBPLib::GetInteraction(InteractionType, GetInteractionData(), BoxReplicationData.SelectedInteraction))
    // {
        if(BoxReplicationData.SelectedInteraction == EInteractionType::Open)
        {
            if(HasAuthority())
            {
                OpenBox(CalculateImpulse(BoxReplicationData.Caller));
            }
            InteractableActorComponent->SetInteractionHidden(EInteractionType::Open, true);
            IInteractionInterface* BaseCaller = Cast<IInteractionInterface>(BoxReplicationData.Caller);
            if(BaseCaller != nullptr)
            {
                BaseCaller->InteractionDataUpdated();
            }
            OnBoxOpened();
        }
    // }
}

OnBoxOpened()

void AInteractableBox::OnBoxOpened

(

)

OnMeshTypeReplicated()

void AInteractableBox::OnMeshTypeReplicated ( )

protected

{
    if(IsValid() == false)
    {
        UE_LOG(LogTemp, Warning, TEXT("AInteractableBox::OnMeshTypeReplicated Invalid"));
        Destroy();
        return;
    }
    SetMesh();
}

OnOpenedReplicated()

void AInteractableBox::OnOpenedReplicated ( )

protected

{
    OpenBox(BoxReplicationData.Impulse);
}

OpenBox()

void AInteractableBox::OpenBox ( const FVector & Force )

protected

{
    UE_LOG(LogTemp, Warning, TEXT("OPEN BOX"));
    if(IsValid() == false){return;}
    bOpened = true;
    LidMeshComponent->SetRenderCustomDepth(false);
    LidMeshComponent->SetIsReplicated(true);
    LidMeshComponent->SetSimulatePhysics(true);
    LidMeshComponent->AddImpulse(Force);
    InteractableActorComponent->SetInteractionHidden(EInteractionType::Open, true);
    if(BaseMeshComponent != nullptr && OpenSound != nullptr)
    {
        UGameplayStatics::PlaySoundAtLocation(this, OpenSound, BaseMeshComponent->GetComponentLocation());
    }
    if(SphereComponent != nullptr)
    {
        SphereComponent->DestroyComponent();
    }
    GetWorld()->GetTimerManager().SetTimer(LidDestroyTimerHandle,  this, &AInteractableBox::DestroyLid, LidDestroyTime);
}

ReceiveEndFocus()

void AInteractableBox::ReceiveEndFocus ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveEndFocus(Caller);
    if(IsValid() == false){return;}
    BaseMeshComponent->SetRenderCustomDepth(false);
    if(bOpened == false)
    {
        LidMeshComponent->SetRenderCustomDepth(false);
    }
}

ReceiveOnInteract()

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

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveOnInteract(Caller, InteractionType);
    SetOwner(Caller);
    // if(bUseBoxData)
    // {
    //  BoxReplicationData = FBoxReplicationData(Caller, InteractionType, CalculateImpulse(Caller));
    //  OnBoxDataReplicated();
    //  return;
    // }
    // FInteractionType InteractionType;
    // if(UBaseHelpersBPLib::GetInteraction(InteractionType, GetInteractionData(), InteractionType))
    // {
        if(InteractionType == EInteractionType::Open)
        {
            // Server_OpenBox(CalculateImpulse(Caller));
            if(HasAuthority())
            {
                OpenBox(CalculateImpulse(Caller));
            }
            else
            {
                Server_OpenBox(CalculateImpulse(Caller));
            }
            InteractableActorComponent->SetInteractionHidden(EInteractionType::Open, true);
            const IInteractionInterface* BaseCaller = Cast<IInteractionInterface>(Caller);
            if(BaseCaller != nullptr)
            {
                BaseCaller->InteractionDataUpdated();
            }
            OnBoxOpened();
        }
    // }    
}

ReceiveStartFocus()

void AInteractableBox::ReceiveStartFocus ( AActor * Caller )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveStartFocus(Caller);
    if(IsValid() == false){return;}
    BaseMeshComponent->SetRenderCustomDepth(true);
    if(bOpened == false)
    {
        LidMeshComponent->SetRenderCustomDepth(true);
    }
}

ReceiveToggleSwitch()

void AInteractableBox::ReceiveToggleSwitch ( AActor * Caller, const bool bOn )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveToggleSwitch(Caller, bOn);
    
}

Server_CalculateRandomNumber()

void AInteractableBox::Server_CalculateRandomNumber

(

)

Server_OpenBox()

void AInteractableBox::Server_OpenBox

(

const FVector &

Force

)

SetMesh()

void AInteractableBox::SetMesh ( )

protected

{
    if(IsValid() == false)
    {
        UE_LOG(LogTemp, Warning, TEXT("AInteractableBox::SetMesh Invalid"));
        return;
    }
    BaseMeshComponent->SetStaticMesh(BaseMeshes[MeshType]);
    if(bOpened == false)
    {
        LidMeshComponent->SetStaticMesh(LidMeshes[MeshType]);
    }
}

Member Data Documentation

BaseMeshComponent

UStaticMeshComponent* AInteractableBox::BaseMeshComponent

protected

BaseMeshes

TArray<UStaticMesh*> AInteractableBox::BaseMeshes

protected

bLidDestroyed

bool AInteractableBox::bLidDestroyed = false

private

bOpened

bool AInteractableBox::bOpened = false

protected

BoxReplicationData

FBoxReplicationData AInteractableBox::BoxReplicationData

protected

bUseBoxData

bool AInteractableBox::bUseBoxData = false

protected

bUseRandom

bool AInteractableBox::bUseRandom = false

protected

Credits

int32 AInteractableBox::Credits = 0

protected

DirectionalForce

float AInteractableBox::DirectionalForce = 5200.0f

protected

How much force in the direction from the Character Interacting

LidDestroyTime

float AInteractableBox::LidDestroyTime = 20.0f

private

How Long After opened does the lid last

LidDestroyTimerHandle

FTimerHandle AInteractableBox::LidDestroyTimerHandle

private

LidMeshComponent

UStaticMeshComponent* AInteractableBox::LidMeshComponent

protected

LidMeshes

TArray<UStaticMesh*> AInteractableBox::LidMeshes

protected

MeshType

int32 AInteractableBox::MeshType = 0

protected

OpenSound

class USoundBase* AInteractableBox::OpenSound

protected

SphereComponent

class USphereComponent* AInteractableBox::SphereComponent

protected

UpForce

float AInteractableBox::UpForce = 12500.0f

protected

How much force UP when opened

XP

int32 AInteractableBox::XP = 0

protected

---

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

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