AOpenableDoorActor Class Reference

#include <OpenableDoorActor.h>

Inheritance diagram for AOpenableDoorActor:

Public Member Functions
	AOpenableDoorActor ()
virtual void	OpenDoor (const bool bOpen)
virtual void	DisableDoor (const bool bDisable=true)
virtual void	SetStatusMaterial (UPrimitiveComponent *StatusComponent)
bool	GetIsDoorOpen () const
bool	GetIsDoorMoving () const
void	OnDoorOpened ()
void	OnDoorClosed ()
void	OnDoorOpenedComplete ()
void	OnDoorClosedComplete ()
void	OnDoorLocked (const bool bValue)
void	SetDoorLocked (const bool bValue)
bool	GetIsDoorLocked () const
Public Member Functions inherited from AInteractableActor
	AInteractableActor ()
virtual void	ReceiveStartFocus (AActor *Caller)
virtual void	ReceiveEndFocus (AActor *Caller)
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)

Public Attributes
FOnDoorOpened	OnDoorOpenedDelegate
int32	Index = 0

Protected Member Functions
virtual void	BeginPlay () override
virtual void	OnConstruction (const FTransform &Transform) override
virtual void	ReceiveOnInteract (AActor *Caller, const EInteractionType InteractionType) override
virtual void	ReceiveToggleSwitch (AActor *Caller, const bool bOn) override
virtual void	OpenDoorInstantly ()
virtual void	OpenDoorInstantly (const bool bOpen)
void	OnDoorOpenReplicated ()
void	OnLockedReplicated ()
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
USceneComponent *	RootSceneComponent
UStaticMeshComponent *	MainDoorComponent
class UBoxComponent *	BoxComponent
bool	bHasSwitch = false
bool	bIsAutomatic = true
bool	bStartOpen = false
UMaterialInstance *	StatusMaterial = nullptr
UMaterialInstanceDynamic *	DynamicMaterial = nullptr
FLinearColor	LockedColor = FLinearColor::Red
FLinearColor	UnlockedColor = FLinearColor::Green
FLinearColor	BrokenColor = FLinearColor::Yellow
FName	MaterialParamName = "Color"
bool	bEaseIn = false
bool	bEaseOut = false
float	TimeToOpen = 1.0f
USoundBase *	DoorOpenSound = nullptr
bool	bPlayingSound = false
bool	bLockable = false
bool	bLocked = false
FVector	TargetLocation
FRotator	TargetRotation
bool	bDoorBroken = false
bool	bDoorOpen = false
bool	bDoorMoving = false
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	OnBoxBeginOverlap (UPrimitiveComponent *OverlappedComponent, AActor *OtherActor, UPrimitiveComponent *OtherComponent, int32 OtherBodyIndex, bool bFromSweep, const FHitResult &HitResult)
void	OnBoxEndOverlap (UPrimitiveComponent *OverlappedComponent, AActor *OtherActor, UPrimitiveComponent *OtherComponent, int32 OtherBodyIndex)
void	OnMainDoorOpened ()
void	OnMainDoorClosed ()
void	OpenMainDoor ()
void	CloseMainDoor ()
void	MoveDoor (const bool bOpen)
FLinearColor	GetStatusColor () const
void	UpdateStatusMaterial () const

Private Attributes
FVector	MainDoorStartLocation
FRotator	MainDoorStartRotation
FTimerHandle	RetryMainDoorOpen
FTimerHandle	RetryMainDoorClose

Constructor & Destructor Documentation

AOpenableDoorActor()

AOpenableDoorActor::AOpenableDoorActor

(

)

{
    RootSceneComponent = CreateDefaultSubobject<USceneComponent>("Root Component");
    SetRootComponent(RootSceneComponent);
 
    MainDoorComponent = CreateDefaultSubobject<UStaticMeshComponent>("Main Door");
    MainDoorComponent->SetupAttachment(RootComponent);
    
    BoxComponent = CreateDefaultSubobject<UBoxComponent>("Box Collision");
    BoxComponent->SetupAttachment(RootComponent);
    
    BoxComponent->OnComponentBeginOverlap.AddDynamic(this, &AOpenableDoorActor::OnBoxBeginOverlap);
    BoxComponent->OnComponentEndOverlap.AddDynamic(this, &AOpenableDoorActor::OnBoxEndOverlap);
 
    InteractableActorComponent->InteractionData = FInteractionData(EInteractionType::Open, EAIStimuliType::Door);
    InteractableActorComponent->InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Close, true));
    InteractableActorComponent->InteractionData.InteractionTypes.Add(FInteractionType("Locked", false));
    bReplicates = true;
    InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Open);
}

Member Function Documentation

BeginPlay()

void AOpenableDoorActor::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from AInteractableActor.

Reimplemented in ADoubleDoorActor.

{
    Super::BeginPlay();
    if(InteractableActorComponent == nullptr){return;}
    if(bIsAutomatic || bHasSwitch)
    {
        InteractableActorComponent->InteractionData.SetDefault(EInteractionType::None);
    }
    if(!bIsAutomatic && !bHasSwitch)
    {
        InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Open);
    }
    if(HasAuthority())
    {
        MainDoorStartLocation = MainDoorComponent->GetRelativeLocation();
        MainDoorStartRotation = MainDoorComponent->GetRelativeRotation();
        bDoorOpen = bStartOpen;
        if(bStartOpen)
        {
            OnDoorOpenedDelegate.Broadcast(Index, true);
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Close);
            OpenDoorInstantly();
        }
        if(bLocked)
        {
            InteractableActorComponent->InteractionData.SetOnlyInteractionVisible("Locked");
        }
    }
}

CloseMainDoor()

void AOpenableDoorActor::CloseMainDoor ( )

private

{
    if(bDoorMoving){return;}
    GetWorld()->GetTimerManager().ClearTimer(RetryMainDoorClose);
    MoveDoor(false);
}

DisableDoor()

void AOpenableDoorActor::DisableDoor ( const bool bDisable = true )

virtual

Reimplemented in ADoubleDoorActor.

{
    bDoorBroken = bDisable;
}

GetIsDoorLocked()

bool AOpenableDoorActor::GetIsDoorLocked ( ) const

inline

{return bLocked;};

GetIsDoorMoving()

bool AOpenableDoorActor::GetIsDoorMoving ( ) const

inline

{return bDoorMoving;};

GetIsDoorOpen()

bool AOpenableDoorActor::GetIsDoorOpen ( ) const

inline

{return bDoorOpen;};

GetStatusColor()

FLinearColor AOpenableDoorActor::GetStatusColor ( ) const

private

{
    if(bDoorBroken)
    {
        return BrokenColor;
    }
    if(bLocked)
    {
        return LockedColor;
    }
    return UnlockedColor;
}

MoveDoor()

void AOpenableDoorActor::MoveDoor ( const bool bOpen )

private

{
    FLatentActionInfo Info;
    Info.CallbackTarget = this;
    Info.Linkage = 0;
    if(bOpen)
    {
        Info.ExecutionFunction = FName("OnMainDoorOpened");
        Info.UUID = 123;
        UKismetSystemLibrary::MoveComponentTo(MainDoorComponent, MainDoorStartLocation + TargetLocation,
            MainDoorStartRotation + TargetRotation,
            bEaseOut, bEaseIn, TimeToOpen,
            true, EMoveComponentAction::Move, Info);
    }
    else
    {
        Info.ExecutionFunction = FName("OnMainDoorClosed");
        Info.UUID = 124;
        UKismetSystemLibrary::MoveComponentTo(MainDoorComponent, MainDoorStartLocation, MainDoorStartRotation,
            bEaseOut, bEaseIn, TimeToOpen,
            true, EMoveComponentAction::Move, Info);
    }
}

OnBoxBeginOverlap()

void AOpenableDoorActor::OnBoxBeginOverlap ( UPrimitiveComponent * OverlappedComponent, AActor * OtherActor, UPrimitiveComponent * OtherComponent, int32 OtherBodyIndex, bool bFromSweep, const FHitResult & HitResult )

private

{
    if(!bIsAutomatic){return;}
    if(OtherActor == this){return;}
    OpenDoor(true);
}

OnBoxEndOverlap()

void AOpenableDoorActor::OnBoxEndOverlap ( UPrimitiveComponent * OverlappedComponent, AActor * OtherActor, UPrimitiveComponent * OtherComponent, int32 OtherBodyIndex )

private

{
    if(!bIsAutomatic){return;}
    if(OtherActor == this){return;}
    OpenDoor(false);
}

OnConstruction()

void AOpenableDoorActor::OnConstruction ( const FTransform & Transform )

overrideprotectedvirtual

Reimplemented in ADoubleDoorActor.

{
    Super::OnConstruction(Transform);
    if(MainDoorComponent == nullptr){return;}
    if(bReplicates != MainDoorComponent->GetIsReplicated())
    {
        MainDoorComponent->SetIsReplicated(bReplicates);
    }
}

OnDoorClosed()

void AOpenableDoorActor::OnDoorClosed

(

)

OnDoorClosedComplete()

void AOpenableDoorActor::OnDoorClosedComplete

(

)

OnDoorLocked()

void AOpenableDoorActor::OnDoorLocked

(

const bool

bValue

)

OnDoorOpened()

void AOpenableDoorActor::OnDoorOpened

(

)

OnDoorOpenedComplete()

void AOpenableDoorActor::OnDoorOpenedComplete

(

)

OnDoorOpenReplicated()

void AOpenableDoorActor::OnDoorOpenReplicated ( )

protected

{
    //- Need to check if the Door is in the correct location //
    OpenDoorInstantly(bDoorOpen);
}

OnLockedReplicated()

void AOpenableDoorActor::OnLockedReplicated ( )

protected

{
    if(InteractableActorComponent == nullptr){return;}
    UpdateStatusMaterial();
    if(bLocked)
    {
        InteractableActorComponent->InteractionData.SetOnlyInteractionVisible("Locked");
    }
    else
    {
        if(bDoorOpen)
        {
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Open);
        }
        else
        {
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Close);
        }
    }
}

OnMainDoorClosed()

void AOpenableDoorActor::OnMainDoorClosed ( )

private

{
    if(bDebuggingMode)
    {
        UE_LOG(LogDoors,Warning,TEXT("Door Closed: %s"), *GetHumanReadableName());
    }
    if(HasAuthority())
    {
        bDoorOpen = false;
    }
    bDoorMoving = false;
    bPlayingSound = false;
    OnDoorClosedComplete();
}

OnMainDoorOpened()

void AOpenableDoorActor::OnMainDoorOpened ( )

private

{
    if(bDebuggingMode)
    {
        UE_LOG(LogDoors,Warning,TEXT("Door opened: %s"), *GetHumanReadableName());
    }
    if(HasAuthority())
    {
        bDoorOpen = true;
    }
    bDoorMoving = false;
    bPlayingSound = false;
    OnDoorOpenedComplete();
}

OpenDoor()

void AOpenableDoorActor::OpenDoor ( const bool bOpen )

virtual

Reimplemented in ADoubleDoorActor.

{
    //- Open Doors  //
    if(HasAuthority() == false){return;}
    if(bDoorBroken){return;}
    if(bOpen)
    {
        if(bDoorMoving)
        {
            GetWorld()->GetTimerManager().SetTimer(RetryMainDoorOpen, this,  &AOpenableDoorActor::OpenMainDoor, 0.55f, true, 0.25f);
        }
        else
        {
            bDoorMoving = true;
            MoveDoor(true);
        }
    }
    //- Close doors //
    else
    {
        if(bDoorMoving)
        {
            GetWorld()->GetTimerManager().SetTimer(RetryMainDoorClose, this,  &AOpenableDoorActor::CloseMainDoor, 0.55f, true, 0.25f);
        }
        else
        {
            bDoorMoving = true;
            MoveDoor(false);
        }
    }
}

OpenDoorInstantly() [1/2]

void AOpenableDoorActor::OpenDoorInstantly ( )

protectedvirtual

Reimplemented in ADoubleDoorActor.

{
    FLatentActionInfo Info;
    Info.CallbackTarget = this;
    Info.Linkage = 0;
    Info.ExecutionFunction = FName("OnMainDoorOpened");
    Info.UUID = 123;
    UKismetSystemLibrary::MoveComponentTo(MainDoorComponent, MainDoorStartLocation + TargetLocation,
        MainDoorStartRotation + TargetRotation,
        bEaseOut, bEaseIn, 0.01f,
        true, EMoveComponentAction::Move, Info);
}

OpenDoorInstantly() [2/2]

void AOpenableDoorActor::OpenDoorInstantly ( const bool bOpen )

protectedvirtual

{
    if(bOpen)
    {
        OpenDoorInstantly();
        return;
    }
    FLatentActionInfo Info;
    Info.CallbackTarget = this;
    Info.Linkage = 0;
    Info.ExecutionFunction = FName("OnMainDoorClosed");
    Info.UUID = 124;
    UKismetSystemLibrary::MoveComponentTo(MainDoorComponent, MainDoorStartLocation, MainDoorStartRotation,
        bEaseOut, bEaseIn, TimeToOpen,
        true, EMoveComponentAction::Move, Info);
}

OpenMainDoor()

void AOpenableDoorActor::OpenMainDoor ( )

private

{
    if(bDoorMoving){return;}
    GetWorld()->GetTimerManager().ClearTimer(RetryMainDoorOpen);
    MoveDoor(true);
}

ReceiveOnInteract()

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

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    if(InteractableActorComponent == nullptr){return;}
    if(bLocked){return;}
    Super::ReceiveOnInteract(Caller, InteractionType);
    if(!bHasSwitch && !bIsAutomatic)
    {
        OpenDoor(!bDoorOpen);
        if(bDoorOpen)
        {
            OnDoorOpenedDelegate.Broadcast(Index ,false);
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Open);
            OnDoorClosed();
        }
        else
        {
            OnDoorOpenedDelegate.Broadcast(Index, true);
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Close);
            OnDoorOpened();
        }
    }
    InteractableActorComponent->UpdateInteractionData();
    if(bPlayingSound == false && DoorOpenSound != nullptr)
    {
        UGameplayStatics::PlaySoundAtLocation(this, DoorOpenSound, RootSceneComponent->GetComponentLocation());
        bPlayingSound = true;
    }
}

ReceiveToggleSwitch()

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

overrideprotectedvirtual

Reimplemented from AInteractableActor.

{
    Super::ReceiveToggleSwitch(Caller, bOn);
    if(InteractableActorComponent == nullptr){return;}
    if(bLockable)
    {
        SetDoorLocked(!bOn);
    }
    if(bHasSwitch)
    {
        OpenDoor(bOn);
        if(bOn)
        {
            OnDoorOpenedDelegate.Broadcast(Index, true);
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Close);
            OnDoorOpened();
        }
        else
        {
            OnDoorOpenedDelegate.Broadcast(Index, false);
            InteractableActorComponent->InteractionData.SetDefault(EInteractionType::Open);
            OnDoorClosed();
        }
    }
    InteractableActorComponent->UpdateInteractionData();
    UpdateStatusMaterial(); 
}

SetDoorLocked()

void AOpenableDoorActor::SetDoorLocked

(

const bool

bValue

)

{
    bLocked = bValue;
    UpdateStatusMaterial();
    OnLockedReplicated();
    OnDoorLocked(bLocked);
}

SetStatusMaterial()

void AOpenableDoorActor::SetStatusMaterial ( UPrimitiveComponent * StatusComponent )

virtual

{
    if(StatusComponent == nullptr || StatusMaterial == nullptr){return;}
    if(DynamicMaterial == nullptr)
    {
        DynamicMaterial = StatusComponent->CreateDynamicMaterialInstance(0, StatusMaterial);
    }
    else
    {
        StatusComponent->SetMaterial(0, DynamicMaterial);
    }
    UpdateStatusMaterial();
}

UpdateStatusMaterial()

void AOpenableDoorActor::UpdateStatusMaterial ( ) const

private

{
    if(DynamicMaterial != nullptr)
    {
        DynamicMaterial->SetVectorParameterValue(MaterialParamName, GetStatusColor());
    }
}

Member Data Documentation

bDoorBroken

bool AOpenableDoorActor::bDoorBroken = false

protected

bDoorMoving

bool AOpenableDoorActor::bDoorMoving = false

protected

bDoorOpen

bool AOpenableDoorActor::bDoorOpen = false

protected

bEaseIn

bool AOpenableDoorActor::bEaseIn = false

protected

bEaseOut

bool AOpenableDoorActor::bEaseOut = false

protected

bHasSwitch

bool AOpenableDoorActor::bHasSwitch = false

protected

bIsAutomatic

bool AOpenableDoorActor::bIsAutomatic = true

protected

bLockable

bool AOpenableDoorActor::bLockable = false

protected

bLocked

bool AOpenableDoorActor::bLocked = false

protected

BoxComponent

class UBoxComponent* AOpenableDoorActor::BoxComponent

protected

bPlayingSound

bool AOpenableDoorActor::bPlayingSound = false

protected

BrokenColor

FLinearColor AOpenableDoorActor::BrokenColor = FLinearColor::Yellow

protected

bStartOpen

bool AOpenableDoorActor::bStartOpen = false

protected

DoorOpenSound

USoundBase* AOpenableDoorActor::DoorOpenSound = nullptr

protected

DynamicMaterial

UMaterialInstanceDynamic* AOpenableDoorActor::DynamicMaterial = nullptr

protected

Index

int32 AOpenableDoorActor::Index = 0

LockedColor

FLinearColor AOpenableDoorActor::LockedColor = FLinearColor::Red

protected

MainDoorComponent

UStaticMeshComponent* AOpenableDoorActor::MainDoorComponent

protected

MainDoorStartLocation

FVector AOpenableDoorActor::MainDoorStartLocation

private

MainDoorStartRotation

FRotator AOpenableDoorActor::MainDoorStartRotation

private

MaterialParamName

FName AOpenableDoorActor::MaterialParamName = "Color"

protected

OnDoorOpenedDelegate

FOnDoorOpened AOpenableDoorActor::OnDoorOpenedDelegate

RetryMainDoorClose

FTimerHandle AOpenableDoorActor::RetryMainDoorClose

private

RetryMainDoorOpen

FTimerHandle AOpenableDoorActor::RetryMainDoorOpen

private

RootSceneComponent

USceneComponent* AOpenableDoorActor::RootSceneComponent

protected

StatusMaterial

UMaterialInstance* AOpenableDoorActor::StatusMaterial = nullptr

protected

TargetLocation

FVector AOpenableDoorActor::TargetLocation

protected

TargetRotation

FRotator AOpenableDoorActor::TargetRotation

protected

TimeToOpen

float AOpenableDoorActor::TimeToOpen = 1.0f

protected

UnlockedColor

FLinearColor AOpenableDoorActor::UnlockedColor = FLinearColor::Green

protected

---

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

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