ARoomActor Class Reference

#include <RoomActor.h>

Inheritance diagram for ARoomActor:

Public Member Functions
	ARoomActor ()

Protected Member Functions
virtual void	BeginPlay () override
bool	GetShouldRoomSpawnDoor (const FRandomStream &Stream) const
bool	GetCanHaveWindow () const
void	HideRoof ()
FRandomStream	GetRandomStream () const
bool	GetIsRandomStreamSet () const
virtual USceneComponent *	GetExitsRootComponent () const override
virtual USceneComponent *	GetOverlapsRootComponent () const override
virtual USceneComponent *	GetAISpawnsRootComponent () const override
virtual USceneComponent *	GetWeaponSpawnsRootComponent () const override
virtual USceneComponent *	GetLootSpawnsRootComponent () const override
virtual USceneComponent *	GetDoorsRootComponent () const override
virtual int32	GetNumOfExits () const override
virtual FBox	GetRoomBounds () const override
virtual EDungeonRoomType	GetRoomType () const override
virtual bool	GetShouldRoomSpawnDoorAtEntry (const FRandomStream &Stream) const override
virtual void	AddAttachedRoom (AActor *Actor) override
virtual void	ToggleAllRoomRoofs (const bool bForceHide) override
virtual void	SetRandomStream (const FRandomStream &Stream) override
virtual void	SetDynamicMaterial (UMaterialInterface *Material) override
virtual void	SetActive (const bool bActive) override
virtual void	SetOptimizationLevel (const int32 Level) override
void	OnOptimizationLevelChanged (const int32 Level, const int32 PreviousLevel)
int32	GetOptimizationLevel () const
virtual void	SetReady () override
void	OnRoomReady ()
bool	GetIsRoomReady () const
virtual void	Activate ()
virtual void	Deactivate ()
void	ToggleLights (const bool bTurnOn) const
void	TogglePhysicsObjects (const bool bSimulatePhysics, const bool bVisible) const
void	TogglePhysicsObjectsSimulation (const bool bSimulatePhysics) const
void	TogglePhysicsObjectsVisibility (const bool bVisible) const
void	ToggleGeometry (const bool bVisible) const
void	ToggleDecorations (const bool bVisible) const
bool	GetCanBeWindow (UStaticMeshComponent *WallMesh) const

Protected Attributes
EDungeonRoomType	RoomType = EDungeonRoomType::Hallway
bool	bShouldDoorSpawn = true
bool	bRandomDoorSpawn = false
float	RandomWeight = 0.5f
bool	bCheckForWindow = false
float	WindowTraceDistance = 2000.0f
USceneComponent *	DefaultRootComponent
USceneComponent *	ExitsRootComponent
USceneComponent *	OverlapsRootComponent
USceneComponent *	AISpawnsRootComponent
USceneComponent *	WeaponSpawnsRootComponent
USceneComponent *	LootSpawnsRootComponent
USceneComponent *	DoorsRootComponent
USceneComponent *	LightsRootComponent
USceneComponent *	GeometryRootComponent
USceneComponent *	WallsRootComponent
USceneComponent *	RoofRootComponent
USceneComponent *	FloorRootComponent
USceneComponent *	DecorationsRootComponent
USceneComponent *	PropsRootComponent
UBoxComponent *	BoundsComponent
bool	bDebuggingMode = false
TArray< ARoomActor * >	AttachedRooms
TArray< AActor * >	DoorActors

Private Member Functions
void	GetLightComponents ()
void	GetPropComponents ()

Private Attributes
bool	bReady = false
bool	bRandomStreamSet = false
FRandomStream	RandomStream
int32	Seed = 0
bool	bShouldHideRoof = false
int32	OptimizationLevel = 0
int32	PreviousOptimizationLevel = 0
TArray< ULightComponent * >	Lights
TArray< UStaticMeshComponent * >	Props

Constructor & Destructor Documentation

ARoomActor()

ARoomActor::ARoomActor

(

)

{
    PrimaryActorTick.bCanEverTick = false;
    DefaultRootComponent = CreateDefaultSubobject<USceneComponent>("Root");
    RootComponent = DefaultRootComponent;
    ExitsRootComponent = CreateDefaultSubobject<USceneComponent>("Exits");
    ExitsRootComponent->SetupAttachment(RootComponent);
    OverlapsRootComponent = CreateDefaultSubobject<USceneComponent>("Overlaps");
    OverlapsRootComponent->SetupAttachment(RootComponent);
    AISpawnsRootComponent = CreateDefaultSubobject<USceneComponent>("AI Spawns");
    AISpawnsRootComponent->SetupAttachment(RootComponent);
    WeaponSpawnsRootComponent = CreateDefaultSubobject<USceneComponent>("Weapon Spawns");
    WeaponSpawnsRootComponent->SetupAttachment(RootComponent);
    LootSpawnsRootComponent = CreateDefaultSubobject<USceneComponent>("Loot Spawns");
    LootSpawnsRootComponent->SetupAttachment(RootComponent);
    DoorsRootComponent = CreateDefaultSubobject<USceneComponent>("Doors");
    DoorsRootComponent->SetupAttachment(RootComponent);
 
 
    GeometryRootComponent = CreateDefaultSubobject<USceneComponent>("Geometry");
    GeometryRootComponent->SetupAttachment(RootComponent);
    WallsRootComponent = CreateDefaultSubobject<USceneComponent>("Walls");
    WallsRootComponent->SetupAttachment(GeometryRootComponent);
    RoofRootComponent = CreateDefaultSubobject<USceneComponent>("Roof");
    RoofRootComponent->SetupAttachment(GeometryRootComponent);
    FloorRootComponent = CreateDefaultSubobject<USceneComponent>("Floors");
    FloorRootComponent->SetupAttachment(GeometryRootComponent);
    DecorationsRootComponent = CreateDefaultSubobject<USceneComponent>("Decorations");
    DecorationsRootComponent->SetupAttachment(GeometryRootComponent);
    PropsRootComponent = CreateDefaultSubobject<USceneComponent>("Props");
    PropsRootComponent->SetupAttachment(GeometryRootComponent);
 
    LightsRootComponent = CreateDefaultSubobject<USceneComponent>("Lights");
    LightsRootComponent->SetupAttachment(RootComponent);
    BoundsComponent = CreateDefaultSubobject<UBoxComponent>("Bounds");
    BoundsComponent->SetupAttachment(RootComponent);
    
    bReplicates = true;
    SetActorTickEnabled(false);
}

Member Function Documentation

Activate()

void ARoomActor::Activate ( )

protectedvirtual

{
    ToggleLights(true);
    TogglePhysicsObjects(true, true);
    ToggleGeometry(true);
    ToggleDecorations(true);
}

AddAttachedRoom()

void ARoomActor::AddAttachedRoom ( AActor * Actor )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::AddAttachedRoom);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    if(Actor == nullptr){return;}
    ARoomActor* RoomActor = Cast<ARoomActor>(Actor);
    if(RoomActor == nullptr){return;}
    AttachedRooms.Add(RoomActor);
}

BeginPlay()

void ARoomActor::BeginPlay ( )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::BeginPlay);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    Super::BeginPlay();
    GetLightComponents();
    GetPropComponents();
    // if(bGetRandomStreamAtBegin && bRandomStreamSet == false)
    // {
    //  const IProceduralGM* ProceduralGM = Cast<IProceduralGM>(UGameplayStatics::GetGameMode(this));
    //  if(ProceduralGM != nullptr)
    //  {
    //      RandomStream = ProceduralGM->GetRandomSeed();
    //      Seed = RandomStream.GetCurrentSeed();
    //  }
    // }
}

Deactivate()

void ARoomActor::Deactivate ( )

protectedvirtual

{
    ToggleLights(false);
    TogglePhysicsObjects(false, false);
    ToggleGeometry(false);
    ToggleDecorations(false);
}

GetAISpawnsRootComponent()

virtual USceneComponent * ARoomActor::GetAISpawnsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return AISpawnsRootComponent;};

GetCanBeWindow()

bool ARoomActor::GetCanBeWindow ( UStaticMeshComponent * WallMesh ) const

protected

{
    WallMesh;
    FVector StartLocation = WallMesh->GetComponentLocation();
    FVector EndLocation = StartLocation + (StartLocation * WindowTraceDistance);
    EDrawDebugTrace::Type DrawDebug = EDrawDebugTrace::None;
    if(bDebuggingMode){DrawDebug = EDrawDebugTrace::ForDuration;}
    TArray<AActor*> ActorsToIgnore;
    FHitResult Hit;
    const bool bHit = UKismetSystemLibrary::LineTraceSingle(this, StartLocation, EndLocation,
        UEngineTypes::ConvertToTraceType(ECC_Visibility), false,
        ActorsToIgnore, DrawDebug, Hit, true);
    if(bHit)
    {
        return false;
    }
    return true;
}

GetCanHaveWindow()

bool ARoomActor::GetCanHaveWindow ( ) const

protected

{
    
    return false;
}

GetDoorsRootComponent()

virtual USceneComponent * ARoomActor::GetDoorsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return DoorsRootComponent;};

GetExitsRootComponent()

virtual USceneComponent * ARoomActor::GetExitsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return ExitsRootComponent;};

GetIsRandomStreamSet()

bool ARoomActor::GetIsRandomStreamSet ( ) const

inlineprotected

{return bRandomStreamSet;};

GetIsRoomReady()

bool ARoomActor::GetIsRoomReady ( ) const

inlineprotected

{return bReady;};

GetLightComponents()

void ARoomActor::GetLightComponents ( )

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::GetLightComponents);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    if(LightsRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::GetLightComponents LightsRootComponent Null"));return;}
    TArray<USceneComponent*> AllChildrenComponents;
    LightsRootComponent->GetChildrenComponents(true, AllChildrenComponents);
    for(const auto ChildComponent : AllChildrenComponents)
    {
        ULightComponent* LightComponent = Cast<ULightComponent>(ChildComponent);
        if(LightComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::GetLightComponents %s is not a Light On %s"), *ChildComponent->GetReadableName(), *GetHumanReadableName());continue;}
        Lights.AddUnique(LightComponent);
    }
}

GetLootSpawnsRootComponent()

virtual USceneComponent * ARoomActor::GetLootSpawnsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return LootSpawnsRootComponent;};

GetNumOfExits()

int32 ARoomActor::GetNumOfExits ( ) const

overrideprotectedvirtual

Implements IDungeonRoom.

{
    return ExitsRootComponent->GetNumChildrenComponents();
}

GetOptimizationLevel()

int32 ARoomActor::GetOptimizationLevel ( ) const

inlineprotected

{return OptimizationLevel;}

GetOverlapsRootComponent()

virtual USceneComponent * ARoomActor::GetOverlapsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return OverlapsRootComponent;};

GetPropComponents()

void ARoomActor::GetPropComponents ( )

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::GetPropComponents);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    if(PropsRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::GetPropComponents PropsRootComponent Null"));return;}
    TArray<USceneComponent*> AllChildrenComponents;
    PropsRootComponent->GetChildrenComponents(true, AllChildrenComponents);
    for(const auto ChildComponent : AllChildrenComponents)
    {
        UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(ChildComponent);
        if(StaticMeshComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::GetPropComponents %s is not a Static Mesh On %s"), *ChildComponent->GetReadableName(), *GetHumanReadableName());continue;}
        Props.AddUnique(StaticMeshComponent);
    }
}

GetRandomStream()

FRandomStream ARoomActor::GetRandomStream ( ) const

inlineprotected

{return RandomStream;};

GetRoomBounds()

FBox ARoomActor::GetRoomBounds ( ) const

overrideprotectedvirtual

Implements IDungeonRoom.

{
    if(BoundsComponent == nullptr){return FBox();}
    return BoundsComponent->Bounds.GetBox();
}

GetRoomType()

virtual EDungeonRoomType ARoomActor::GetRoomType ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return RoomType;};

GetShouldRoomSpawnDoor()

bool ARoomActor::GetShouldRoomSpawnDoor ( const FRandomStream & Stream ) const

protected

GetShouldRoomSpawnDoorAtEntry()

virtual bool ARoomActor::GetShouldRoomSpawnDoorAtEntry ( const FRandomStream & Stream ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return GetShouldRoomSpawnDoor(RandomStream);};

GetWeaponSpawnsRootComponent()

virtual USceneComponent * ARoomActor::GetWeaponSpawnsRootComponent ( ) const

inlineoverrideprotectedvirtual

Implements IDungeonRoom.

{return WeaponSpawnsRootComponent;};

HideRoof()

void ARoomActor::HideRoof ( )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::HideRoof);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    ToggleAllRoomRoofs(true);
}

OnOptimizationLevelChanged()

void ARoomActor::OnOptimizationLevelChanged ( const int32 Level, const int32 PreviousLevel )

protected

OnRoomReady()

void ARoomActor::OnRoomReady ( )

protected

SetActive()

void ARoomActor::SetActive ( const bool bActive )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::SetActive);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    if(bActive)
    {
        Activate();
    }
    else
    {
        Deactivate();
    }
}

SetDynamicMaterial()

void ARoomActor::SetDynamicMaterial ( UMaterialInterface * Material )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::SetDynamicMaterial);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    TArray<USceneComponent*> ChildrenMeshes;
    GeometryRootComponent->GetChildrenComponents(true, ChildrenMeshes);
    for(const auto Child : ChildrenMeshes)
    {
        if(Child == nullptr){continue;}
        UStaticMeshComponent* MeshChild = Cast<UStaticMeshComponent>(Child);
        if(MeshChild == nullptr){continue;}
        const FName MaterialSlotName = MeshChild->GetMaterialSlotNames()[0];
        if(bDebuggingMode){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::SetDynamicMaterial Material Slot Name: %s"), *MaterialSlotName.ToString());}
        MeshChild->SetMaterial(0, Material);
    }
}

SetOptimizationLevel()

void ARoomActor::SetOptimizationLevel ( const int32 Level )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::SetOptimizationLevel);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    PreviousOptimizationLevel = OptimizationLevel;
    OptimizationLevel = Level;
    switch (OptimizationLevel)
    {
    case 0: // Everything on
        ToggleGeometry(true);
        ToggleLights(true);
        TogglePhysicsObjects(true, true);
        ToggleDecorations(true);
        break;
    case 1: // Physics Sim off, Decorations Off
        ToggleGeometry(true);
        ToggleLights(true);
        TogglePhysicsObjects(false, true);
        ToggleDecorations(false);
        break;
    case 2: // Physics Objects gone, Lights Gone 
        ToggleGeometry(true);
        ToggleLights(false);
        TogglePhysicsObjects(false, false);
        ToggleDecorations(false);
        break;
    case 3: // All Geometry gone 
    default:
        ToggleGeometry(false);
        ToggleLights(false);
        TogglePhysicsObjects(false, false);
        ToggleDecorations(false);
        break;
    }
    
    OnOptimizationLevelChanged(OptimizationLevel, PreviousOptimizationLevel);
}

SetRandomStream()

void ARoomActor::SetRandomStream ( const FRandomStream & Stream )

overrideprotectedvirtual

If the room needs access to any random Elements

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::SetRandomStream);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    RandomStream = Stream;
    Seed = RandomStream.GetInitialSeed();
    bRandomStreamSet = true;
}

SetReady()

void ARoomActor::SetReady ( )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    bReady = true;
    OnRoomReady();
    if(bCheckForWindow)
    {
        //GetCanBeWindow()
    }
}

ToggleAllRoomRoofs()

void ARoomActor::ToggleAllRoomRoofs ( const bool bForceHide )

overrideprotectedvirtual

Implements IDungeonRoom.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ARoomActor::ToggleAllRoomRoofs);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Rooms);
    if(RoofRootComponent == nullptr){return;}
    if(bForceHide)
    {
        RoofRootComponent->SetVisibility(false, true);
        bShouldHideRoof = true;
        return;
    }
    const bool bCurrentVisibility = RoofRootComponent->GetVisibleFlag();
    RoofRootComponent->SetVisibility(!bCurrentVisibility, true);
}

ToggleDecorations()

void ARoomActor::ToggleDecorations ( const bool bVisible ) const

protected

{
    if(DecorationsRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::ToggleDecorations DecorationsRootComponent Null"));return;}
    DecorationsRootComponent->SetVisibility(bVisible, true);
}

ToggleGeometry()

void ARoomActor::ToggleGeometry ( const bool bVisible ) const

protected

{
    if(GeometryRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::ToggleGeometry GeometryRootComponent Null"));return;}
    GeometryRootComponent->SetVisibility(bVisible, true);
}

ToggleLights()

void ARoomActor::ToggleLights ( const bool bTurnOn ) const

protected

{
    if(LightsRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::ToggleLights LightsRootComponent Null"));return;}
    LightsRootComponent->SetVisibility(bTurnOn, true);
}

TogglePhysicsObjects()

void ARoomActor::TogglePhysicsObjects ( const bool bSimulatePhysics, const bool bVisible ) const

protected

{
    TogglePhysicsObjectsSimulation(bSimulatePhysics);
    TogglePhysicsObjectsVisibility(bVisible);
}

TogglePhysicsObjectsSimulation()

void ARoomActor::TogglePhysicsObjectsSimulation ( const bool bSimulatePhysics ) const

protected

{
    for(UStaticMeshComponent* Prop : Props)
    {
        if(Prop == nullptr){continue;}
        Prop->SetSimulatePhysics(bSimulatePhysics);
    }
}

TogglePhysicsObjectsVisibility()

void ARoomActor::TogglePhysicsObjectsVisibility ( const bool bVisible ) const

protected

{
    if(PropsRootComponent == nullptr){UE_LOG(LogRoomActor, Warning, TEXT("ARoomActor::TogglePhysicsObjectsVisibility PropsRootComponent Null"));return;}
    PropsRootComponent->SetVisibility(bVisible, true);
}

Member Data Documentation

AISpawnsRootComponent

USceneComponent* ARoomActor::AISpawnsRootComponent

protected

AttachedRooms

TArray<ARoomActor*> ARoomActor::AttachedRooms

protected

bCheckForWindow

bool ARoomActor::bCheckForWindow = false

protected

bDebuggingMode

bool ARoomActor::bDebuggingMode = false

protected

BoundsComponent

UBoxComponent* ARoomActor::BoundsComponent

protected

bRandomDoorSpawn

bool ARoomActor::bRandomDoorSpawn = false

protected

Should it be random if the door is spawned

bRandomStreamSet

bool ARoomActor::bRandomStreamSet = false

private

bReady

bool ARoomActor::bReady = false

private

bShouldDoorSpawn

bool ARoomActor::bShouldDoorSpawn = true

protected

Should a door spawn at the start of this room, Corridors etc.

bShouldHideRoof

bool ARoomActor::bShouldHideRoof = false

private

DecorationsRootComponent

USceneComponent* ARoomActor::DecorationsRootComponent

protected

DefaultRootComponent

USceneComponent* ARoomActor::DefaultRootComponent

protected

DoorActors

TArray<AActor*> ARoomActor::DoorActors

protected

DoorsRootComponent

USceneComponent* ARoomActor::DoorsRootComponent

protected

ExitsRootComponent

USceneComponent* ARoomActor::ExitsRootComponent

protected

FloorRootComponent

USceneComponent* ARoomActor::FloorRootComponent

protected

GeometryRootComponent

USceneComponent* ARoomActor::GeometryRootComponent

protected

Lights

TArray<ULightComponent*> ARoomActor::Lights

private

LightsRootComponent

USceneComponent* ARoomActor::LightsRootComponent

protected

LootSpawnsRootComponent

USceneComponent* ARoomActor::LootSpawnsRootComponent

protected

OptimizationLevel

int32 ARoomActor::OptimizationLevel = 0

private

OverlapsRootComponent

USceneComponent* ARoomActor::OverlapsRootComponent

protected

PreviousOptimizationLevel

int32 ARoomActor::PreviousOptimizationLevel = 0

private

Props

TArray<UStaticMeshComponent*> ARoomActor::Props

private

PropsRootComponent

USceneComponent* ARoomActor::PropsRootComponent

protected

RandomStream

FRandomStream ARoomActor::RandomStream

private

RandomWeight

float ARoomActor::RandomWeight = 0.5f

protected

Range of weight is 0.0 - 1.0 E. g., Weight = .6 return value = True 60% of the time

RoofRootComponent

USceneComponent* ARoomActor::RoofRootComponent

protected

RoomType

EDungeonRoomType ARoomActor::RoomType = EDungeonRoomType::Hallway

protected

Seed

int32 ARoomActor::Seed = 0

private

WallsRootComponent

USceneComponent* ARoomActor::WallsRootComponent

protected

WeaponSpawnsRootComponent

USceneComponent* ARoomActor::WeaponSpawnsRootComponent

protected

WindowTraceDistance

float ARoomActor::WindowTraceDistance = 2000.0f

protected

How far do we trace to check if a window can be placed

---

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

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