AProceduralDungeonBuilder Class Reference

#include <ProceduralDungeonBuilder.h>

Inheritance diagram for AProceduralDungeonBuilder:

Public Member Functions
	AProceduralDungeonBuilder ()

Protected Member Functions
virtual void	BeginPlay () override
virtual void	OnConstruction (const FTransform &Transform) override
void	CreateDungeonInEditor ()
void	DestroyDungeonInEditor ()
void	HideAllRoomRoofs ()
void	CreateDungeon ()
void	OnDungeonComplete (const int32 NumOfRooms)
void	OnDoorsSpawned (const int32 NumOfDoors)
void	OnAISpawned (const int32 NumOfPawns)
void	Multicast_DungeonComplete (int32 NumRooms)
FRandomStream &	GetRandomStream () const
bool	IsOverlapping (const FBox &CandidateBox)
bool	GetIsValidRoomConnection (const EDungeonRoomType ParentType, const EDungeonRoomType CandidateType) const
UMaterialInstanceDynamic *	GetMaterialInstance () const
void	SpawnStartingRoom ()
void	SpawnAllRooms ()
void	CreateDynamicMaterials ()
void	SpawnNextRoom ()
void	ContinueSpawnNextRoom ()
void	SetInitialValues ()
void	SpawnSpecialRoom ()
void	ScheduleSpawn (const FTimerDelegate::TMethodPtr< AProceduralDungeonBuilder > SpawnMethod)
void	AddAISpawnPointsToList (const USceneComponent *AIRootComponent)
void	CheckExitsForJoiningRooms ()
void	CloseHoles ()
void	SpawnDoorAtLocation ()
void	SpawnAIAtLocation ()
void	SetRoomsReady () const
void	DungeonComplete ()

Protected Attributes
FDungeonSpawns	RoomTypes
int32	StartingRoomNumber = 0
int32	NumberOfRoomsToSpawn = 50
bool	bUseRandomNumberOfRooms = false
int32	MinNumberOfRoomsToSpawn = 2
TSubclassOf< AActor >	RoomChecker = nullptr
bool	bApplyDynamicMaterial = true
UMaterialInterface *	RoomMaterial = nullptr
class UDataTable *	MaterialDataTable = nullptr
bool	bCheckRoomExitCount = false
int32	CheckRoomExitCountMin = 3
bool	bCheckRoomTypes = true
bool	bGetClosestExit = false
bool	bRandomGetClosestExit = false
float	RandomClosesExitWeight = 0.5f
bool	bUseRandomSeed = true
int32	Seed = 0
TSubclassOf< AActor >	WallFill = nullptr
bool	bFillWithDeadEndRooms = false
bool	bSpawnDoors = true
bool	bLimitDoors = true
int32	DoorLimit = 10
TArray< TSubclassOf< AActor > >	DoorTypes
TArray< int32 >	DoorWeights
bool	bCreateOnBeginPlay = true
bool	bUseGameModeStream = true
bool	bCheckForJoiningRooms = true
int32	AIToSpawn = 10
TArray< TSubclassOf< AActor > >	AITypes
bool	bComplete = false
TArray< USceneComponent * >	AvailableExits
TArray< USceneComponent * >	DoorLocations
TArray< USceneComponent * >	ExitsToFill
USceneComponent *	SelectedExit = nullptr
AActor *	LastSpawnedRoom = nullptr
TArray< UPrimitiveComponent * >	OverlappedComponents
TArray< AActor * >	DungeonActors
TArray< TSubclassOf< AActor > >	SpecialRoomTypeClasses
UMaterialInstanceDynamic *	RoomMaterialInstance = nullptr
TArray< FBox >	PlacedRoomBounds
USceneComponent *	SelectedAISpawn = nullptr
USceneComponent *	SelectedDoorSpawn = nullptr
TArray< USceneComponent * >	AISpawns
bool	bUsingGameModeSteam = false
TArray< USceneComponent * >	AISpawnsSelected
TArray< USceneComponent * >	AISpawnsFailed
TArray< USceneComponent * >	DoorSpawnsSelected
TArray< USceneComponent * >	DoorSpawnsFailed

Private Member Functions
void	OnRoomsComplete ()
void	CheckRoomAttemptsNumber ()
void	SetSeed ()
void	SetNumberOfRooms ()
bool	GetShouldStopSpawningRooms () const
bool	GetShouldSpawnSpecialRoom () const
USceneComponent *	GetNextExit ()
UClass *	GetNewRoomClass () const
UClass *	GetStartingRoomClass ()
UClass *	GetSpecialRoomClass () const
UClass *	GetDeadEndRoomClass () const
TArray< FDungeonSpawnRoom >	GetRoomsOfTypeBP (const TArray< EDungeonRoomType > &FilterTypes, const bool bInverseSelection=false) const
TArray< FDungeonSpawnRoom >	GetRoomsOfType (const TArray< EDungeonRoomType > &FilterTypes, const bool bInverseSelection=false) const
TArray< FDungeonSpawnRoom >	GetRoomsOfType (const EDungeonRoomType FilterType, const bool bInverseSelection=false) const
TArray< FDungeonSpawnRoom >	GetRoomsByExits () const
void	RemoveExitsByDistance (TArray< USceneComponent * > &ExitsA, TArray< USceneComponent * > &ExitsB) const
bool	SetDungeonValues ()
void	LogDebugError (const FString &Message) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const

Private Attributes
FActorSpawnParameters	SpawnParams
int32	RoomsSpawned = 0
int32	AttemptChecker = 0
int32	StartingNumberOfRoomsToSpawn = 0
int32	TotalNumberOfRoomsToSpawn = 0
FDungeonSpawns	StartingRoomTypes
int32	StartingAIToSpawn = 0
int32	AISpawned = 0
int32	DoorsSpawned = 0
bool	bCreatedInEditor = false
FRandomStream	RandomStream
FRandomStream *	RandomStreamPtr = nullptr
FRandomStream	NullRandomStream
TArray< IDungeonRoom * >	AllDungeonRooms
float	ExitLocationDistanceOverlap = 0.1f
bool	bDeleteExitBeforeSpawn = true
int32	RoomAttemptsBeforeFail = 5
int32	RoomAttemptsMathMultiplier = 5
bool	bHasInvalidClass = false
bool	bHideRoomRoofs = false
bool	bGiveRoomsRandomStream = false
bool	bAddStartingExit = false
bool	bDebuggingMode = true
bool	bDrawFailedExits = false
bool	bLogDungeonSummary = true
bool	bLogDungeonSteps = false
bool	bResetRoomTypesOnComplete = false
bool	bDelayEachRoomBuild = false
bool	bDelayEachAISpawn = false
bool	bDelayEachDoorSpawn = false
float	BuildDelayTime = 0.1f
FTimerHandle	BuildDelayHandle

Constructor & Destructor Documentation

AProceduralDungeonBuilder()

AProceduralDungeonBuilder::AProceduralDungeonBuilder

(

)

{
    PrimaryActorTick.bCanEverTick = false;
    SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
}

Member Function Documentation

AddAISpawnPointsToList()

void AProceduralDungeonBuilder::AddAISpawnPointsToList ( const USceneComponent * AIRootComponent )

protected

Adds any overlapping components to a List

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::AddAISpawnPointsToList);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(AIRootComponent == nullptr){return;}
    TArray<USceneComponent*> AISpawnComponents;
    AIRootComponent->GetChildrenComponents(false, AISpawnComponents);
    AISpawns.Append(AISpawnComponents);
}

BeginPlay()

void AProceduralDungeonBuilder::BeginPlay ( )

overrideprotectedvirtual

{
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    Super::BeginPlay();
    if(bCreateOnBeginPlay)
    {
        CreateDungeon();
    }
}

CheckExitsForJoiningRooms()

void AProceduralDungeonBuilder::CheckExitsForJoiningRooms ( )

protected

Check exits after the generator is complete, to see if they're next to Rooms

{
    if(bLogDungeonSteps){LogDebugWarning("CheckExitsForJoiningRooms");}
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::CheckExitsForJoiningRooms);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(AvailableExits.IsEmpty()){return;}
    // Iterate over the array from the start to find duplicates by distance
    RemoveExitsByDistance(AvailableExits, AvailableExits);
    RemoveExitsByDistance(ExitsToFill, ExitsToFill);
    RemoveExitsByDistance(AvailableExits, ExitsToFill);
}

CheckRoomAttemptsNumber()

void AProceduralDungeonBuilder::CheckRoomAttemptsNumber ( )

private

Checks that room attempts number hasn't been incorrectly input

{
    if(bLogDungeonSteps){LogDebugWarning("Check Room Attempts Number");}
    if(RoomAttemptsBeforeFail > 5)
    {
        RoomAttemptsBeforeFail = 5;
    }
    if(RoomAttemptsBeforeFail < 1)
    {
        RoomAttemptsBeforeFail = 1;
    }
}

CloseHoles()

void AProceduralDungeonBuilder::CloseHoles ( )

protected

Closes empty exits after the generator is complete

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::CloseHoles);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(bLogDungeonSteps){LogDebugWarning("CloseHoles");}
    if(AvailableExits.IsEmpty() && ExitsToFill.IsEmpty()){return;}
    if(bFillWithDeadEndRooms)
    {
        for(int32 i = AvailableExits.Num() - 1; i >= 0; --i)
        {
            SelectedExit = AvailableExits[i];
            UClass* SelectedRoomClass = GetDeadEndRoomClass();
            if(SelectedRoomClass == nullptr)
            {
                LogDebugError("CloseHoles SelectedRoomClass nullptr.");
                break;
            }
            FDungeonSpawnRoom* RoomData = RoomTypes.Find(SelectedRoomClass);
            if(RoomData == nullptr)
            {
                LogDebugError(FString::Printf(TEXT("CloseHoles: No precomputed data for %s"), *SelectedRoomClass->GetName()));
                continue;
            }
        
            const FTransform SpawnTransform = SelectedExit->GetComponentTransform();
            const FBox CandidateWorldBounds = RoomData->CalculatedRoomBounds.TransformBy(SpawnTransform);
            // 6. Check for overlap using our math (not physics overlaps).
            if(IsOverlapping(CandidateWorldBounds))
            {
                LogDebugWarning("CloseHoles Candidate room would overlap an existing room.");
                // Option: Remove this exit so we do not try it again, then try spawning a room on another exit.
                AttemptChecker++;
                INC_DWORD_STAT(STAT_GenerateAttempts);
                ExitsToFill.Add(SelectedExit);
                AvailableExits.Remove(SelectedExit);
                continue;
            }
            AActor* DeadEndRoom = GetWorld()->SpawnActor(SelectedRoomClass, &SpawnTransform, SpawnParams);
            const bool bValidRoom = SetDungeonValues();
            if(bValidRoom)
            {
                // 8. Save the candidate room’s bounds so future rooms can check against it.
                PlacedRoomBounds.Add(CandidateWorldBounds);
                AttemptChecker = 0;
                RoomData->NumberSpawned++;
            }
            else
            {
                if(DeadEndRoom != nullptr)
                {
                    DeadEndRoom->Destroy();
                }
                INC_DWORD_STAT(STAT_RoomsDeleted);
                ExitsToFill.Add(SelectedExit);
            }
        }
    }
    if(WallFill == nullptr)
    {
        LogDebugError(FString::Printf(TEXT("CloseHoles Wall fill class INVALID")));
        return;
    }
    for(const auto& Exit : AvailableExits)
    {
        const FTransform SpawnTransform = Exit->GetComponentTransform();
        AActor* Wall = GetWorld()->SpawnActor(WallFill, &SpawnTransform, SpawnParams);
        if(Wall == nullptr){LogDebugError(FString::Printf(TEXT("AvailableExits Wall Failed.. %s"), *Exit->GetReadableName()));continue;}
        if(bCreatedInEditor)
        {
            DungeonActors.Add(Wall);
        }
    }
    for(const auto& Exit : ExitsToFill)
    {
        const FTransform SpawnTransform = Exit->GetComponentTransform();
        AActor* Wall = GetWorld()->SpawnActor(WallFill, &SpawnTransform, SpawnParams);
        if(Wall == nullptr){LogDebugError(FString::Printf(TEXT("ExitsToFill Wall Failed.. %s"), *Exit->GetReadableName()));continue;}
        if(bCreatedInEditor)
        {
            DungeonActors.Add(Wall);
        }
    }
}

ContinueSpawnNextRoom()

void AProceduralDungeonBuilder::ContinueSpawnNextRoom ( )

protected

Triggers next room function

{
    if(GetShouldStopSpawningRooms())
    {
        if(bDelayEachRoomBuild)
        {
            OnRoomsComplete();
        }
        return;
    }
    if(GetShouldSpawnSpecialRoom())
    {
        ScheduleSpawn(&AProceduralDungeonBuilder::SpawnSpecialRoom);
    }
    else
    {
        ScheduleSpawn(&AProceduralDungeonBuilder::SpawnNextRoom);
    }
}

CreateDungeon()

void AProceduralDungeonBuilder::CreateDungeon ( )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::CreateDungeon);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(bLogDungeonSteps){LogDebugWarning("Create Dungeon");}
    if(GetNetMode() != NM_Client)
    {
        SetSeed();
        SetNumberOfRooms();
        CheckRoomAttemptsNumber();
        SetInitialValues();
        SpawnAllRooms();
        CreateDynamicMaterials();
        SpawnStartingRoom();
        ContinueSpawnNextRoom();
        if(bDelayEachRoomBuild){return;}
        if(bCheckForJoiningRooms)
        {
            CheckExitsForJoiningRooms();
        }
        CloseHoles();
        SpawnDoorAtLocation();
        SpawnAIAtLocation();
        SetRoomsReady();
        DungeonComplete();
    }
}

CreateDungeonInEditor()

void AProceduralDungeonBuilder::CreateDungeonInEditor ( )

protected

Creates a Dungeon From the Editor

{
    if(bCreatedInEditor)
    {
        DestroyDungeonInEditor();
    }
    bCreatedInEditor = true;
    CreateDungeon();
}

CreateDynamicMaterials()

void AProceduralDungeonBuilder::CreateDynamicMaterials ( )

protected

{
    if(bLogDungeonSteps){LogDebugWarning("CreateDynamicMaterials");}
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::CreateDynamicMaterials);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // const FSoftObjectPath UnitDataTablePath = FSoftObjectPath(TEXT("/SyntyAnimationPackage/Data/DT_SciFi_Tex.DT_SciFi_Tex"));
    // UDataTable* DataTable = Cast<UDataTable>(UnitDataTablePath.ResolveObject());
    // if(DataTable)
    // {
    //  MaterialDataTable =  DataTable;
    // }
    // DataTable = Cast<UDataTable>(UnitDataTablePath.TryLoad());
    // if(DataTable)
    // {
    //  MaterialDataTable =  DataTable;
    // }
    // UE_LOG(LogDungeonBuilder, Warning, TEXT("CreateDynamicMaterials DataTable Failed"));
 
    UMaterialInterface* CurrentMaterial = RoomMaterial;
    RoomMaterialInstance = UMaterialInstanceDynamic::Create(CurrentMaterial, this);
    if(RoomMaterialInstance == nullptr){LogDebugError(FString::Printf(TEXT("CreateDynamicMaterials Room Material Invalid"))); bApplyDynamicMaterial = false;return;}
    // MaterialDataTable->FindRow<>()
    //RoomMaterialInstance->SetTextureParameterValue();
}

DestroyDungeonInEditor()

void AProceduralDungeonBuilder::DestroyDungeonInEditor ( )

protected

Deletes the Last Dungeon From the Editor

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::DestroyDungeonInEditor);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    for(int32 i = DungeonActors.Num() - 1; i >= 0; --i)
    {
        if(DungeonActors[i] != nullptr)
        {
            DungeonActors[i]->Destroy();
        }
    }
    DungeonActors.Empty();
    bCreatedInEditor = false;
    bComplete = false;
    RoomsSpawned = 0;
    const TArray<USceneComponent*> EmptyArray;
    AvailableExits = EmptyArray;
    NumberOfRoomsToSpawn = StartingNumberOfRoomsToSpawn;
    AIToSpawn = StartingAIToSpawn;
    AttemptChecker = 0;
    AISpawned = 0;
}

DungeonComplete()

void AProceduralDungeonBuilder::DungeonComplete ( )

protected

Sets the dungeon to complete

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::DungeonComplete);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    bComplete = true;
#if WITH_EDITOR
    if(bLogDungeonSummary)
    {
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, TEXT("DUNGEON COMPLETE"));
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("Rooms: %i"), RoomsSpawned));
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("AI: %i"), AISpawned));
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("Seed: %i"), GetRandomStream().GetInitialSeed()));
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("Doors: %i"), DoorsSpawned));
        LogDebugError("DUNGEON COMPLETE");
        LogDebugError(FString::Printf(TEXT("Rooms: %i"), RoomsSpawned));
        LogDebugError(FString::Printf(TEXT("AI: %i"), AISpawned));
        LogDebugError(FString::Printf(TEXT("Seed: %i"), GetRandomStream().GetInitialSeed()));
        LogDebugError(FString::Printf(TEXT("Doors: %i"), DoorsSpawned));
    }
#endif
    const TArray<USceneComponent*> EmptyArray;
    AvailableExits = EmptyArray;
    LastSpawnedRoom = nullptr;
    SelectedExit = nullptr;
    if(bResetRoomTypesOnComplete)
    {
        RoomTypes = StartingRoomTypes;
    }
    NumberOfRoomsToSpawn = StartingNumberOfRoomsToSpawn;
    AttemptChecker = 0;
    SelectedAISpawn = nullptr;
    ExitsToFill.Empty();
    AISpawns.Empty();
    AllDungeonRooms.Empty();
    Multicast_DungeonComplete(RoomsSpawned);
}

GetDeadEndRoomClass()

UClass * AProceduralDungeonBuilder::GetDeadEndRoomClass ( ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetDeadEndRoomClass);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // 1.Get All Rooms Except Hallways
    FDungeonSpawns NonHallways = FDungeonSpawns(GetRoomsOfType(EDungeonRoomType::Hallway, true));
    TArray<FDungeonSpawnRoom>& SelectedRooms = NonHallways.GetRooms();
    SelectedRooms = NonHallways.GetRoomsWithNoExits();
    TArray<TSubclassOf<AActor>> SelectedRoomClasses;
    for(auto& SelectedRoom : SelectedRooms)
    {
        if(SelectedRoom.bDisable)
        {
            continue;
        }
        //- Don't Add Types that aren't compatible  
        if(bCheckRoomTypes)
        {
            if(SelectedExit != nullptr && SelectedExit->GetAttachParentActor() != nullptr)
            {
                UClass* ConnectingRoomClass = SelectedExit->GetAttachParentActor()->GetClass();
                const EDungeonRoomType ConnectingRoomType = RoomTypes.FindType(ConnectingRoomClass);
                const bool bValidConnection = GetIsValidRoomConnection(ConnectingRoomType, SelectedRoom.CalculatedType);
                if(bValidConnection == false)
                {
                    continue;
                }
            }
        }
        //- Check if the Room has a limit 
        if(SelectedRoom.bSpawnLimit)
        {
            const int32 ExistingCount = SelectedRoom.NumberSpawned;
            if(ExistingCount >= SelectedRoom.NumberToSpawn)
            {
                continue;
            }
        }
        SelectedRoomClasses.Append(SelectedRoom.GetWeightedTypes());
    }
    return UProceduralBPLib::GetRandomClassFromStream(SelectedRoomClasses, GetRandomStream());
}

GetIsValidRoomConnection()

bool AProceduralDungeonBuilder::GetIsValidRoomConnection ( const EDungeonRoomType ParentType, const EDungeonRoomType CandidateType ) const

protected

GetMaterialInstance()

UMaterialInstanceDynamic * AProceduralDungeonBuilder::GetMaterialInstance ( ) const

inlineprotected

{return RoomMaterialInstance;};

GetNewRoomClass()

UClass * AProceduralDungeonBuilder::GetNewRoomClass ( ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetNewRoomClass);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // 1.Get All Rooms Except Special Rooms
    FDungeonSpawns NonSpecialRooms = FDungeonSpawns(GetRoomsOfType(EDungeonRoomType::SpecialRoom, true));
    TArray<FDungeonSpawnRoom>& SelectedRooms = NonSpecialRooms.GetRooms();
    if(bCheckRoomExitCount)
    {
        const int32 ExitsLeft = AvailableExits.Num();
        // exclude dead end rooms.
        if(ExitsLeft <= CheckRoomExitCountMin && NumberOfRoomsToSpawn > CheckRoomExitCountMin)
        {
            SelectedRooms = NonSpecialRooms.GetRoomsWithExits();
            // if Exits are 1 or less
            if(ExitsLeft <= 1 && NumberOfRoomsToSpawn > CheckRoomExitCountMin)
            {
                SelectedRooms = NonSpecialRooms.GetRoomsWithNumOfExits(2);
            }
        }
    }
    TArray<TSubclassOf<AActor>> SelectedRoomClasses;
    for(auto& SelectedRoom : SelectedRooms)
    {
        if(SelectedRoom.bDisable)
        {
            continue;
        }
        //- Don't Add Types that aren't compatible  
        if(bCheckRoomTypes)
        {
            if(SelectedExit != nullptr && SelectedExit->GetAttachParentActor() != nullptr)
            {
                UClass* ConnectingRoomClass = SelectedExit->GetAttachParentActor()->GetClass();
                const EDungeonRoomType ConnectingRoomType = RoomTypes.FindType(ConnectingRoomClass);
                const bool bValidConnection = GetIsValidRoomConnection(ConnectingRoomType, SelectedRoom.CalculatedType);
                if(bValidConnection == false)
                {
                    continue;
                }
            }
        }
        //- Check if the Room has a limit 
        if(SelectedRoom.bSpawnLimit)
        {
            const int32 ExistingCount = SelectedRoom.NumberSpawned;
            if(ExistingCount >= SelectedRoom.NumberToSpawn)
            {
                continue;
            }
        }
        SelectedRoomClasses.Append(SelectedRoom.GetWeightedTypes());
    }
    if(SelectedRoomClasses.IsEmpty()){return nullptr;}
    return UProceduralBPLib::GetRandomClassFromStream(SelectedRoomClasses, GetRandomStream());
}

GetNextExit()

USceneComponent * AProceduralDungeonBuilder::GetNextExit ( )

private

{
    if(bGetClosestExit)
    {
        if(bRandomGetClosestExit)
        {
            UKismetMathLibrary::RandomBoolWithWeightFromStream(GetRandomStream(), RandomClosesExitWeight);
        }
        const FVector OriginLocation = GetActorLocation();
        USceneComponent* ClosestExit = nullptr;
        float ClosestDistanceSquared = FLT_MAX;
        for (USceneComponent* Exit : AvailableExits)
        {
            if(Exit == nullptr)
            {
                continue;
            }
            // Use squared distance for performance
            const float DistanceSquared = FVector::DistSquared(Exit->GetComponentLocation(), OriginLocation);
            if (DistanceSquared < ClosestDistanceSquared)
            {
                ClosestDistanceSquared = DistanceSquared;
                ClosestExit = Exit;
            }
        }
        if(ClosestExit != nullptr)
        {
            return ClosestExit;
        }
    }
    return UProceduralBPLib::GetRandomSceneComponentFromStream(AvailableExits, GetRandomStream());
}

GetRandomStream()

FRandomStream & AProceduralDungeonBuilder::GetRandomStream ( ) const

protected

{
    if(RandomStreamPtr != nullptr)
    {
        return *RandomStreamPtr;
    }
    if(RandomStreamPtr == nullptr)
    {
        UE_LOG(LogDungeonBuilder, Fatal, TEXT("AProceduralDungeonBuilder::GetRandomStream has failed"));
    }
    return *RandomStreamPtr;
    // return RandomStream;
}

GetRoomsByExits()

TArray< FDungeonSpawnRoom > AProceduralDungeonBuilder::GetRoomsByExits ( ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetRoomsByExits);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    TArray<FDungeonSpawnRoom> SelectedRooms = RoomTypes.GetAllRooms();
    const int32 ExitsLeft = AvailableExits.Num();
    // exclude dead end rooms.
    if(ExitsLeft <= CheckRoomExitCountMin && NumberOfRoomsToSpawn > CheckRoomExitCountMin)
    {
        SelectedRooms = RoomTypes.GetRoomsWithExits();
        // if Exits are 1 or less
        if(ExitsLeft <= 1 && NumberOfRoomsToSpawn > CheckRoomExitCountMin)
        {
            SelectedRooms = RoomTypes.GetRoomsWithNumOfExits(2);
        }
    }
    return SelectedRooms;
}

GetRoomsOfType() [1/2]

TArray< FDungeonSpawnRoom > AProceduralDungeonBuilder::GetRoomsOfType ( const EDungeonRoomType FilterType, const bool bInverseSelection = false ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetRoomsOfType);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    TArray<EDungeonRoomType> FilterTypes;
    FilterTypes.Add(FilterType);
    return GetRoomsOfType(FilterTypes, bInverseSelection);
}

GetRoomsOfType() [2/2]

TArray< FDungeonSpawnRoom > AProceduralDungeonBuilder::GetRoomsOfType ( const TArray< EDungeonRoomType > & FilterTypes, const bool bInverseSelection = false ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetRoomsOfType);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    TArray<FDungeonSpawnRoom> SelectedRooms = RoomTypes.GetAllRooms();
    const int32 RoomsLength = SelectedRooms.Num() - 1;
    for(int32 i = RoomsLength; i >= 0; --i)
    {
        if(FilterTypes.Contains(SelectedRooms[i].CalculatedType) == bInverseSelection)
        {
            SelectedRooms.RemoveAt(i);
        }
    }
    return SelectedRooms;
}

GetRoomsOfTypeBP()

TArray< FDungeonSpawnRoom > AProceduralDungeonBuilder::GetRoomsOfTypeBP ( const TArray< EDungeonRoomType > & FilterTypes, const bool bInverseSelection = false ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetRoomsOfType);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    return GetRoomsOfType(FilterTypes, bInverseSelection);
}

GetShouldSpawnSpecialRoom()

bool AProceduralDungeonBuilder::GetShouldSpawnSpecialRoom ( ) const

private

Gets if the next spawn should take from the special list

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetShouldSpawnSpecialRoom);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    //@ TEMP Fix, This can return null in SpawnNextSpecialRoom Mathmatically, and end the loop too early 
    if(GetSpecialRoomClass() == nullptr){return false;}
    TArray<FDungeonSpawnRoom> SpecialRooms = GetRoomsOfType(EDungeonRoomType::SpecialRoom);
    LogDebugMessage(FString::Printf(TEXT("GetShouldSpawnSpecialRoom Rooms: %i"), SpecialRooms.Num()), true, true);
    if(SpecialRooms.IsEmpty()){return false;}
    
    int32 TotalSpecialSpawnsRemaining = 0;
    int32 RequiredSpecialSpawnsRemaining = 0;
    
    for(const auto& SpecialRoom : SpecialRooms)
    {
        if(SpecialRoom.bDisable)
        {
            continue;
        }
        // Calculate how many spawns remain for this room type.
        const int32 Remaining = FMath::Max(SpecialRoom.NumberToSpawn - SpecialRoom.NumberSpawned, 0);
        if(Remaining <= 0)
        {
            continue;
        }
        // If the room is required, count it toward required spawns.
        if (SpecialRoom.bRequired)
        {
            RequiredSpecialSpawnsRemaining += Remaining;
        }
        // If we have a spawn limit, only add the remaining count.
        // Otherwise, treat NumberToSpawn as a weight.
        if (SpecialRoom.bSpawnLimit)
        {
            TotalSpecialSpawnsRemaining += Remaining;
        }
        else
        {
            TotalSpecialSpawnsRemaining += SpecialRoom.NumberToSpawn;
        }
    }
    LogDebugMessage(FString::Printf(TEXT("GetShouldSpawnSpecialRoom SpecialRoomsToSpawn: %i"), TotalSpecialSpawnsRemaining), true, true);
    
    if(TotalSpecialSpawnsRemaining <= 0){return false;}
    //- If we have more special than regular rooms, always use special //
    if(RequiredSpecialSpawnsRemaining  >=  NumberOfRoomsToSpawn){return true;}
 
    // 2. Check we have enough exits ?
    if(bCheckRoomExitCount)
    {
        if(NumberOfRoomsToSpawn > AvailableExits.Num())
        {
            return false;
        }
        if(AvailableExits.Num() < TotalSpecialSpawnsRemaining)
        {
            return false;
        }
    }
    // Calculate the probability of spawning a special room
    float Probability = static_cast<float>(TotalSpecialSpawnsRemaining) / static_cast<float>(NumberOfRoomsToSpawn);
    // Optionally, if there are required special rooms, boost the probability so they don't get left out.
    if (RequiredSpecialSpawnsRemaining > 0)
    {
        Probability = FMath::Max(Probability, 0.5f); // adjust the minimum probability as needed
    }
    // Generate a random float between 0 and 1 using the random stream
    const float RandomFloat = UKismetMathLibrary::RandomFloatInRangeFromStream(GetRandomStream(), 0.0f, 1.0f);
    // If the random number is less than the calculated probability, spawn a special room
    return RandomFloat < Probability;
}

GetShouldStopSpawningRooms()

bool AProceduralDungeonBuilder::GetShouldStopSpawningRooms ( ) const

private

Checks if Still rooms to spawn, if too many attempts

{
    if(AttemptChecker > (TotalNumberOfRoomsToSpawn * RoomAttemptsBeforeFail * RoomAttemptsMathMultiplier))
    {
        return true;
    }
    if(AttemptChecker > (TotalNumberOfRoomsToSpawn * RoomAttemptsBeforeFail))
    {
        return true;
    }
    if(AvailableExits.Num() <= 0)
    {
        return true;
    }
    if(NumberOfRoomsToSpawn <= 0)
    {
        return true;
    }
    return false;
}

GetSpecialRoomClass()

UClass * AProceduralDungeonBuilder::GetSpecialRoomClass ( ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::GetSpecialRoomClass);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // 1. Get All Special room Types 
    FDungeonSpawns SpecialRooms = FDungeonSpawns(GetRoomsOfType(EDungeonRoomType::SpecialRoom));
    TArray<FDungeonSpawnRoom>& SelectedRooms = SpecialRooms.GetRooms();
    
    TArray<TSubclassOf<AActor>> SelectedRoomClasses;
    for(auto& SelectedRoom : SelectedRooms)
    {
        if(SelectedRoom.bDisable)
        {
            continue;
        }
        if(bCheckRoomTypes)
        {
            if(SelectedExit != nullptr && SelectedExit->GetAttachParentActor() != nullptr)
            {
                UClass* ConnectingRoomClass = SelectedExit->GetAttachParentActor()->GetClass();
                const EDungeonRoomType ConnectingRoomType = RoomTypes.FindType(ConnectingRoomClass);
                const bool bValidConnection = GetIsValidRoomConnection(ConnectingRoomType, SelectedRoom.CalculatedType);
                if(bValidConnection == false)
                {
                    continue;
                }
            }
        }
        //- Check if the Room has a limit 
        if(SelectedRoom.bSpawnLimit)
        {
            if(SelectedRoom.NumberSpawned >= SelectedRoom.NumberToSpawn)
            {
                continue;
            }
        }
        SelectedRoomClasses.Append(SelectedRoom.GetWeightedTypes());
    }
    if(SelectedRoomClasses.IsEmpty()){return nullptr;}
    return UProceduralBPLib::GetRandomClassFromStream(SelectedRoomClasses, GetRandomStream());
}

GetStartingRoomClass()

UClass * AProceduralDungeonBuilder::GetStartingRoomClass ( )

private

{
    if(RoomTypes.IsEmpty())
    {
        LogDebugMessage("GetStartingRoomClass RoomTypes.IsEmpty", true);
        return nullptr;
    }
    if(RoomTypes.IsValidIndex(StartingRoomNumber) == false)
    {
        StartingRoomNumber = UKismetMathLibrary::RandomIntegerInRangeFromStream(GetRandomStream(), 0, (RoomTypes.Num() - 1));
    }
    if(RoomTypes.IsValidIndex(StartingRoomNumber) == false)
    {
        LogDebugMessage("GetStartingRoomClass RoomTypes.IsValidIndex", true);
        return nullptr;
    }
    return RoomTypes.GetAllRooms()[StartingRoomNumber].Type;
}

HideAllRoomRoofs()

void AProceduralDungeonBuilder::HideAllRoomRoofs ( )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::HideAllRoomRoofs);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    bHideRoomRoofs = !bHideRoomRoofs;
    for(const auto DungeonRoom :  AllDungeonRooms)
    {
        DungeonRoom->ToggleAllRoomRoofs(bHideRoomRoofs);
    }
}

IsOverlapping()

bool AProceduralDungeonBuilder::IsOverlapping ( const FBox & CandidateBox )

protected

{
    for(const FBox& ExistingBox : PlacedRoomBounds)
    {
        if(BoxesOverlap(CandidateBox, ExistingBox))
        {
            return true;
        }
    }
    return false;
}

LogDebugError()

void AProceduralDungeonBuilder::LogDebugError ( const FString & Message ) const

private

Gets random from the array

{
    LogDebugMessage(Message, true, true);
}

LogDebugMessage()

void AProceduralDungeonBuilder::LogDebugMessage ( const FString & Message, const bool bWarning = false, const bool bError = false ) const

private

{
    if(bDebuggingMode == false && bError == false){return;}
    FOutputDevice* OutputDevice = GWarn;
    if(OutputDevice == nullptr){return;}
    FString NetModeString;
    switch(GetWorld()->GetNetMode())
    {
    case NM_Standalone:
        NetModeString = FString("SDL");
        break;
    case NM_DedicatedServer:
        NetModeString = FString("DServer");
        break;
    case NM_ListenServer:
        NetModeString = FString("LServer");
        break;
    case NM_Client:
        NetModeString = FString("Client");
        break;
    default:
        NetModeString = FString("Unknown");
        break;
    }
    const FString FullMessage = FString::Printf(TEXT("%s: AProceduralDungeonBuilder::%s"), *NetModeString, *Message);
    if(bError)
    {
        OutputDevice->Log(LogDungeonBuilder.GetCategoryName(), ELogVerbosity::Error, FullMessage);
    }
    else if(bWarning)
    {
        OutputDevice->Log(LogDungeonBuilder.GetCategoryName(), ELogVerbosity::Warning, FullMessage);
    }
    else
    {
        OutputDevice->Log(LogDungeonBuilder.GetCategoryName(), ELogVerbosity::Log, FullMessage);
    }
}

LogDebugWarning()

void AProceduralDungeonBuilder::LogDebugWarning ( const FString & Message ) const

private

{
    LogDebugMessage(Message, true);
}

Multicast_DungeonComplete()

void AProceduralDungeonBuilder::Multicast_DungeonComplete ( int32 NumRooms )

protected

OnAISpawned()

void AProceduralDungeonBuilder::OnAISpawned ( const int32 NumOfPawns )

protected

OnConstruction()

void AProceduralDungeonBuilder::OnConstruction ( const FTransform & Transform )

overrideprotectedvirtual

{
    Super::OnConstruction(Transform);
    if(Transform.IsValid() == false){return;}
}

OnDoorsSpawned()

void AProceduralDungeonBuilder::OnDoorsSpawned ( const int32 NumOfDoors )

protected

OnDungeonComplete()

void AProceduralDungeonBuilder::OnDungeonComplete ( const int32 NumOfRooms )

protected

OnRoomsComplete()

void AProceduralDungeonBuilder::OnRoomsComplete ( )

private

For use if there is a Delay,

{
    if(bLogDungeonSteps){LogDebugWarning("OnRoomsComplete");}
    if(bCheckForJoiningRooms)
    {
        CheckExitsForJoiningRooms();
    }
    CloseHoles();
    SpawnDoorAtLocation();
    SpawnAIAtLocation();
    SetRoomsReady();
    DungeonComplete();
}

RemoveExitsByDistance()

void AProceduralDungeonBuilder::RemoveExitsByDistance ( TArray< USceneComponent * > & ExitsA, TArray< USceneComponent * > & ExitsB ) const

private

{
    for (int32 i = 0; i < ExitsA.Num(); ++i)
    {
        if (!ExitsA[i]) { continue; }
 
        const FVector LocationToCheck = ExitsA[i]->GetComponentLocation();
 
        // Check against all other components after this one in the array
        for (int32 j = i + 1; j < ExitsB.Num(); ++j)
        {
            if (!ExitsB[j]) { continue; }
 
            // Ensure we are not comparing the same component instance
            if (ExitsA[i] != ExitsB[j] &&
                LocationToCheck.Equals(ExitsB[j]->GetComponentLocation(), ExitLocationDistanceOverlap))
            {
                // If the locations are the same, remove both exits from the array
                ExitsB.RemoveAt(j);  // Remove the second component first
                ExitsA.RemoveAt(i);  // Remove the first component
 
                // After removing, decrement i to avoid skipping the next element
                --i;
                break;  // Exit the inner loop and move to the next component
            }
        }
    }
}

ScheduleSpawn()

void AProceduralDungeonBuilder::ScheduleSpawn ( const FTimerDelegate::TMethodPtr< AProceduralDungeonBuilder > SpawnMethod )

protected

{
    if(bDelayEachRoomBuild)
    {
        GetWorld()->GetTimerManager().SetTimer(BuildDelayHandle, this, SpawnMethod, BuildDelayTime, false);
    }
    else
    {
        (this->*SpawnMethod)();
    }
}

SetDungeonValues()

bool AProceduralDungeonBuilder::SetDungeonValues ( )

private

{
    AttemptChecker++;
    INC_DWORD_STAT(STAT_GenerateAttempts);
    
    // 1. Check Valid
    if(LastSpawnedRoom == nullptr){LogDebugWarning(FString::Printf(TEXT("SetDungeonValues LastSpawnedRoom")));return false;}
    IDungeonRoom* NextDungeonRoom = Cast<IDungeonRoom>(LastSpawnedRoom);
    if(NextDungeonRoom == nullptr)
    {
        LogDebugWarning(FString::Printf(TEXT("SetDungeonValues NextDungeonRoom")));
        return false;
    }
    // 2. Add to list of all rooms, to set as ready at end //
    AllDungeonRooms.AddUnique(NextDungeonRoom);
    
    // 3. Apply Random 
    NextDungeonRoom->SetRandomStream(GetRandomStream());
    // 3.1 Material
    if(bApplyDynamicMaterial)
    {
        //@TODO Get Slot Name
        //@TODO Instead should give an array of each Dynamic material, ones for glass, General etc. 
        // @ Get Matching Material?
        NextDungeonRoom->SetDynamicMaterial(RoomMaterialInstance);
    }
    //3.2 Roof Debug 
#if WITH_EDITOR
    if(bHideRoomRoofs)
    {
        NextDungeonRoom->ToggleAllRoomRoofs(true);
    }
#endif // WITH_EDITOR
 
    // 4. Add Exits to list
    TArray<USceneComponent*> ExitsToAdd;
    if(NextDungeonRoom->GetExitsRootComponent())
    {
        TArray<USceneComponent*> NewExits;
        NextDungeonRoom->GetExitsRootComponent()->GetChildrenComponents(false, NewExits);
        // 4.1 Check if any are overlapping the current exits
        RemoveExitsByDistance(NewExits, AvailableExits);
        RemoveExitsByDistance(NewExits, ExitsToFill);
        ExitsToAdd.Append(NewExits);
    }
    AvailableExits.Append(ExitsToAdd);
    
    if(SelectedExit != nullptr)
    {
        // 5. Add Door Locations
        if(NextDungeonRoom->GetShouldRoomSpawnDoorAtEntry(GetRandomStream()))
        {
            DoorLocations.Add(SelectedExit);
        
            //@ TEST do we need to get it when we add to the list, and add into a scruct? or when we are adding the doors   
            // //@TEST Check if we can get the Parent of the Component
            // // then we can get the Room that owns the Door, and Add that to the RoomActor 
            // if(SelectedExit->GetAttachParentActor() != nullptr)
            // {
            //  UE_LOG(LogDungeonBuilder, Warning,TEXT("Parent Actor: %s"), SelectedExit->GetAttachParentActor()->GetHumanReadableName());
            // }
        }
        // 6. Add Connecting Rooms  
        if(SelectedExit->GetAttachParentActor() != nullptr)
        {
            //- Add the Last room to the New room   -> 
            NextDungeonRoom->AddAttachedRoom(SelectedExit->GetAttachParentActor());
            //- Add the New room, to the Last room  ->
            IDungeonRoom* ExitDungeonRoom = Cast<IDungeonRoom>(SelectedExit->GetAttachParentActor());
            if(ExitDungeonRoom != nullptr)
            {
                ExitDungeonRoom->AddAttachedRoom(LastSpawnedRoom);
            }
        }
        // // 7. Remove Exit from List
        // if(bDeleteExitBeforeSpawn == false)
        // {
        //  AvailableExits.Remove(SelectedExit);
        // }
    }
 
    // 8. Add AI Spawn Points
    AddAISpawnPointsToList(NextDungeonRoom->GetAISpawnsRootComponent());
    // 9. Add Values
    NumberOfRoomsToSpawn--;
    RoomsSpawned++;
    if(bCreatedInEditor)
    {
        DungeonActors.Add(LastSpawnedRoom);
    }
    INC_DWORD_STAT(STAT_RoomsCreated);
    return true;
}

SetInitialValues()

void AProceduralDungeonBuilder::SetInitialValues ( )

protected

{
    if(bLogDungeonSteps){LogDebugWarning("SetInitialValues");}
    UProceduralBPLib::AddWeightsToArray(DoorTypes, DoorWeights);
    StartingAIToSpawn = AIToSpawn;
    StartingRoomTypes = RoomTypes;
}

SetNumberOfRooms()

void AProceduralDungeonBuilder::SetNumberOfRooms ( )

private

Sets the Number Of Rooms

{
    if(bLogDungeonSteps){LogDebugWarning("Set Number Of Rooms");}
    StartingNumberOfRoomsToSpawn = NumberOfRoomsToSpawn;
    if(bUseRandomNumberOfRooms)
    {
        NumberOfRoomsToSpawn = UKismetMathLibrary::RandomIntegerInRangeFromStream(GetRandomStream(), MinNumberOfRoomsToSpawn, NumberOfRoomsToSpawn);
    }
    TotalNumberOfRoomsToSpawn = NumberOfRoomsToSpawn;
}

SetRoomsReady()

void AProceduralDungeonBuilder::SetRoomsReady ( ) const

protected

Sets all rooms to be Ready

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SetRoomsReady);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(bLogDungeonSteps){LogDebugWarning("SetRoomsReady");}
    if(bDebuggingMode){LogDebugMessage(FString::Printf(TEXT("SetRoomsReady DungeonRooms: %i"), AllDungeonRooms.Num()));}
    for(const auto DungeonRoom: AllDungeonRooms)
    {
        if(DungeonRoom == nullptr){continue;}
        DungeonRoom->SetReady();
    }
}

SetSeed()

void AProceduralDungeonBuilder::SetSeed ( )

private

Sets the RandomStream

{
    if (!HasAuthority()) return;
    if(bLogDungeonSteps){LogDebugWarning("Set Seed");}
    if(bUseGameModeStream)
    {
        LogDebugError("SetSeed bUseGameModeStream");
        IProceduralGM* ProceduralGM = Cast<IProceduralGM>(UGameplayStatics::GetGameMode(this));
        if(ProceduralGM == nullptr){LogDebugError("SetSeed ProceduralGM");}
        if(ProceduralGM != nullptr)
        {
            RandomStreamPtr = &ProceduralGM->GetRandomStream();
            if(RandomStreamPtr == nullptr){LogDebugError("SetSeed RandomStreamPtr");}
            if(RandomStreamPtr != nullptr)
            {
                Seed = RandomStreamPtr->GetCurrentSeed();
                bUsingGameModeSteam = true;
                LogDebugMessage(FString::Printf(TEXT("GAME MODE SEED: %i"), Seed), true, true);
                return;
            }
        }
    }
    if(bUseRandomSeed)
    {
        UKismetMathLibrary::SeedRandomStream(RandomStream);
        Seed = RandomStream.GetCurrentSeed();
    }
    else
    {
        UKismetMathLibrary::SetRandomStreamSeed(RandomStream, Seed);
    }
    if(RandomStreamPtr == nullptr)
    {
        RandomStreamPtr = &RandomStream;
    }
}

SpawnAIAtLocation()

void AProceduralDungeonBuilder::SpawnAIAtLocation ( )

protected

Spawns Random AI at the Spawn points

{
    if (!HasAuthority()) return;
    if(bLogDungeonSteps){LogDebugWarning("SpawnAIAtLocation");}
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnAIAtLocation);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(AIToSpawn <= 0){OnAISpawned(AISpawned);return;}
    UClass* AIClass = UProceduralBPLib::GetRandomClassFromStream(AITypes, GetRandomStream());
    // @Todo Instead of Early Finish, there needs to be attempt limit, and try again.
    if(AIClass == nullptr){OnAISpawned(AISpawned);return;}
    SelectedAISpawn = UProceduralBPLib::GetRandomSceneComponentFromStream(AISpawns, GetRandomStream());
    if(SelectedAISpawn == nullptr){OnAISpawned(AISpawned);return;}
    const FTransform SpawnTransform = SelectedAISpawn->GetComponentTransform();
    const APawn* SpawnedAI = UAIBlueprintHelperLibrary::SpawnAIFromClass(GetWorld(), AIClass, nullptr, SpawnTransform.GetLocation());
    if(SpawnedAI == nullptr)
    {
        LogDebugError(FString::Printf(TEXT("SpawnAIAtLocation SpawnedAI")));
        AISpawns.Remove(SelectedAISpawn);
        AISpawnsFailed.Add(SelectedAISpawn);
        SpawnAIAtLocation();
        return;
    }
    AISpawns.Remove(SelectedAISpawn);
    AISpawnsSelected.Add(SelectedAISpawn);
    
    AIToSpawn--;
    AISpawned++;
    if(bDelayEachAISpawn)
    {
        GetWorld()->GetTimerManager().SetTimer(BuildDelayHandle, this, &AProceduralDungeonBuilder::SpawnAIAtLocation, BuildDelayTime, false);
        return;
    }
    SpawnAIAtLocation();
}

SpawnAllRooms()

void AProceduralDungeonBuilder::SpawnAllRooms ( )

protected

Create first room at Actors location

{
    if(bLogDungeonSteps){LogDebugWarning("SpawnAllRooms");}
    //@ TODO Get all Material Slot Names Possible?
    // for Setting the right Material?
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnAllRooms);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    UWorld* World = GetWorld();
    if(World == nullptr)
    {
        LogDebugWarning(FString::Printf(TEXT("SpawnAllRooms CalculateRoomExits: World is null")));
        return;
    }
    for(FDungeonSpawnRoom& RoomSpawn : RoomTypes.GetRooms())
    {
        if (RoomSpawn.Type == nullptr){LogDebugWarning(FString::Printf(TEXT("SpawnAllRooms RoomSpawn.Type nullptr")));continue;}
        AActor* TempRoom = World->SpawnActor<AActor>(RoomSpawn.Type, FTransform::Identity, SpawnParams);
        if (TempRoom)
        {
            const IDungeonRoom* DungeonRoom = Cast<IDungeonRoom>(TempRoom);
            if(DungeonRoom)
            {
                const int32 NumExits = DungeonRoom->GetNumOfExits();
                RoomSpawn.CalculatedExits = NumExits;
                const EDungeonRoomType RoomType = DungeonRoom->GetRoomType();
                RoomSpawn.CalculatedType = RoomType;
                const FBox RoomBounds = DungeonRoom->GetRoomBounds();
                RoomSpawn.CalculatedRoomBounds = RoomBounds;
                // RoomSpawn.bCalculatedMaterialSlot ? or on room
                RoomSpawn.bCalculatedValues = true;
            }
            else
            {
                LogDebugWarning(FString::Printf(TEXT("SpawnAllRooms Room %s does not implement IDungeonRoom."), *RoomSpawn.Type->GetName()));
            }
            TempRoom->Destroy();
        }
        else
        {
            LogDebugWarning(FString::Printf(TEXT("SpawnAllRooms Failed to spawn temporary instance of %s."), *RoomSpawn.Type->GetName()));
        }
    }
}

SpawnDoorAtLocation()

void AProceduralDungeonBuilder::SpawnDoorAtLocation ( )

protected

Closes empty exits after the generator is complete

{
    if (!HasAuthority()) return;
    if(bLogDungeonSteps){LogDebugWarning("SpawnDoorAtLocation");}
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnDoors);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    if(DoorLocations.Num() <= 0){OnDoorsSpawned(DoorsSpawned);return;}
    if(bSpawnDoors == false){OnDoorsSpawned(DoorsSpawned);return;}
    if(bLimitDoors && DoorsSpawned >= DoorLimit){OnDoorsSpawned(DoorsSpawned);return;}
    UClass* DoorClass = UProceduralBPLib::GetRandomClassFromStream(DoorTypes, GetRandomStream());
    if(DoorClass == nullptr){OnDoorsSpawned(DoorsSpawned);return;}
    SelectedDoorSpawn = UProceduralBPLib::GetRandomSceneComponentFromStream(DoorLocations, GetRandomStream());
    if(SelectedDoorSpawn == nullptr){OnDoorsSpawned(DoorsSpawned);return;}
    const FTransform SpawnTransform = SelectedDoorSpawn->GetComponentTransform();
    const AActor* NewDoor = GetWorld()->SpawnActor(DoorClass, &SpawnTransform, SpawnParams);
    if(NewDoor == nullptr)
    {
        LogDebugError(FString::Printf(TEXT("SpawnDoors NewDoor Failed")));
        DoorLocations.Remove(SelectedDoorSpawn);
        DoorSpawnsFailed.Add(SelectedDoorSpawn);
        SpawnDoorAtLocation();
        return;
    }
    //@TEST Check if we can get the Parent of the Component
    // then we can get the Room that owns the Door, and Add that to the RoomActor 
    if(SelectedExit->GetAttachParentActor() != nullptr)
    {
        //LogDebugMessage(FString::Printf(TEXT("Parent Actor: %s, Door: %s"), *SelectedExit->GetAttachParentActor()->GetName(), *NewDoor->GetName()));
    }
    else
    {
        LogDebugError(FString::Printf(TEXT("Parent Actor: Invalid, Door: %s"), *NewDoor->GetName()));
    }
    DoorLocations.Remove(SelectedDoorSpawn);
    DoorsSpawned++;
    if(bDelayEachDoorSpawn)
    {
        GetWorld()->GetTimerManager().SetTimer(BuildDelayHandle, this, &AProceduralDungeonBuilder::SpawnDoorAtLocation, BuildDelayTime, false);
        return;
    }
    SpawnDoorAtLocation();
}

SpawnNextRoom()

void AProceduralDungeonBuilder::SpawnNextRoom ( )

protected

The function that loops creating rooms

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnNextRoom);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // 1. Choose an exit from an already placed room.
    SelectedExit = GetNextExit();
    if(SelectedExit == nullptr)
    {
        LogDebugError("SpawnNextRoom No available exit found.");
        return;
    }
    
    // 2. Pick a candidate room.
    UClass* SelectedRoomClass = GetNewRoomClass();
    if(SelectedRoomClass == nullptr)
    {
        LogDebugError("SpawnNextRoom SelectedRoomClass nullptr.");
        return;
    }
    // 3.1 Look up the precomputed data for the candidate room.
    FDungeonSpawnRoom* RoomData = RoomTypes.Find(SelectedRoomClass);
    if(RoomData == nullptr)
    {
        LogDebugError(FString::Printf(TEXT("SpawnNextRoom: No precomputed data for %s"), *SelectedRoomClass->GetName()));
        return;
    }
 
    // 4.1 Compute the candidate room’s world transform.
    const FTransform SpawnTransform = SelectedExit->GetComponentTransform();
 
    // 5.1 Compute the candidate room’s world bounds.
    const FBox CandidateWorldBounds = RoomData->CalculatedRoomBounds.TransformBy(SpawnTransform);
    // const FBox CandidateWorldBounds = RoomData->LocalBounds.TransformBy(SpawnTransform);
    
    // 6. Check for overlap using our math (not physics overlaps).
    if(IsOverlapping(CandidateWorldBounds))
    {
        LogDebugWarning("SpawnNextRoom Candidate room would overlap an existing room.");
        if(bDrawFailedExits)
        {
            DrawDebugBox(GetWorld(), CandidateWorldBounds.GetCenter(), CandidateWorldBounds.GetExtent(), FColor::Red, false, BuildDelayTime * 5.0f, 0, 1.0f);
        }
        // Option: Remove this exit so we do not try it again, then try spawning a room on another exit.
        AttemptChecker++;
        INC_DWORD_STAT(STAT_GenerateAttempts);
        AvailableExits.Remove(SelectedExit);
        ExitsToFill.Add(SelectedExit);
        ContinueSpawnNextRoom();
        return;
    }
    // 7. Spawn the candidate room using the computed transform.
    LastSpawnedRoom = GetWorld()->SpawnActor<AActor>(SelectedRoomClass, SpawnTransform, SpawnParams);
    AvailableExits.Remove(SelectedExit);
    const bool bValidRoom = SetDungeonValues();
    if(bValidRoom)
    {
        // 8. Save the candidate room’s bounds so future rooms can check it
        PlacedRoomBounds.Add(CandidateWorldBounds);
        AttemptChecker = 0;
        RoomData->NumberSpawned++;
        //@ TODO
        // CheckForOverlappingExits();
    }
    else
    {
        // AvailableExits.Remove(SelectedExit);
        if(LastSpawnedRoom != nullptr)
        {
            LastSpawnedRoom->Destroy();
        }
        INC_DWORD_STAT(STAT_RoomsDeleted);
        ExitsToFill.Add(SelectedExit);
    }
    // 11. Continue the spawning process (using your delay mechanism if needed).
    ContinueSpawnNextRoom();
}

SpawnSpecialRoom()

void AProceduralDungeonBuilder::SpawnSpecialRoom ( )

protected

The function that Spawns from the Special rooms List, only creating a certain amount of them

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnSpecialRoom);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    // 1. Choose an exit from an already placed room.
    // LogDebugWarning("SpawnSpecialRoom.");
    SelectedExit = GetNextExit();
    if(SelectedExit == nullptr)
    {
        LogDebugError("SpawnSpecialRoom No available exit found.");
        return;
    }
    // 2. Pick a candidate room.
    UClass* SelectedRoomClass = GetSpecialRoomClass();
    if(SelectedRoomClass == nullptr)
    {
        LogDebugError("SpawnSpecialRoom SelectedRoomClass nullptr.");
        return;
    }
 
    // 3.1 Look up the precomputed data for the candidate room.
    FDungeonSpawnRoom* RoomData = RoomTypes.Find(SelectedRoomClass);
    if(RoomData == nullptr)
    {
        LogDebugError(FString::Printf(TEXT("SpawnSpecialRoom: No precomputed data for %s"), *SelectedRoomClass->GetName()));
        return;
    }
    // LogDebugWarning("SpawnSpecialRoom. SpawnTransform");
    // 4.1 Compute the candidate room’s world transform.
    const FTransform SpawnTransform = SelectedExit->GetComponentTransform();
 
    // 5.1 Compute the candidate room’s world bounds.
    // const FBox CandidateWorldBounds = RoomData->LocalBounds.TransformBy(SpawnTransform);
    const FBox CandidateWorldBounds = RoomData->CalculatedRoomBounds.TransformBy(SpawnTransform);
 
    // 6. Check for overlap using our math (not physics overlaps).
    if(IsOverlapping(CandidateWorldBounds))
    {
        LogDebugError(FString::Printf(TEXT("SpawnSpecialRoom: Candidate room would overlap an existing room %s"), *SelectedRoomClass->GetName()));
        // Option: Remove this exit so we do not try it again, then try spawning a room on another exit.
        AttemptChecker++;
        INC_DWORD_STAT(STAT_GenerateAttempts);
        if(AttemptChecker < RoomAttemptsBeforeFail)
        {
            SpawnSpecialRoom();
        }
        else
        {
            SpawnNextRoom();
        }
        return;
    }
    //LogDebugWarning("SpawnSpecialRoom. SpawnActor");
 
    // 7. Spawn the candidate room using the computed transform.
    LastSpawnedRoom = GetWorld()->SpawnActor<AActor>(SelectedRoomClass, SpawnTransform, SpawnParams);
    AvailableExits.Remove(SelectedExit);
    const bool bValidRoom = SetDungeonValues();
    if(bValidRoom)
    {
        AttemptChecker = 0;
        LogDebugMessage(FString::Printf(TEXT("SpawnSpecialRoom: Room Spawned: %s"), *SelectedRoomClass->GetName()));
        // 8. Save the candidate room’s bounds so future rooms can check against it.
        PlacedRoomBounds.Add(CandidateWorldBounds);
        RoomData->NumberSpawned++;
    }
    else
    {
        // AvailableExits.Remove(SelectedExit);
        if(LastSpawnedRoom != nullptr)
        {
            LastSpawnedRoom->Destroy();
        }
        INC_DWORD_STAT(STAT_RoomsDeleted);
        ExitsToFill.Add(SelectedExit);
    }
    //LogDebugWarning("SpawnSpecialRoom. ContinueSpawnNextRoom");
    // 11. Continue the spawning process (using your delay mechanism if needed).
    ContinueSpawnNextRoom();
}

SpawnStartingRoom()

void AProceduralDungeonBuilder::SpawnStartingRoom ( )

protected

Create first room at Actors location

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AProceduralDungeonBuilder::SpawnStartingRoom);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons);
    SCOPE_CYCLE_COUNTER(STAT_ProceduralDungeons_Builder);
    SET_DWORD_STAT(STAT_RoomsCreated, 0);
    SET_DWORD_STAT(STAT_RoomsDeleted, 0)
    SET_DWORD_STAT(STAT_GenerateAttempts, 0);
    if(bLogDungeonSteps){LogDebugWarning("SpawnStartingRoom");}
    if(RootComponent == nullptr){LogDebugError("SpawnStartingRoom RootComponent");return;}
 
    UClass* StartingRoomClass = GetStartingRoomClass();
    if(StartingRoomClass == nullptr){LogDebugError("SpawnStartingRoom StartingRoomClass");return;}
    
    const FTransform StartTransform = RootComponent->GetComponentTransform();
 
    LastSpawnedRoom = GetWorld()->SpawnActor(StartingRoomClass, &StartTransform, SpawnParams);
    if(bAddStartingExit)
    {
        RootComponent->SetRelativeRotation(FRotator(0.0f, 180.0f,0.0f));
        AvailableExits.Add(RootComponent);
    }
    const bool bValidRoom = SetDungeonValues();
    if(bValidRoom)
    {
        // if(bUseSpawnNextRoomMathematically)
        // {
        const FDungeonSpawnRoom* RoomData = RoomTypes.Find(StartingRoomClass);
        if(RoomData == nullptr)
        {
            LogDebugError(FString::Printf(TEXT("SpawnNextRoomMathematically: No precomputed data for %s"), *StartingRoomClass->GetName()));
            return;
        }
        const FBox CandidateWorldBounds = RoomData->CalculatedRoomBounds.TransformBy(StartTransform);
        PlacedRoomBounds.Add(CandidateWorldBounds);
        // }
    }
    else
    {
        LogDebugError("SpawnStartingRoom Starting room Failed");
    }
}

Member Data Documentation

AISpawned

int32 AProceduralDungeonBuilder::AISpawned = 0

private

Number of rooms spawned

AISpawns

TArray<USceneComponent*> AProceduralDungeonBuilder::AISpawns

protected

AISpawnsFailed

TArray<USceneComponent*> AProceduralDungeonBuilder::AISpawnsFailed

protected

AISpawnsSelected

TArray<USceneComponent*> AProceduralDungeonBuilder::AISpawnsSelected

protected

AIToSpawn

int32 AProceduralDungeonBuilder::AIToSpawn = 10

protected

AITypes

TArray<TSubclassOf<AActor> > AProceduralDungeonBuilder::AITypes

protected

AllDungeonRooms

TArray<IDungeonRoom*> AProceduralDungeonBuilder::AllDungeonRooms

private

AttemptChecker

int32 AProceduralDungeonBuilder::AttemptChecker = 0

private

Total times we have tried to spawn a room

AvailableExits

TArray<USceneComponent*> AProceduralDungeonBuilder::AvailableExits

protected

All available Exit Components

bAddStartingExit

bool AProceduralDungeonBuilder::bAddStartingExit = false

private

bApplyDynamicMaterial

bool AProceduralDungeonBuilder::bApplyDynamicMaterial = true

protected

bCheckForJoiningRooms

bool AProceduralDungeonBuilder::bCheckForJoiningRooms = true

protected

bCheckRoomExitCount

bool AProceduralDungeonBuilder::bCheckRoomExitCount = false

protected

bCheckRoomTypes

bool AProceduralDungeonBuilder::bCheckRoomTypes = true

protected

bComplete

bool AProceduralDungeonBuilder::bComplete = false

protected

If the builder is complete

bCreatedInEditor

bool AProceduralDungeonBuilder::bCreatedInEditor = false

private

If the Dungeon was created in Editor

bCreateOnBeginPlay

bool AProceduralDungeonBuilder::bCreateOnBeginPlay = true

protected

bDebuggingMode

bool AProceduralDungeonBuilder::bDebuggingMode = true

private

bDelayEachAISpawn

bool AProceduralDungeonBuilder::bDelayEachAISpawn = false

private

bDelayEachDoorSpawn

bool AProceduralDungeonBuilder::bDelayEachDoorSpawn = false

private

bDelayEachRoomBuild

bool AProceduralDungeonBuilder::bDelayEachRoomBuild = false

private

For showing the build process slowly, which can make it easier to find faults

bDeleteExitBeforeSpawn

bool AProceduralDungeonBuilder::bDeleteExitBeforeSpawn = true

private

Should a possible exit be removed once selected, or after the actor has spawned false will guarantee that all rooms will try to spawn, causing more memory leaks true will remove exits that have failed to spawn a room, causing more fills, and likely fewer rooms than intended

bDrawFailedExits

bool AProceduralDungeonBuilder::bDrawFailedExits = false

private

bFillWithDeadEndRooms

bool AProceduralDungeonBuilder::bFillWithDeadEndRooms = false

protected

bGetClosestExit

bool AProceduralDungeonBuilder::bGetClosestExit = false

protected

bGiveRoomsRandomStream

bool AProceduralDungeonBuilder::bGiveRoomsRandomStream = false

private

bHasInvalidClass

bool AProceduralDungeonBuilder::bHasInvalidClass = false

private

Saves if one of the Rooms is invalid

bHideRoomRoofs

bool AProceduralDungeonBuilder::bHideRoomRoofs = false

private

bLimitDoors

bool AProceduralDungeonBuilder::bLimitDoors = true

protected

bLogDungeonSteps

bool AProceduralDungeonBuilder::bLogDungeonSteps = false

private

Log Each Main function of the builder

bLogDungeonSummary

bool AProceduralDungeonBuilder::bLogDungeonSummary = true

private

Log main stats after build complete

bRandomGetClosestExit

bool AProceduralDungeonBuilder::bRandomGetClosestExit = false

protected

bResetRoomTypesOnComplete

bool AProceduralDungeonBuilder::bResetRoomTypesOnComplete = false

private

bSpawnDoors

bool AProceduralDungeonBuilder::bSpawnDoors = true

protected

Actor with collision to Check if 2 rooms are joining

BuildDelayHandle

FTimerHandle AProceduralDungeonBuilder::BuildDelayHandle

private

BuildDelayTime

float AProceduralDungeonBuilder::BuildDelayTime = 0.1f

private

bUseGameModeStream

bool AProceduralDungeonBuilder::bUseGameModeStream = true

protected

bUseRandomNumberOfRooms

bool AProceduralDungeonBuilder::bUseRandomNumberOfRooms = false

protected

If true, Set the NumberOfRooms to the Max Amount

bUseRandomSeed

bool AProceduralDungeonBuilder::bUseRandomSeed = true

protected

bUsingGameModeSteam

bool AProceduralDungeonBuilder::bUsingGameModeSteam = false

protected

CheckRoomExitCountMin

int32 AProceduralDungeonBuilder::CheckRoomExitCountMin = 3

protected

DoorLimit

int32 AProceduralDungeonBuilder::DoorLimit = 10

protected

DoorLocations

TArray<USceneComponent*> AProceduralDungeonBuilder::DoorLocations

protected

DoorSpawnsFailed

TArray<USceneComponent*> AProceduralDungeonBuilder::DoorSpawnsFailed

protected

DoorSpawnsSelected

TArray<USceneComponent*> AProceduralDungeonBuilder::DoorSpawnsSelected

protected

DoorsSpawned

int32 AProceduralDungeonBuilder::DoorsSpawned = 0

private

DoorTypes

TArray<TSubclassOf<AActor> > AProceduralDungeonBuilder::DoorTypes

protected

DoorWeights

TArray<int32> AProceduralDungeonBuilder::DoorWeights

protected

How likely the Door is to be picked, 1 Standard, 2 double

DungeonActors

TArray<AActor*> AProceduralDungeonBuilder::DungeonActors

protected

ExitLocationDistanceOverlap

float AProceduralDungeonBuilder::ExitLocationDistanceOverlap = 0.1f

private

The max distance two exits have to be auto deleted

ExitsToFill

TArray<USceneComponent*> AProceduralDungeonBuilder::ExitsToFill

protected

Exits that failed to spawn, but should be filed

LastSpawnedRoom

AActor* AProceduralDungeonBuilder::LastSpawnedRoom = nullptr

protected

The Last Room that was Created

MaterialDataTable

class UDataTable* AProceduralDungeonBuilder::MaterialDataTable = nullptr

protected

MinNumberOfRoomsToSpawn

int32 AProceduralDungeonBuilder::MinNumberOfRoomsToSpawn = 2

protected

NullRandomStream

FRandomStream AProceduralDungeonBuilder::NullRandomStream

private

NumberOfRoomsToSpawn

int32 AProceduralDungeonBuilder::NumberOfRoomsToSpawn = 50

protected

OverlappedComponents

TArray<UPrimitiveComponent*> AProceduralDungeonBuilder::OverlappedComponents

protected

PlacedRoomBounds

TArray<FBox> AProceduralDungeonBuilder::PlacedRoomBounds

protected

RandomClosesExitWeight

float AProceduralDungeonBuilder::RandomClosesExitWeight = 0.5f

protected

RandomStream

FRandomStream AProceduralDungeonBuilder::RandomStream

private

Stored Stream to generate Random Numbers

RandomStreamPtr

FRandomStream* AProceduralDungeonBuilder::RandomStreamPtr = nullptr

private

RoomAttemptsBeforeFail

int32 AProceduralDungeonBuilder::RoomAttemptsBeforeFail = 5

private

How many times should we try to spawn a room before giving up, any higher than 5 is too risky

RoomAttemptsMathMultiplier

int32 AProceduralDungeonBuilder::RoomAttemptsMathMultiplier = 5

private

Math Function is calculated differently, so it can have more Attempts

RoomChecker

TSubclassOf<AActor> AProceduralDungeonBuilder::RoomChecker = nullptr

protected

RoomMaterial

UMaterialInterface* AProceduralDungeonBuilder::RoomMaterial = nullptr

protected

RoomMaterialInstance

UMaterialInstanceDynamic* AProceduralDungeonBuilder::RoomMaterialInstance = nullptr

protected

RoomsSpawned

int32 AProceduralDungeonBuilder::RoomsSpawned = 0

private

Number of rooms spawned

RoomTypes

FDungeonSpawns AProceduralDungeonBuilder::RoomTypes

protected

List of the Room types to Spawn in

Seed

int32 AProceduralDungeonBuilder::Seed = 0

protected

SelectedAISpawn

USceneComponent* AProceduralDungeonBuilder::SelectedAISpawn = nullptr

protected

SelectedDoorSpawn

USceneComponent* AProceduralDungeonBuilder::SelectedDoorSpawn = nullptr

protected

SelectedExit

USceneComponent* AProceduralDungeonBuilder::SelectedExit = nullptr

protected

SpawnParams

FActorSpawnParameters AProceduralDungeonBuilder::SpawnParams

private

SpecialRoomTypeClasses

TArray<TSubclassOf<AActor> > AProceduralDungeonBuilder::SpecialRoomTypeClasses

protected

StartingAIToSpawn

int32 AProceduralDungeonBuilder::StartingAIToSpawn = 0

private

Saved Starting Special Rooms

StartingNumberOfRoomsToSpawn

int32 AProceduralDungeonBuilder::StartingNumberOfRoomsToSpawn = 0

private

Saved number of rooms we are trying to spawn

StartingRoomNumber

int32 AProceduralDungeonBuilder::StartingRoomNumber = 0

protected

From the RoomTypes Array, set to -1 for Random

StartingRoomTypes

FDungeonSpawns AProceduralDungeonBuilder::StartingRoomTypes

private

Saved Starting room Classes

TotalNumberOfRoomsToSpawn

int32 AProceduralDungeonBuilder::TotalNumberOfRoomsToSpawn = 0

private

Saved number of rooms * the Random Amount

WallFill

TSubclassOf<AActor> AProceduralDungeonBuilder::WallFill = nullptr

protected

Wall to fill in any gaps

---

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

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