From 7b711b79b57a060a1fe33ee656fb1381b2c3188a Mon Sep 17 00:00:00 2001 From: Relintai Date: Sat, 20 Apr 2019 14:51:33 +0200 Subject: [PATCH] Initial commit. --- .gitignore | 5 ++ DungeonCorridor.cpp | 125 ++++++++++++++++++++++++++ DungeonCorridor.h | 49 +++++++++++ DungeonEndRoom.cpp | 37 ++++++++ DungeonEndRoom.h | 19 ++++ DungeonGenerator.cpp | 205 +++++++++++++++++++++++++++++++++++++++++++ DungeonGenerator.h | 83 ++++++++++++++++++ DungeonRoom.cpp | 161 +++++++++++++++++++++++++++++++++ DungeonRoom.h | 64 ++++++++++++++ DungeonStartRoom.cpp | 23 +++++ DungeonStartRoom.h | 27 ++++++ IntRect.cpp | 46 ++++++++++ IntRect.h | 39 ++++++++ SCsub | 4 + TileConsts.cpp | 71 +++++++++++++++ TileConsts.h | 63 +++++++++++++ config.py | 5 ++ config.pyc | Bin 0 -> 427 bytes register_types.cpp | 10 +++ register_types.h | 3 + 20 files changed, 1039 insertions(+) create mode 100644 .gitignore create mode 100644 DungeonCorridor.cpp create mode 100644 DungeonCorridor.h create mode 100644 DungeonEndRoom.cpp create mode 100644 DungeonEndRoom.h create mode 100644 DungeonGenerator.cpp create mode 100644 DungeonGenerator.h create mode 100644 DungeonRoom.cpp create mode 100644 DungeonRoom.h create mode 100644 DungeonStartRoom.cpp create mode 100644 DungeonStartRoom.h create mode 100644 IntRect.cpp create mode 100644 IntRect.h create mode 100644 SCsub create mode 100644 TileConsts.cpp create mode 100644 TileConsts.h create mode 100644 config.py create mode 100644 config.pyc create mode 100644 register_types.cpp create mode 100644 register_types.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5230b5a --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.import +*.d +*.o +*.meta + diff --git a/DungeonCorridor.cpp b/DungeonCorridor.cpp new file mode 100644 index 0000000..7bee6d7 --- /dev/null +++ b/DungeonCorridor.cpp @@ -0,0 +1,125 @@ +#include "DungeonCorridor.h" +namespace BS { + namespace Levels { + namespace Generator { + DungeonRoom* DungeonCorridor::getStartRoom(){ + return this->startRoom; + } + void DungeonCorridor::setStartRoom(DungeonRoom* value) + { + this->startRoom = value; + } + DungeonRoom* DungeonCorridor::getEndRoom() + { + return this->endRoom; + } + void DungeonCorridor::setEndRoom(DungeonRoom* value) + { + this->endRoom = value; + } + DungeonCorridor::DungeonCorridor(int size, DungeonRoom* startRoom, DungeonRoom* endRoom) + { + size = 4; + this->size = size; + this->setStartRoom(startRoom); + this->setEndRoom(endRoom); + } + void DungeonCorridor::GenerateCorridor(ArrayND* dungeon) + { + int num = this->getStartRoom()->X + Mathf::RoundToInt((float)(this->getStartRoom()->Width) / (float)2); + int num2 = this->getStartRoom()->Y + Mathf::RoundToInt((float)(this->getStartRoom()->Height) / (float)2); + int num3 = this->getEndRoom()->X + Mathf::RoundToInt((float)(this->getEndRoom()->Width) / (float)2); + int num4 = this->getEndRoom()->Y + Mathf::RoundToInt((float)(this->getEndRoom()->Height) / (float)2); + if ((num <= num3) && (num2 <= num4)) { + this->widthir = new IntRect(num, num2, num3 - num, this->size); + this->heightir = new IntRect((this->widthir->X + this->widthir->Width) - this->size, num2, this->size, num4 - num2); + } + else { + if ((num > num3) && (num2 <= num4)) { + this->widthir = new IntRect(num3, num2, num - num3, this->size); + this->heightir = new IntRect(this->widthir->X, num2, this->size, num4 - num2); + } + else { + if ((num <= num3) && (num2 > num4)) { + this->widthir = new IntRect(num, num4, num3 - num, this->size); + this->heightir = new IntRect(num, num4, this->size, num2 - num4); + } + else { + if ((num > num3) && (num2 > num4)) { + this->widthir = new IntRect(num3 - this->size, num2 - this->size, num - num3, this->size); + this->heightir = new IntRect(this->widthir->X, num4, this->size, num2 - num4); + } + } + } + } + this->Write(dungeon, this->widthir); + this->Write(dungeon, this->heightir); + } + void DungeonCorridor::Write(ArrayND* dungeon, IntRect* rect) + { + for (int i = rect->getY(); i < (rect->getY() + rect->getHeight()); i += 1) { + for (int j = rect->getX(); j < (rect->getX() + rect->getWidth()); j += 1) { + if (((*(dungeon->GetData(j, i)) != 1) && (*(dungeon->GetData(j, i)) != 2)) && (*(dungeon->GetData(j, i)) != 20)) { + if ((j == rect->getX()) && (i == rect->getY())) { + dungeon->SetData(j, i, 13); + } + else { + if ((j == rect->getX()) && (i == ((rect->getY() + rect->getHeight()) - 1))) { + dungeon->SetData(j, i, 13); + } + else { + if ((j == ((rect->getX() + rect->getWidth()) - 1)) && (i == rect->getY())) { + dungeon->SetData(j, i, 13); + } + else { + if ((j == ((rect->getX() + rect->getWidth()) - 1)) && (i == ((rect->getY() + rect->getHeight()) - 1))) { + dungeon->SetData(j, i, 13); + } + else { + if (j == rect->getX()) { + dungeon->SetData(j, i, 14); + } + else { + if (j == ((rect->getX() + rect->getWidth()) - 1)) { + dungeon->SetData(j, i, 12); + } + else { + if (i == rect->getY()) { + dungeon->SetData(j, i, 13); + } + else { + if (i == ((rect->getY() + rect->getHeight()) - 1)) { + dungeon->SetData(j, i, 11); + } + else { + dungeon->SetData(j, i, 1); + } + } + } + } + } + } + } + } + } + } + } + } + void DungeonCorridor::GenerateAIPlayers(int level) + { + this->GenerateAIPlayers(level, this->widthir); + this->GenerateAIPlayers(level, this->heightir); + } + void DungeonCorridor::GenerateAIPlayers(int level, IntRect* rect) + { + int num = UnityEngine::Random::Range(0, 3); + for (int i = 0; i < num; i += 1) { + int num2 = rect->getX() + UnityEngine::Random::Range(1, rect->getWidth() - 2); + int num3 = rect->getY() + UnityEngine::Random::Range(1, rect->getHeight() - 2); + new Vector3(((float)(num2) * Voxelizzer::world->voxelScale) * (float)2, Voxelizzer::world->voxelScale, ((float)(num3) * Voxelizzer::world->voxelScale) * (float)2); + } + } + + } + } +} diff --git a/DungeonCorridor.h b/DungeonCorridor.h new file mode 100644 index 0000000..e571b04 --- /dev/null +++ b/DungeonCorridor.h @@ -0,0 +1,49 @@ +#pragma once +#include +#include "DungeonRoom.h" +#include "IntRect.h" +#include "Mathf.h" +#include "UnityEngine.h" +#include "Vector3.h" +#include "Voxelizzer.h" + +using namespace UnityEngine; +using namespace VoxelToolbox; +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class DungeonCorridor : public virtual Object + { + private: + DungeonRoom* startRoom; + private: + DungeonRoom* endRoom; + public: + int size; + private: + IntRect* widthir; + private: + IntRect* heightir; + public: + DungeonRoom* getStartRoom(); + public: + void setStartRoom(DungeonRoom* value); + public: + DungeonRoom* getEndRoom(); + public: + void setEndRoom(DungeonRoom* value); + public: + DungeonCorridor(int size, DungeonRoom* startRoom, DungeonRoom* endRoom); + public: + void GenerateCorridor(ArrayND* dungeon); + private: + void Write(ArrayND* dungeon, IntRect* rect); + public: + virtual void GenerateAIPlayers(int level); + private: + void GenerateAIPlayers(int level, IntRect* rect); + }; + } + } +} diff --git a/DungeonEndRoom.cpp b/DungeonEndRoom.cpp new file mode 100644 index 0000000..05cc920 --- /dev/null +++ b/DungeonEndRoom.cpp @@ -0,0 +1,37 @@ +#include "DungeonEndRoom.h" +namespace BS { + namespace Levels { + namespace Generator { + DungeonEndRoom::DungeonEndRoom(int x, int y, int width, int height) : DungeonRoom(x, y, width, height){ + } + void DungeonEndRoom::WriteRoom(ArrayND* dungeon) + { + for (int i = DungeonRoom::getY(); i < (DungeonRoom::getY() + DungeonRoom::getHeight()); i += 1) { + for (int j = DungeonRoom::getX(); j < (DungeonRoom::getX() + DungeonRoom::getWidth()); j += 1) { + dungeon->SetData(j, i, 1); + } + } + for (int k = DungeonRoom::getX() + 1; k < ((DungeonRoom::getX() + DungeonRoom::getWidth()) - 1); k += 1) { + dungeon->SetData(k, (DungeonRoom::getY() + DungeonRoom::getHeight()) - 1, 11); + } + for (int l = DungeonRoom::getX() + 1; l < ((DungeonRoom::getX() + DungeonRoom::getWidth()) - 1); l += 1) { + dungeon->SetData(l, DungeonRoom::getY(), 13); + } + for (int m = DungeonRoom::getY() + 1; m < ((DungeonRoom::getY() + DungeonRoom::getHeight()) - 1); m += 1) { + dungeon->SetData(DungeonRoom::getX(), m, 14); + } + for (int n = DungeonRoom::getY() + 1; n < ((DungeonRoom::getY() + DungeonRoom::getHeight()) - 1); n += 1) { + dungeon->SetData((DungeonRoom::getX() + DungeonRoom::getWidth()) - 1, n, 12); + } + dungeon->SetData(DungeonRoom::getX(), DungeonRoom::getY(), 13); + dungeon->SetData((DungeonRoom::getX() + DungeonRoom::getWidth()) - 1, DungeonRoom::getY(), 13); + dungeon->SetData(DungeonRoom::getX(), (DungeonRoom::getY() + DungeonRoom::getHeight()) - 1, 13); + dungeon->SetData((DungeonRoom::getX() + DungeonRoom::getWidth()) - 1, (DungeonRoom::getY() + DungeonRoom::getHeight()) - 1, 13); + int num = UnityEngine::Random::Range(DungeonRoom::getX() + 1, (DungeonRoom::getX() + DungeonRoom::getWidth()) - 1); + int num2 = UnityEngine::Random::Range(DungeonRoom::getY() + 1, (DungeonRoom::getY() + DungeonRoom::getHeight()) - 1); + dungeon->SetData(num, num2, 20); + } + + } + } +} diff --git a/DungeonEndRoom.h b/DungeonEndRoom.h new file mode 100644 index 0000000..c86e52f --- /dev/null +++ b/DungeonEndRoom.h @@ -0,0 +1,19 @@ +#pragma once +#include +#include "DungeonRoom.h" +#include "UnityEngine.h" + +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class DungeonEndRoom : public virtual DungeonRoom, public virtual Object + { + public: + DungeonEndRoom(int x, int y, int width, int height); + public: + virtual void WriteRoom(ArrayND* dungeon); + }; + } + } +} diff --git a/DungeonGenerator.cpp b/DungeonGenerator.cpp new file mode 100644 index 0000000..f21ef90 --- /dev/null +++ b/DungeonGenerator.cpp @@ -0,0 +1,205 @@ +#include "DungeonGenerator.h" +namespace BS { + namespace Levels { + namespace Generator { + ArrayND* DungeonGenerator::getDungeon(){ + return this->dungeon; + } + void DungeonGenerator::Awake() + { + this->rooms = new List_T(); + this->corridors = new List_T(); + this->dungeon = new ArrayND(this->DUNGEON_Size_X, this->DUNGEON_Size_Y); + } + void DungeonGenerator::Generate(int level) + { + UnityEngine::Random::InitState(BrokenSeals::Game->Seed); + if (!CxNet::IsServer) { + this->SpawnMobs = false; + } + this->GenerateDungeon(); + this->GenerateCorridors(); + this->PreprocessDungeonSimple(); + this->GeneratePlayers(level); + } + void DungeonGenerator::GenerateDungeon() + { + for (int i = 0; i < this->ROOM_PLACEMENT_TRIES; i += 1) { + int x = UnityEngine::Random::Range(0, this->DUNGEON_Size_X - this->ROOM_MAX_SIZE); + int y = UnityEngine::Random::Range(0, this->DUNGEON_Size_Y - this->ROOM_MAX_SIZE); + int width = UnityEngine::Random::Range(this->ROOM_MIN_SIZE, this->ROOM_MAX_SIZE); + int height = UnityEngine::Random::Range(this->ROOM_MIN_SIZE, this->ROOM_MAX_SIZE); + if (this->CanPlaceRoom(x, y, width, height)) { + if (this->rooms->Count > 0) { + DungeonRoom* dungeonRoom = new DungeonRoom(x, y, width, height); + dungeonRoom->WriteRoom(this->dungeon); + this->corridors->Add(new DungeonCorridor(this->CORRIDOR_SIZE, this->rooms->GetData(this->rooms->Count - 1), dungeonRoom)); + this->rooms->Add(dungeonRoom); + } + else { + DungeonStartRoom* dungeonStartRoom = new DungeonStartRoom(x, y, width, height); + dungeonStartRoom->WriteRoom(this->dungeon); + dungeonStartRoom->GenerateSpawnPoint(this->startPositionPrefab); + this->rooms->Add(dungeonStartRoom); + } + } + } + DungeonRoom* dungeonRoom2 = this->rooms->GetData(this->rooms->Count - 1); + this->rooms->Remove(dungeonRoom2); + this->corridors->RemoveAt(this->corridors->Count - 1); + DungeonEndRoom* dungeonEndRoom = new DungeonEndRoom(dungeonRoom2->getX(), dungeonRoom2->getY(), dungeonRoom2->getWidth(), dungeonRoom2->getHeight()); + this->corridors->Add(new DungeonCorridor(this->CORRIDOR_SIZE, this->rooms->GetData(this->rooms->Count - 1), dungeonEndRoom)); + this->rooms->Add(dungeonEndRoom); + dungeonEndRoom->WriteRoom(this->dungeon); + } + void DungeonGenerator::GenerateCorridors() + { + for (int i = 0; i < this->corridors->Count; i += 1) { + this->corridors->GetData(i)->GenerateCorridor(this->dungeon); + } + } + void DungeonGenerator::GeneratePlayers(int level) + { + if (!this->SpawnMobs) { + return; + } + for (int i = 0; i < this->rooms->Count; i += 1) { + this->rooms->GetData(i)->GenerateAIPlayers(level); + } + for (int j = 0; j < this->corridors->Count; j += 1) { + this->corridors->GetData(j)->GenerateAIPlayers(level); + } + } + void DungeonGenerator::PreprocessDungeonSimple() + { + for (int i = 1; i < this->DUNGEON_Size_X; i += 1) { + for (int j = 1; j < this->DUNGEON_Size_Y; j += 1) { + this->dungeon->GetData(i, j); + if (TileConsts::isWall(this->dungeon->GetData(i, j))) { + bool arg_68_0 = *(this->dungeon->GetData(i, j - 1)) == 0; + bool flag = *(this->dungeon->GetData(i - 1, j)) == 0; + bool flag2 = *(this->dungeon->GetData(i - 1, j - 1)) == 0; + if ((arg_68_0 | flag) | flag2) { + this->dungeon->SetData(i, j, 12); + } + } + } + } + } + void DungeonGenerator::PreprocessDungeon() + { + for (int i = 1; i < this->DUNGEON_Size_X; i += 1) { + for (int j = 1; j < this->DUNGEON_Size_Y; j += 1) { + char b = this->dungeon->GetData(i, j); + if (((b != 0) && (b != 1)) && (b != 20)) { + bool flag = TileConsts::isWall(this->dungeon->GetData(i, j + 1)); + bool flag2 = TileConsts::isWall(this->dungeon->GetData(i, j - 1)); + bool flag3 = TileConsts::isWall(this->dungeon->GetData(i - 1, j)); + bool flag4 = TileConsts::isWall(this->dungeon->GetData(i + 1, j)); + bool flag5 = TileConsts::isWall(this->dungeon->GetData(i + 1, j + 1)); + bool flag6 = TileConsts::isWall(this->dungeon->GetData(i - 1, j + 1)); + bool flag7 = TileConsts::isWall(this->dungeon->GetData(i + 1, j - 1)); + bool flag8 = TileConsts::isWall(this->dungeon->GetData(i - 1, j - 1)); + if (!flag & flag2) { + if (((!flag4 & flag) & flag3) && !flag2) { + this->dungeon->SetData(i, j, 17); + } + else { + if (((!flag4 && !flag) & flag3) & flag2) { + this->dungeon->SetData(i, j, 18); + } + else { + if (((!flag3 && !flag) & flag4) & flag2) { + this->dungeon->SetData(i, j, 17); + } + else { + if (((((((flag3 && !flag8) && !flag2) && !flag7) && !flag4) && !flag5) & flag) && !flag6) { + this->dungeon->SetData(i, j, 23); + } + else { + if ((!flag3 & flag) & flag4) { + } + if (((((((flag3 && !flag8) & flag2) && !flag7) && !flag4) && !flag5) && !flag) && !flag6) { + this->dungeon->SetData(i, j, 22); + } + else { + if (((((((!flag3 && !flag8) && !flag2) && !flag7) & flag4) && !flag5) & flag) && !flag6) { + this->dungeon->SetData(i, j, 21); + } + } + } + } + } + } + } + } + } + } + } + String* DungeonGenerator::StringifyDungeon() + { + this->sb = new StringBuilder(); + for (int i = 0; i < this->DUNGEON_Size_Y; i += 1) { + for (int j = 0; j < this->DUNGEON_Size_X; j += 1) { + if (*(this->dungeon->GetData(j, i)) != 0) { + this->sb->Append(j); + this->sb->Append(new String(";")); + this->sb->Append(i); + this->sb->Append(new String(";")); + this->sb->Append(this->dungeon->GetData(j, i)); + this->sb->Append(new String("|")); + } + } + } + return this->sb->ToString(); + } + void DungeonGenerator::GenerateDebugDungeon() + { + this->dungeon = new ArrayND(this->DUNGEON_Size_X, this->DUNGEON_Size_Y); + for (int i = 0; i < this->DUNGEON_Size_Y; i += 1) { + for (int j = 0; j < this->DUNGEON_Size_X; j += 1) { + this->dungeon->SetData(j, i, 1); + } + } + for (int k = 0; k < 300; k += 1) { + this->dungeon->SetData(UnityEngine::Random::Range(0, this->DUNGEON_Size_X), UnityEngine::Random::Range(0, this->DUNGEON_Size_Y), 2); + } + } + bool DungeonGenerator::CanPlaceRoom(int x, int y, int width, int height) + { + for (int i = y; i < (y + height); i += 1) { + for (int j = x; j < (x + width); j += 1) { + if (*(this->dungeon->GetData(j, i)) != 0) { + return false; + } + } + } + return true; + } + void DungeonGenerator::Reset() + { + if (this->rooms == null) { + return; + } + this->rooms->Clear(); + this->corridors->Clear(); + for (int i = 0; i < this->DUNGEON_Size_Y; i += 1) { + for (int j = 0; j < this->DUNGEON_Size_X; j += 1) { + this->dungeon->SetData(j, i, 0); + } + } + } + DungeonGenerator::DungeonGenerator() + { + SpawnMobs = true; + DUNGEON_Size_X = 200; + DUNGEON_Size_Y = 200; + ROOM_MIN_SIZE = 20; + ROOM_MAX_SIZE = 26; + ROOM_PLACEMENT_TRIES = 100; + CORRIDOR_SIZE = 4; + } + + } + } +} diff --git a/DungeonGenerator.h b/DungeonGenerator.h new file mode 100644 index 0000000..4d0a929 --- /dev/null +++ b/DungeonGenerator.h @@ -0,0 +1,83 @@ +#pragma once +#include +#include "MonoBehaviour.h" +#include "GameObject.h" +#include "DungeonRoom.h" +#include +#include "DungeonCorridor.h" +#include +#include "UnityEngine.h" +#include "BrokenSeals.h" +#include "CxNet.h" +#include "DungeonStartRoom.h" +#include "DungeonEndRoom.h" +#include "TileConsts.h" + +using namespace UnityEngine; +using namespace System::Collections::Generic; +using namespace System::Text; +using namespace CxNetworking; +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class DungeonGenerator : public virtual MonoBehaviour, public virtual Object + { + public: + int Seed; + public: + bool SpawnMobs; + public: + int DUNGEON_Size_X; + public: + int DUNGEON_Size_Y; + public: + int ROOM_MIN_SIZE; + public: + int ROOM_MAX_SIZE; + public: + int ROOM_PLACEMENT_TRIES; + public: + int CORRIDOR_SIZE; + //Attribute: SerializeField* + private: + GameObject* startPositionPrefab; + private: + ArrayND* dungeon; + private: + List_T* rooms; + private: + List_T* corridors; + private: + StringBuilder* sb; + public: + ArrayND* getDungeon(); + //Ignored empty method declaration + private: + void Awake(); + public: + void Generate(int level); + public: + void GenerateDungeon(); + public: + void GenerateCorridors(); + public: + void GeneratePlayers(int level); + public: + void PreprocessDungeonSimple(); + public: + void PreprocessDungeon(); + public: + String* StringifyDungeon(); + private: + void GenerateDebugDungeon(); + private: + bool CanPlaceRoom(int x, int y, int width, int height); + public: + void Reset(); + public: + DungeonGenerator(); + }; + } + } +} diff --git a/DungeonRoom.cpp b/DungeonRoom.cpp new file mode 100644 index 0000000..7d913d7 --- /dev/null +++ b/DungeonRoom.cpp @@ -0,0 +1,161 @@ +#include "DungeonRoom.h" +namespace BS { + namespace Levels { + namespace Generator { + Array* DungeonRoom::biga; + Array* DungeonRoom::bigb; + Array* DungeonRoom::smalla; + Array* DungeonRoom::smallb; + int DungeonRoom::getX(){ + return this->x; + } + void DungeonRoom::setX(int value) + { + this->x = value; + } + int DungeonRoom::getY() + { + return this->y; + } + void DungeonRoom::setY(int value) + { + this->y = value; + } + int DungeonRoom::getWidth() + { + return this->width; + } + void DungeonRoom::setWidth(int value) + { + this->width = value; + } + int DungeonRoom::getHeight() + { + return this->height; + } + void DungeonRoom::setHeight(int value) + { + this->height = value; + } + DungeonRoom::DungeonRoom(int x, int y, int width, int height) + { + this->setX(x); + this->setY(y); + this->setWidth(width); + this->setHeight(height); + } + void DungeonRoom::WriteRoom(ArrayND* dungeon) + { + for (int i = this->getY(); i < (this->getY() + this->getHeight()); i += 1) { + for (int j = this->getX(); j < (this->getX() + this->getWidth()); j += 1) { + dungeon->SetData(j, i, 1); + } + } + for (int k = this->getX() + 1; k < ((this->getX() + this->getWidth()) - 1); k += 1) { + dungeon->SetData(k, (this->getY() + this->getHeight()) - 1, 11); + } + for (int l = this->getX() + 1; l < ((this->getX() + this->getWidth()) - 1); l += 1) { + dungeon->SetData(l, this->getY(), 13); + } + for (int m = this->getY() + 1; m < ((this->getY() + this->getHeight()) - 1); m += 1) { + dungeon->SetData(this->getX(), m, 14); + } + for (int n = this->getY() + 1; n < ((this->getY() + this->getHeight()) - 1); n += 1) { + dungeon->SetData((this->getX() + this->getWidth()) - 1, n, 12); + } + dungeon->SetData(this->getX(), this->getY(), 13); + dungeon->SetData((this->getX() + this->getWidth()) - 1, this->getY(), 13); + dungeon->SetData(this->getX(), (this->getY() + this->getHeight()) - 1, 13); + dungeon->SetData((this->getX() + this->getWidth()) - 1, (this->getY() + this->getHeight()) - 1, 13); + } + void DungeonRoom::GenerateAIPlayers(int level) + { + int num = UnityEngine::Random::Range(3, 5); + for (int i = 0; i < num; i += 1) { + int num2 = this->getX() + UnityEngine::Random::Range(1, this->getWidth() - 2); + int num3 = this->getY() + UnityEngine::Random::Range(1, this->getHeight() - 2); + Vector3* position = new Vector3((float)(num2) * Voxelizzer::world->voxelScale, Voxelizzer::world->voxelScale, (float)(num3) * Voxelizzer::world->voxelScale); + Entity::SSpawn(EntityType::Mob, UnityEngine::Random::Range(10000, 10005), level, this->GenerateName(), 0u, null, false, position, ); + } + } + String* DungeonRoom::GenerateName() + { + UnityEngine::Random::State* state = UnityEngine::Random::state; + String* text = DungeonRoom::biga->GetData(UnityEngine::Random::Range(0, DungeonRoom::biga->Length)); + bool flag = false; + int num = UnityEngine::Random::Range(3, 7); + for (int i = 0; i < num; i += 1) { + if (flag) { + *text += DungeonRoom::smallb->GetData(UnityEngine::Random::Range(0, DungeonRoom::smallb->Length)); + } + else { + *text += DungeonRoom::smalla->GetData(UnityEngine::Random::Range(0, DungeonRoom::smalla->Length)); + } + flag = !flag; + } + UnityEngine::Random::state = state; + return text; + } + DungeonRoom::DungeonRoom() + { + Array* expr_06 = new Array(5); + expr_06->SetData(0, new String("A")); + expr_06->SetData(1, new String("E")); + expr_06->SetData(2, new String("I")); + expr_06->SetData(3, new String("O")); + expr_06->SetData(4, new String("U")); + DungeonRoom::biga = expr_06; + Array* expr_3A = new Array(19); + expr_3A->SetData(0, new String("B")); + expr_3A->SetData(1, new String("C")); + expr_3A->SetData(2, new String("D")); + expr_3A->SetData(3, new String("E")); + expr_3A->SetData(4, new String("F")); + expr_3A->SetData(5, new String("G")); + expr_3A->SetData(6, new String("H")); + expr_3A->SetData(7, new String("J")); + expr_3A->SetData(8, new String("K")); + expr_3A->SetData(9, new String("L")); + expr_3A->SetData(10, new String("M")); + expr_3A->SetData(11, new String("N")); + expr_3A->SetData(12, new String("P")); + expr_3A->SetData(13, new String("Q")); + expr_3A->SetData(14, new String("R")); + expr_3A->SetData(15, new String("V")); + expr_3A->SetData(16, new String("X")); + expr_3A->SetData(17, new String("Y")); + expr_3A->SetData(18, new String("Z")); + DungeonRoom::bigb = expr_3A; + Array* expr_E7 = new Array(5); + expr_E7->SetData(0, new String("a")); + expr_E7->SetData(1, new String("e")); + expr_E7->SetData(2, new String("i")); + expr_E7->SetData(3, new String("o")); + expr_E7->SetData(4, new String("u")); + DungeonRoom::smalla = expr_E7; + Array* expr_11B = new Array(19); + expr_11B->SetData(0, new String("b")); + expr_11B->SetData(1, new String("c")); + expr_11B->SetData(2, new String("d")); + expr_11B->SetData(3, new String("e")); + expr_11B->SetData(4, new String("f")); + expr_11B->SetData(5, new String("g")); + expr_11B->SetData(6, new String("h")); + expr_11B->SetData(7, new String("j")); + expr_11B->SetData(8, new String("k")); + expr_11B->SetData(9, new String("l")); + expr_11B->SetData(10, new String("m")); + expr_11B->SetData(11, new String("n")); + expr_11B->SetData(12, new String("p")); + expr_11B->SetData(13, new String("q")); + expr_11B->SetData(14, new String("r")); + expr_11B->SetData(15, new String("v")); + expr_11B->SetData(16, new String("x")); + expr_11B->SetData(17, new String("y")); + expr_11B->SetData(18, new String("z")); + DungeonRoom::smallb = expr_11B; + } + + } + } +} diff --git a/DungeonRoom.h b/DungeonRoom.h new file mode 100644 index 0000000..1d5f485 --- /dev/null +++ b/DungeonRoom.h @@ -0,0 +1,64 @@ +#pragma once +#include +#include "UnityEngine.h" +#include "Vector3.h" +#include "Voxelizzer.h" +#include "Entity.h" +#include "EntityType.h" +#include "Quaternion.h" + +using namespace UnityEngine; +using namespace VoxelToolbox; +using namespace BS::Player; +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class DungeonRoom : public virtual Object + { + private: + static Array* biga; + private: + static Array* bigb; + private: + static Array* smalla; + private: + static Array* smallb; + private: + int x; + private: + int y; + private: + int width; + private: + int height; + public: + int getX(); + public: + void setX(int value); + public: + int getY(); + public: + void setY(int value); + public: + int getWidth(); + public: + void setWidth(int value); + public: + int getHeight(); + public: + void setHeight(int value); + public: + DungeonRoom(int x, int y, int width, int height); + public: + virtual void WriteRoom(ArrayND* dungeon); + public: + virtual void GenerateAIPlayers(int level); + public: + String* GenerateName(); + static: + DungeonRoom(); + }; + } + } +} diff --git a/DungeonStartRoom.cpp b/DungeonStartRoom.cpp new file mode 100644 index 0000000..8453010 --- /dev/null +++ b/DungeonStartRoom.cpp @@ -0,0 +1,23 @@ +#include "DungeonStartRoom.h" +namespace BS { + namespace Levels { + namespace Generator { + DungeonStartRoom::DungeonStartRoom(int x, int y, int width, int height) : DungeonRoom(x, y, 8, 8){ + } + void DungeonStartRoom::GenerateSpawnPoint(GameObject* startPositionPrefab) + { + bool flag = false; + while (!flag) { + int num = DungeonRoom::getX() + UnityEngine::Random::Range(1, DungeonRoom::getWidth() - 2); + int num2 = DungeonRoom::getY() + UnityEngine::Random::Range(1, DungeonRoom::getHeight() - 2); + flag = true; + UnityEngine::Object::Instantiate(startPositionPrefab, Vector3::zero, Quaternion::identity)->transform->position = new Vector3((float)(num) * Voxelizzer::world->voxelScale, Voxelizzer::world->voxelScale, (float)(num2) * Voxelizzer::world->voxelScale); + } + } + void DungeonStartRoom::GenerateAIPlayers(int level) + { + } + + } + } +} diff --git a/DungeonStartRoom.h b/DungeonStartRoom.h new file mode 100644 index 0000000..044125a --- /dev/null +++ b/DungeonStartRoom.h @@ -0,0 +1,27 @@ +#pragma once +#include +#include "DungeonRoom.h" +#include "GameObject.h" +#include "UnityEngine.h" +#include "Vector3.h" +#include "Voxelizzer.h" +#include "Quaternion.h" + +using namespace UnityEngine; +using namespace VoxelToolbox; +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class DungeonStartRoom : public virtual DungeonRoom, public virtual Object + { + public: + DungeonStartRoom(int x, int y, int width, int height); + public: + void GenerateSpawnPoint(GameObject* startPositionPrefab); + public: + virtual void GenerateAIPlayers(int level); + }; + } + } +} diff --git a/IntRect.cpp b/IntRect.cpp new file mode 100644 index 0000000..667cea8 --- /dev/null +++ b/IntRect.cpp @@ -0,0 +1,46 @@ +#include "IntRect.h" +namespace BS { + namespace Levels { + namespace Generator { + int IntRect::getX(){ + return this->x; + } + void IntRect::setX(int value) + { + this->x = value; + } + int IntRect::getY() + { + return this->y; + } + void IntRect::setY(int value) + { + this->y = value; + } + int IntRect::getWidth() + { + return this->width; + } + void IntRect::setWidth(int value) + { + this->width = value; + } + int IntRect::getHeight() + { + return this->height; + } + void IntRect::setHeight(int value) + { + this->height = value; + } + IntRect::IntRect(int x, int y, int width, int height) + { + this->x = x; + this->y = y; + this->width = width; + this->height = height; + } + + } + } +} diff --git a/IntRect.h b/IntRect.h new file mode 100644 index 0000000..6607084 --- /dev/null +++ b/IntRect.h @@ -0,0 +1,39 @@ +#pragma once +#include + +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class IntRect : public virtual Object + { + private: + int x; + private: + int y; + private: + int width; + private: + int height; + public: + int getX(); + public: + void setX(int value); + public: + int getY(); + public: + void setY(int value); + public: + int getWidth(); + public: + void setWidth(int value); + public: + int getHeight(); + public: + void setHeight(int value); + public: + IntRect(int x, int y, int width, int height); + }; + } + } +} diff --git a/SCsub b/SCsub new file mode 100644 index 0000000..a7ee051 --- /dev/null +++ b/SCsub @@ -0,0 +1,4 @@ +Import('env') + +env.add_source_files(env.modules_sources,"register_types.cpp") + diff --git a/TileConsts.cpp b/TileConsts.cpp new file mode 100644 index 0000000..054637a --- /dev/null +++ b/TileConsts.cpp @@ -0,0 +1,71 @@ +#include "TileConsts.h" +namespace BS { + namespace Levels { + namespace Generator { + bool TileConsts::isWall(char tile){ + switch (tile){ + case 11: + return true; + + case 12: + return true; + + case 13: + return true; + + case 14: + return true; + + case 15: + return true; + + case 16: + return true; + + case 17: + return true; + + case 18: + return true; + + case 21: + return true; + + case 22: + return true; + + case 23: + return true; + } + return false; + } + TileConsts::TileConsts() + { + Floor = 1; + Floor_Var1 = 2; + Floor_Up = 3; + Floor_Left = 4; + Floor_Down = 5; + Floor_Right = 6; + Floor_UpRight = 7; + Floor_UpLeft = 8; + Floor_DownLeft = 9; + Floor_DownRight = 10; + Wall_Up = 11; + Wall_Right = 12; + Wall_Down = 13; + Wall_Left = 14; + Wall_Corner_TopRight = 15; + Wall_Corner_TopLeft = 16; + Wall_Corner_BottomRight = 17; + Wall_Corner_BottomRight_Outside = 23; + Wall_Corner_BottomLeft = 18; + Wall_Corner_BottomLeft_Outside = 21; + Wall_Corner_BottomLeft_Half_Outside = 22; + Roof_Wood_Single = 19; + Stair_Down = 20; + } + + } + } +} diff --git a/TileConsts.h b/TileConsts.h new file mode 100644 index 0000000..3056fe8 --- /dev/null +++ b/TileConsts.h @@ -0,0 +1,63 @@ +#pragma once +#include + +using namespace System; +namespace BS { + namespace Levels { + namespace Generator { + class TileConsts : public virtual Object + { + public: + char Floor; + public: + char Floor_Var1; + public: + char Floor_Up; + public: + char Floor_Left; + public: + char Floor_Down; + public: + char Floor_Right; + public: + char Floor_UpRight; + public: + char Floor_UpLeft; + public: + char Floor_DownLeft; + public: + char Floor_DownRight; + public: + char Wall_Up; + public: + char Wall_Right; + public: + char Wall_Down; + public: + char Wall_Left; + public: + char Wall_Corner_TopRight; + public: + char Wall_Corner_TopLeft; + public: + char Wall_Corner_BottomRight; + public: + char Wall_Corner_BottomRight_Outside; + public: + char Wall_Corner_BottomLeft; + public: + char Wall_Corner_BottomLeft_Outside; + public: + char Wall_Corner_BottomLeft_Half_Outside; + public: + char Roof_Wood_Single; + public: + char Stair_Down; + public: + static bool isWall(char tile); + public: + TileConsts(); + }; + } + } +} diff --git a/config.py b/config.py new file mode 100644 index 0000000..1c8cd12 --- /dev/null +++ b/config.py @@ -0,0 +1,5 @@ +def can_build(env, platform): + return True + +def configure(env): + pass diff --git a/config.pyc b/config.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23d1680ae80d5a8c8ba409a21402f8d6e2e90cb4 GIT binary patch literal 427 zcmbVIOA5j;5S_Lztl-ug2wm9=hzPDNQeBB4HBF09laeNadvD<}y?}4xZ>@oO^O($J z-b-{J4wkFiPSEQF$a6$D0+d8oqAf_^NkC;t>mjw5pEvq`lY}ouW|t zgF7~mhUNS|1%mlIKBC~_EsDFmvYfmA-|dw+BiY|;cji6j>@nx^_wird^)Wqte#7iz GE{-0=Yf$R| literal 0 HcmV?d00001 diff --git a/register_types.cpp b/register_types.cpp new file mode 100644 index 0000000..8a8686b --- /dev/null +++ b/register_types.cpp @@ -0,0 +1,10 @@ +#include "register_types.h" + +void register_dungeon_generator_types() { + //ClassDB::register_class(); +} + +void unregister_dungeon_generator_types() { + +} + diff --git a/register_types.h b/register_types.h new file mode 100644 index 0000000..f725d39 --- /dev/null +++ b/register_types.h @@ -0,0 +1,3 @@ + +void register_dungeon_generator_types(); +void unregister_dungeon_generator_types();