DungeonData.h

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Interfaces/DungeonRoom.h"
#include "Data/DungeonEnums.h"
#include "DungeonData.generated.h"
 
class IDungeonRoom;
 
 
DECLARE_STATS_GROUP(TEXT("Procedural Dungeons"), STATGROUP_ProceduralDungeons, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT(TEXT("Procedural Dungeons (All Functions)"), STAT_ProceduralDungeons, STATGROUP_ProceduralDungeons);
DECLARE_CYCLE_STAT(TEXT("Builder (All Functions)"), STAT_ProceduralDungeons_Builder, STATGROUP_ProceduralDungeons);
DECLARE_CYCLE_STAT(TEXT("Rooms (All Functions)"), STAT_ProceduralDungeons_Rooms, STATGROUP_ProceduralDungeons);
DECLARE_CYCLE_STAT(TEXT("BP Library (All Functions)"), STAT_ProceduralDungeons_BPLib, STATGROUP_ProceduralDungeons);
 
DECLARE_DWORD_COUNTER_STAT(TEXT("Dungeon Rooms"), STAT_RoomsCreated, STATGROUP_ProceduralDungeons);
DECLARE_DWORD_COUNTER_STAT(TEXT("Dungeon Rooms Destoryed"), STAT_RoomsDeleted, STATGROUP_ProceduralDungeons);
DECLARE_DWORD_COUNTER_STAT(TEXT("Dungeon Room Attempts"), STAT_GenerateAttempts, STATGROUP_ProceduralDungeons);
 
DECLARE_LOG_CATEGORY_CLASS(LogDungeonData, Display, All);
 
 
USTRUCT(BlueprintType)
struct FDungeonSpecialItem
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Special Room")
    TSubclassOf<AActor> Class = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Special Room")
    int32 NumberToSpawn = 1;
 
    // Default constructor
    FDungeonSpecialItem() {}
 
    // Parameterized constructor
    FDungeonSpecialItem(const TSubclassOf<AActor> InClass, const int32 InNumberToSpawn)
        : Class(InClass), NumberToSpawn(InNumberToSpawn) {}
 
    bool operator==(const FDungeonSpecialItem& Other) const
    {
        if(Other.Class == Class){return true;}
        return false;
    }
};
 
 
 
// Check if this is used anywhere?
// Use as Not Arrays or Types, but for just one type, With it's own Weight, etc.
// Then the builder will just have an array of this 
USTRUCT(BlueprintType)
struct FDungeonSpawnRoom
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    TSubclassOf<AActor> Type = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    int32 TypeWeight = 1;
 
    //@TODO make Enum? or Tag for type of room, then can spawn room or hallways etc.
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    // FString TypeTag = "Hallway";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bDisable = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bSpawnLimit = false;
    // -1 is not limit
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General", meta=(EditCondition=bSpawnLimit))
    int32 NumberToSpawn = -1;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Spawn")
    int32 NumberSpawned = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    bool bRequired = false;
    
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Calculated")
    bool bCalculatedValues = false;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Calculated")
    int32 CalculatedExits = 0;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Calculated")
    EDungeonRoomType CalculatedType = EDungeonRoomType::Hallway;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Calculated")
    FBox CalculatedRoomBounds = FBox(FVector::ZeroVector, FVector::ZeroVector);
 
    bool GetHasSpawnedLimit() const
    {
        if(bSpawnLimit)
        {
            return NumberSpawned >= NumberToSpawn;
        }
        return false;
    }
 
 
    int32 GetExits() const
    {
        return CalculatedExits;
        // if(Type == nullptr){UE_LOG(LogDungeonData, Warning, TEXT("FDungeonSpawnType::GetExits Type Failed"));return 0;}
        // // BUG Get Exits doesn't seem to work on Default Object 
        // const IDungeonRoom* DungeonRoomClass = Cast<IDungeonRoom>(Type.GetDefaultObject());
        // if(DungeonRoomClass == nullptr){UE_LOG(LogDungeonData, Warning, TEXT("FDungeonSpawnType::GetExits DungeonRoomClass Failed"));return 0;}
        // return DungeonRoomClass->GetNumOfExits();
    }
 
    FDungeonSpawnRoom()
    {
    }
    
    //@TODO Add sizes
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Spawn Type")
    // int32 Size = 0;
    // Get Size from Class?
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Spawn Type")
    // TArray<int32> CompatibleSizes;
    
    
    TArray<TSubclassOf<AActor>>& GetWeightedTypes()
    {
        if(Type == nullptr){UE_LOG(LogDungeonData, Error, TEXT("FDungeonSpawnRoom::GetWeightedTypes No Valid Type"));return WeightedTypes;}
        WeightedTypes.Empty();
        for(int32 i = 0; i < TypeWeight; ++i)
        {
            WeightedTypes.Add(Type);
        }
        return WeightedTypes;
    };
 
private:
    TArray<TSubclassOf<AActor>> WeightedTypes;
    
public:
    bool operator==(const FDungeonSpawnRoom& Other) const
    {
        if(Other.Type == Type){return true;}
        return false;
    }
    bool operator!=(const FDungeonSpawnRoom& Other) const
    {
        if(Other.Type != Type){return true;}
        return false;
    }
    bool IsValid() const
    {
        if(Type == nullptr)
        {
            return false;
        }
        if(Type->ImplementsInterface(UDungeonRoom::StaticClass()) == false)
        {
            UE_LOG(LogDungeonData, Error, TEXT("FDungeonSpawnRoom::IsValid Please Remove RoomType %s Doesn't Implement Interface"), *Type->GetName());
            return false;
        }
        return true;
    }
};
 
USTRUCT(BlueprintType)
struct FDungeonSpawns
{
    GENERATED_BODY()
 
    // Protected?
    
    
    TArray<FDungeonSpawnRoom> GetAllRooms() const
    {
        return GetRoomsWithNumOfExits(0);
    }
    
    TArray<FDungeonSpawnRoom>& GetRooms()
    {
        return Rooms;
    }
 
    TArray<FDungeonSpawnRoom> GetRoomsOfType(const TSubclassOf<AActor> ActorClass)
    {
        TArray<FDungeonSpawnRoom> SelectedRooms;
        for(auto& Room : Rooms)
        {
            if(Room.Type == ActorClass)
            {
                SelectedRooms.Add(Room);
            }
        }
        return SelectedRooms;
    }
 
 
 
    /* Will only return rooms with exits */
    TArray<FDungeonSpawnRoom> GetRoomsWithExits() const
    {
        return GetRoomsWithNumOfExits(1);
    }
    /* Will only return dead end rooms */
    TArray<FDungeonSpawnRoom> GetRoomsWithNoExits() const
    {
        return GetRoomsWithNumOfExits(0, 0);
    }
 
    /* Will return ALL rooms with minExits or more */ 
    TArray<FDungeonSpawnRoom> GetRoomsWithNumOfExits(const int32 MinExits) const
    {
        TArray<FDungeonSpawnRoom> SelectedRooms;
        for(int32 i = 0; i < Rooms.Num(); ++i)
        {
            if(Rooms[i].IsValid() == false){UE_LOG(LogDungeonData, Warning, TEXT("FDungeonSpawns::GetRoomsWithNumOfExits Room %i Not Valid"), i);continue;}
            // UE_LOG(LogDungeonData, Warning, TEXT("Rooms %s GetExits: %i"), *Rooms[i].Type->GetName(), Rooms[i].GetExits());
            if(Rooms[i].GetExits() >= MinExits)
            {
                SelectedRooms.AddUnique(Rooms[i]);
            }
        }
        return SelectedRooms;
    }
    TArray<FDungeonSpawnRoom> GetRoomsWithNumOfExits(const int32 MinExits, const int32 MaxExits) const
    {
        TArray<FDungeonSpawnRoom> SelectedRooms;
        for(int32 i = 0; i < Rooms.Num(); ++i)
        {
            if(Rooms[i].IsValid() == false){UE_LOG(LogDungeonData, Warning, TEXT("FDungeonSpawns::GetRoomsWithNumOfExits Room %i Not Valid"), i);continue;}
            // if(Rooms[i].GetExits() >= MinExits && Rooms[i].GetExits() <= MaxExits)
            if(Rooms[i].GetExits() >= MinExits && Rooms[i].GetExits() <= MaxExits)
            {
                // This needs to add the room with weights
                SelectedRooms.AddUnique(Rooms[i]);
            }
        }
        return SelectedRooms;
    }
 
    FDungeonSpawnRoom* Find(const TSubclassOf<AActor> ActorClass)
    {
        for(auto& Room : Rooms)
        {
            if(Room.Type == ActorClass)
            {
                return &Room;
            }
        }
        return nullptr;
    }
    EDungeonRoomType FindType(const TSubclassOf<AActor> ActorClass) const
    {
        for(auto& Room : Rooms)
        {
            if(Room.Type == ActorClass)
            {
                return Room.CalculatedType;
            }
        }
        return EDungeonRoomType::Hallway;
    }
 
    
    bool IsEmpty() const
    {
        return Rooms.IsEmpty();
    }
    bool IsValidIndex(const int32 Index) const
    {
        return Rooms.IsValidIndex(Index);
    }
    int32 Num() const
    {
        return Rooms.Num();
    }
 
    FDungeonSpawns()
    {
        
    }
    explicit FDungeonSpawns(const TArray<FDungeonSpawnRoom>& InitialRooms)
    {
        Rooms = InitialRooms;
    }
 
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    TArray<FDungeonSpawnRoom> Rooms;
 
};
 
 
class PROCEDURALDUNGEONS_API DungeonData
{
public:
};