From 3911f4289459c5c23e1e7f5ee89e78aa16eb586d Mon Sep 17 00:00:00 2001 From: Relintai Date: Tue, 21 Jul 2020 18:41:52 +0200 Subject: [PATCH] Did the same to Dungeon and DungeonData. --- SCsub | 1 - config.py | 1 - data/dungeon_data.cpp | 583 ------------------------------------------ data/dungeon_data.h | 203 --------------- main/biome.cpp | 2 +- main/dungeon.cpp | 367 ++++++++++++++++++++++++-- main/dungeon.h | 95 ++++++- register_types.cpp | 2 - 8 files changed, 435 insertions(+), 819 deletions(-) delete mode 100644 data/dungeon_data.cpp delete mode 100644 data/dungeon_data.h diff --git a/SCsub b/SCsub index d1827c7..2bc984b 100644 --- a/SCsub +++ b/SCsub @@ -29,7 +29,6 @@ sources = [ "data/dungeon_room_data.cpp", "data/dungeon_corridor_data.cpp", - "data/dungeon_data.cpp", "data/world_generator_prop_data.cpp", "world_generator.cpp", diff --git a/config.py b/config.py index 7c90fff..871ec14 100644 --- a/config.py +++ b/config.py @@ -7,7 +7,6 @@ def configure(env): def get_doc_classes(): return [ "DungeonCorridorData", - "DungeonData", "DungeonRoomData", "WorldGeneratorPropData", diff --git a/data/dungeon_data.cpp b/data/dungeon_data.cpp deleted file mode 100644 index dffe444..0000000 --- a/data/dungeon_data.cpp +++ /dev/null @@ -1,583 +0,0 @@ -/* -Copyright (c) 2019-2020 Péter Magyar - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#include "dungeon_data.h" - -#include "core/version.h" - -#include "../main/dungeon.h" - -Ref DungeonData::get_dungeon() { - return _dungeon; -} -void DungeonData::set_dungeon(const Ref &dungeon) { - _dungeon = dungeon; -} - -Vector2 DungeonData::get_level_range() { - return _level_range; -} -void DungeonData::set_level_range(Vector2 value) { - _level_range = value; -} - -//Min Size -int DungeonData::get_min_sizex() { - return _min_sizex; -} -void DungeonData::set_min_sizex(int value) { - _min_sizex = value; -} - -int DungeonData::get_min_sizey() { - return _min_sizey; -} -void DungeonData::set_min_sizey(int value) { - _min_sizey = value; -} - -int DungeonData::get_min_sizez() { - return _min_sizez; -} -void DungeonData::set_min_sizez(int value) { - _min_sizez = value; -} - -//Max Size -int DungeonData::get_max_sizex() { - return _max_sizex; -} -void DungeonData::set_max_sizex(int value) { - _max_sizex = value; -} - -int DungeonData::get_max_sizey() { - return _max_sizey; -} -void DungeonData::set_max_sizey(int value) { - _max_sizey = value; -} - -int DungeonData::get_max_sizez() { - return _max_sizez; -} -void DungeonData::set_max_sizez(int value) { - _max_sizez = value; -} - -int DungeonData::get_min_room_count() { - return _min_room_count; -} -void DungeonData::set_min_room_count(int value) { - _min_room_count = value; -} - -int DungeonData::get_max_room_count() { - return _max_room_count; -} -void DungeonData::set_max_room_count(int value) { - _max_room_count = value; -} - -//Rooms -Ref DungeonData::get_dungeon_room_data(const int index) const { - ERR_FAIL_INDEX_V(index, _dungeon_room_datas.size(), Ref()); - - return _dungeon_room_datas.get(index); -} -void DungeonData::set_dungeon_room_data(const int index, const Ref dungeon_room_data) { - ERR_FAIL_INDEX(index, _dungeon_room_datas.size()); - - _dungeon_room_datas.set(index, dungeon_room_data); -} -void DungeonData::add_dungeon_room_data(const Ref dungeon_room_data) { - _dungeon_room_datas.push_back(dungeon_room_data); -} -void DungeonData::remove_dungeon_room_data(const int index) { - ERR_FAIL_INDEX(index, _dungeon_room_datas.size()); - - _dungeon_room_datas.remove(index); -} - -int DungeonData::get_dungeon_room_data_count() const { - return _dungeon_room_datas.size(); -} - -Vector DungeonData::get_dungeon_room_datas() { - Vector r; - for (int i = 0; i < _dungeon_room_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_dungeon_room_datas[i].get_ref_ptr()); -#else - r.push_back(_dungeon_room_datas[i]); -#endif - } - return r; -} -void DungeonData::set_dungeon_room_datas(const Vector &dungeon_room_datas) { - _dungeon_room_datas.clear(); - for (int i = 0; i < dungeon_room_datas.size(); i++) { - Ref dungeon_room_data = Ref(dungeon_room_datas[i]); - - _dungeon_room_datas.push_back(dungeon_room_data); - } -} - -//Start Rooms -Ref DungeonData::get_dungeon_start_room_data(const int index) const { - ERR_FAIL_INDEX_V(index, _dungeon_start_room_datas.size(), Ref()); - - return _dungeon_start_room_datas.get(index); -} -void DungeonData::set_dungeon_start_room_data(const int index, const Ref dungeon_start_room_data) { - ERR_FAIL_INDEX(index, _dungeon_start_room_datas.size()); - - _dungeon_start_room_datas.set(index, dungeon_start_room_data); -} -void DungeonData::add_dungeon_start_room_data(const Ref dungeon_start_room_data) { - _dungeon_start_room_datas.push_back(dungeon_start_room_data); -} -void DungeonData::remove_dungeon_start_room_data(const int index) { - ERR_FAIL_INDEX(index, _dungeon_start_room_datas.size()); - - _dungeon_start_room_datas.remove(index); -} - -int DungeonData::get_dungeon_start_room_data_count() const { - return _dungeon_start_room_datas.size(); -} - -Vector DungeonData::get_dungeon_start_room_datas() { - Vector r; - for (int i = 0; i < _dungeon_start_room_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_dungeon_start_room_datas[i].get_ref_ptr()); -#else - r.push_back(_dungeon_start_room_datas[i]); -#endif - } - return r; -} -void DungeonData::set_dungeon_start_room_datas(const Vector &dungeon_start_room_datas) { - _dungeon_start_room_datas.clear(); - for (int i = 0; i < dungeon_start_room_datas.size(); i++) { - Ref dungeon_start_room_data = Ref(dungeon_start_room_datas[i]); - - _dungeon_start_room_datas.push_back(dungeon_start_room_data); - } -} - -//End Rooms -Ref DungeonData::get_dungeon_end_room_data(const int index) const { - ERR_FAIL_INDEX_V(index, _dungeon_end_room_datas.size(), Ref()); - - return _dungeon_end_room_datas.get(index); -} -void DungeonData::set_dungeon_end_room_data(const int index, const Ref dungeon_end_room_data) { - ERR_FAIL_INDEX(index, _dungeon_end_room_datas.size()); - - _dungeon_end_room_datas.set(index, dungeon_end_room_data); -} -void DungeonData::add_dungeon_end_room_data(const Ref dungeon_end_room_data) { - _dungeon_end_room_datas.push_back(dungeon_end_room_data); -} -void DungeonData::remove_dungeon_end_room_data(const int index) { - ERR_FAIL_INDEX(index, _dungeon_end_room_datas.size()); - - _dungeon_end_room_datas.remove(index); -} - -int DungeonData::get_dungeon_end_room_data_count() const { - return _dungeon_end_room_datas.size(); -} - -Vector DungeonData::get_dungeon_end_room_datas() { - Vector r; - for (int i = 0; i < _dungeon_end_room_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_dungeon_end_room_datas[i].get_ref_ptr()); -#else - r.push_back(_dungeon_end_room_datas[i]); -#endif - } - return r; -} -void DungeonData::set_dungeon_end_room_datas(const Vector &dungeon_end_room_datas) { - _dungeon_end_room_datas.clear(); - for (int i = 0; i < dungeon_end_room_datas.size(); i++) { - Ref dungeon_end_room_data = Ref(dungeon_end_room_datas[i]); - - _dungeon_end_room_datas.push_back(dungeon_end_room_data); - } -} - -//Corridors -Ref DungeonData::get_dungeon_corridor_data(const int index) const { - ERR_FAIL_INDEX_V(index, _dungeon_corridor_datas.size(), Ref()); - - return _dungeon_corridor_datas.get(index); -} -void DungeonData::set_dungeon_corridor_data(const int index, const Ref dungeon_corridor_data) { - ERR_FAIL_INDEX(index, _dungeon_corridor_datas.size()); - - _dungeon_corridor_datas.set(index, dungeon_corridor_data); -} -void DungeonData::add_dungeon_corridor_data(const Ref dungeon_corridor_data) { - _dungeon_corridor_datas.push_back(dungeon_corridor_data); -} -void DungeonData::remove_dungeon_corridor_data(const int index) { - ERR_FAIL_INDEX(index, _dungeon_corridor_datas.size()); - - _dungeon_corridor_datas.remove(index); -} - -int DungeonData::get_dungeon_corridor_data_count() const { - return _dungeon_corridor_datas.size(); -} - -Vector DungeonData::get_dungeon_corridor_datas() { - Vector r; - for (int i = 0; i < _dungeon_corridor_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_dungeon_corridor_datas[i].get_ref_ptr()); -#else - r.push_back(_dungeon_corridor_datas[i]); -#endif - } - return r; -} -void DungeonData::set_dungeon_corridor_datas(const Vector &dungeon_corridor_datas) { - _dungeon_corridor_datas.clear(); - for (int i = 0; i < dungeon_corridor_datas.size(); i++) { - Ref dungeon_corridor_data = Ref(dungeon_corridor_datas[i]); - - _dungeon_corridor_datas.push_back(dungeon_corridor_data); - } -} - -#ifdef ESS_PRESENT -//Entities -Ref DungeonData::get_entity_data(const int index) const { - ERR_FAIL_INDEX_V(index, _entity_datas.size(), Ref()); - - return _entity_datas.get(index); -} -void DungeonData::set_entity_data(const int index, const Ref entity_data) { - ERR_FAIL_INDEX(index, _entity_datas.size()); - - _entity_datas.set(index, entity_data); -} -void DungeonData::add_entity_data(const Ref entity_data) { - _entity_datas.push_back(entity_data); -} -void DungeonData::remove_entity_data(const int index) { - ERR_FAIL_INDEX(index, _entity_datas.size()); - - _entity_datas.remove(index); -} -int DungeonData::get_entity_data_count() const { - return _entity_datas.size(); -} - -Vector DungeonData::get_entity_datas() { - Vector r; - for (int i = 0; i < _entity_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_entity_datas[i].get_ref_ptr()); -#else - r.push_back(_entity_datas[i]); -#endif - } - return r; -} -void DungeonData::set_entity_datas(const Vector &entity_datas) { - _entity_datas.clear(); - for (int i = 0; i < entity_datas.size(); i++) { - Ref entity_data = Ref(entity_datas[i]); - - _entity_datas.push_back(entity_data); - } -} -#endif - -#ifdef VOXELMAN_PRESENT -//// Surfaces //// -Ref DungeonData::get_voxel_surface(const int index) const { - ERR_FAIL_INDEX_V(index, _voxel_surfaces.size(), Ref()); - - return _voxel_surfaces.get(index); -} -void DungeonData::set_voxel_surface(const int index, const Ref voxel_surface) { - ERR_FAIL_INDEX(index, _voxel_surfaces.size()); - - _voxel_surfaces.set(index, voxel_surface); -} -void DungeonData::add_voxel_surface(const Ref voxel_surface) { - _voxel_surfaces.push_back(voxel_surface); -} -void DungeonData::remove_voxel_surface(const int index) { - ERR_FAIL_INDEX(index, _voxel_surfaces.size()); - - _voxel_surfaces.remove(index); -} -int DungeonData::get_voxel_surface_count() const { - return _voxel_surfaces.size(); -} - -Vector DungeonData::get_voxel_surfaces() { - Vector r; - for (int i = 0; i < _voxel_surfaces.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_voxel_surfaces[i].get_ref_ptr()); -#else - r.push_back(_voxel_surfaces[i]); -#endif - } - return r; -} -void DungeonData::set_voxel_surfaces(const Vector &voxel_surfaces) { - _voxel_surfaces.clear(); - for (int i = 0; i < voxel_surfaces.size(); i++) { - Ref voxel_surface = Ref(voxel_surfaces[i]); - - _voxel_surfaces.push_back(voxel_surface); - } -} - -//Environments -Ref DungeonData::get_environment_data(const int index) const { - ERR_FAIL_INDEX_V(index, _environment_datas.size(), Ref()); - - return _environment_datas.get(index); -} -void DungeonData::set_environment_data(const int index, const Ref environment_data) { - ERR_FAIL_INDEX(index, _environment_datas.size()); - - _environment_datas.set(index, environment_data); -} -void DungeonData::add_environment_data(const Ref environment_data) { - _environment_datas.push_back(environment_data); -} -void DungeonData::remove_environment_data(const int index) { - ERR_FAIL_INDEX(index, _environment_datas.size()); - - _environment_datas.remove(index); -} -int DungeonData::get_environment_data_count() const { - return _environment_datas.size(); -} - -Vector DungeonData::get_environment_datas() { - Vector r; - for (int i = 0; i < _environment_datas.size(); i++) { -#if VERSION_MAJOR < 4 - r.push_back(_environment_datas[i].get_ref_ptr()); -#else - r.push_back(_environment_datas[i]); -#endif - } - return r; -} -void DungeonData::set_environment_datas(const Vector &environment_datas) { - _environment_datas.clear(); - for (int i = 0; i < environment_datas.size(); i++) { - Ref environment_data = Ref(environment_datas[i]); - - _environment_datas.push_back(environment_data); - } -} -#endif - -Ref DungeonData::instance() { - Ref dungeon; - - if (!_dungeon.is_valid()) { - dungeon.instance(); - } else { - dungeon = _dungeon->duplicate(); - } - - dungeon->set_data(Ref(this)); - - return dungeon; -} - -DungeonData::DungeonData() { - _min_sizex = 0; - _min_sizey = 0; - _min_sizez = 0; - - _max_sizex = 0; - _max_sizey = 0; - _max_sizez = 0; - - _min_room_count = 0; - _max_room_count = 0; -} -DungeonData::~DungeonData() { -#ifdef VOXELMAN_PRESENT - _environment_datas.clear(); -#endif - - _dungeon_room_datas.clear(); - _dungeon_start_room_datas.clear(); - _dungeon_end_room_datas.clear(); - _dungeon_corridor_datas.clear(); - -#ifdef ESS_PRESENT - _entity_datas.clear(); -#endif - -#ifdef VOXELMAN_PRESENT - _entity_datas.clear(); - _voxel_surfaces.clear(); - _liquid_voxel_surfaces.clear(); -#endif -} - -void DungeonData::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_dungeon"), &DungeonData::get_dungeon); - ClassDB::bind_method(D_METHOD("set_dungeon", "value"), &DungeonData::set_dungeon); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "dungeon", PROPERTY_HINT_RESOURCE_TYPE, "Dungeon"), "set_dungeon", "get_dungeon"); - - ClassDB::bind_method(D_METHOD("get_level_range"), &DungeonData::get_level_range); - ClassDB::bind_method(D_METHOD("set_level_range", "value"), &DungeonData::set_level_range); - ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "level_range"), "set_level_range", "get_level_range"); - - //Min Size - ClassDB::bind_method(D_METHOD("get_min_sizex"), &DungeonData::get_min_sizex); - ClassDB::bind_method(D_METHOD("set_min_sizex", "value"), &DungeonData::set_min_sizex); - ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizex"), "set_min_sizex", "get_min_sizex"); - - ClassDB::bind_method(D_METHOD("get_min_sizey"), &DungeonData::get_min_sizey); - ClassDB::bind_method(D_METHOD("set_min_sizey", "value"), &DungeonData::set_min_sizey); - ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizey"), "set_min_sizey", "get_min_sizey"); - - ClassDB::bind_method(D_METHOD("get_min_sizez"), &DungeonData::get_min_sizez); - ClassDB::bind_method(D_METHOD("set_min_sizez", "value"), &DungeonData::set_min_sizez); - ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizez"), "set_min_sizez", "get_min_sizez"); - - //Max Size - ClassDB::bind_method(D_METHOD("get_max_sizex"), &DungeonData::get_max_sizex); - ClassDB::bind_method(D_METHOD("set_max_sizex", "value"), &DungeonData::set_max_sizex); - ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizex"), "set_max_sizex", "get_max_sizex"); - - ClassDB::bind_method(D_METHOD("get_max_sizey"), &DungeonData::get_max_sizey); - ClassDB::bind_method(D_METHOD("set_max_sizey", "value"), &DungeonData::set_max_sizey); - ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizey"), "set_max_sizey", "get_max_sizey"); - - ClassDB::bind_method(D_METHOD("get_max_sizez"), &DungeonData::get_max_sizez); - ClassDB::bind_method(D_METHOD("set_max_sizez", "value"), &DungeonData::set_max_sizez); - ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizez"), "set_max_sizez", "get_max_sizez"); - - //Room Count - ClassDB::bind_method(D_METHOD("get_min_room_count"), &DungeonData::get_min_room_count); - ClassDB::bind_method(D_METHOD("set_min_room_count", "value"), &DungeonData::set_min_room_count); - ADD_PROPERTY(PropertyInfo(Variant::INT, "min_room_count"), "set_min_room_count", "get_min_room_count"); - - ClassDB::bind_method(D_METHOD("get_max_room_count"), &DungeonData::get_max_room_count); - ClassDB::bind_method(D_METHOD("set_max_room_count", "value"), &DungeonData::set_max_room_count); - ADD_PROPERTY(PropertyInfo(Variant::INT, "max_room_count"), "set_max_room_count", "get_max_room_count"); - - //Rooms - ClassDB::bind_method(D_METHOD("get_dungeon_room_data", "index"), &DungeonData::get_dungeon_room_data); - ClassDB::bind_method(D_METHOD("set_dungeon_room_data", "index", "data"), &DungeonData::set_dungeon_room_data); - ClassDB::bind_method(D_METHOD("add_dungeon_room_data", "dungeon_room_data"), &DungeonData::add_dungeon_room_data); - ClassDB::bind_method(D_METHOD("remove_dungeon_room_data", "index"), &DungeonData::remove_dungeon_room_data); - ClassDB::bind_method(D_METHOD("get_dungeon_room_data_count"), &DungeonData::get_dungeon_room_data_count); - - ClassDB::bind_method(D_METHOD("get_dungeon_room_datas"), &DungeonData::get_dungeon_room_datas); - ClassDB::bind_method(D_METHOD("set_dungeon_room_datas", "dungeon_room_datas"), &DungeonData::set_dungeon_room_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_room_datas", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_room_datas", "get_dungeon_room_datas"); - - //Start Rooms - ClassDB::bind_method(D_METHOD("get_dungeon_start_room_data", "index"), &DungeonData::get_dungeon_start_room_data); - ClassDB::bind_method(D_METHOD("set_dungeon_start_room_data", "index", "data"), &DungeonData::set_dungeon_start_room_data); - ClassDB::bind_method(D_METHOD("add_dungeon_start_room_data", "dungeon_start_room_data"), &DungeonData::add_dungeon_start_room_data); - ClassDB::bind_method(D_METHOD("remove_dungeon_start_room_data", "index"), &DungeonData::remove_dungeon_start_room_data); - ClassDB::bind_method(D_METHOD("get_dungeon_start_room_data_count"), &DungeonData::get_dungeon_start_room_data_count); - - ClassDB::bind_method(D_METHOD("get_dungeon_start_room_datas"), &DungeonData::get_dungeon_start_room_datas); - ClassDB::bind_method(D_METHOD("set_dungeon_start_room_datas", "dungeon_start_room_datas"), &DungeonData::set_dungeon_start_room_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_start_room_datas", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_start_room_datas", "get_dungeon_start_room_datas"); - - //End Rooms - ClassDB::bind_method(D_METHOD("get_dungeon_end_room_data", "index"), &DungeonData::get_dungeon_end_room_data); - ClassDB::bind_method(D_METHOD("set_dungeon_end_room_data", "index", "data"), &DungeonData::set_dungeon_end_room_data); - ClassDB::bind_method(D_METHOD("add_dungeon_end_room_data", "dungeon_end_room_data"), &DungeonData::add_dungeon_end_room_data); - ClassDB::bind_method(D_METHOD("remove_dungeon_end_room_data", "index"), &DungeonData::remove_dungeon_end_room_data); - ClassDB::bind_method(D_METHOD("get_dungeon_end_room_data_count"), &DungeonData::get_dungeon_end_room_data_count); - - ClassDB::bind_method(D_METHOD("get_dungeon_end_room_datas"), &DungeonData::get_dungeon_end_room_datas); - ClassDB::bind_method(D_METHOD("set_dungeon_end_room_datas", "dungeon_end_room_datas"), &DungeonData::set_dungeon_end_room_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_end_room_datas", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_end_room_datas", "get_dungeon_end_room_datas"); - - //Corridors - ClassDB::bind_method(D_METHOD("get_dungeon_corridor_data", "index"), &DungeonData::get_dungeon_corridor_data); - ClassDB::bind_method(D_METHOD("set_dungeon_corridor_data", "index", "data"), &DungeonData::set_dungeon_corridor_data); - ClassDB::bind_method(D_METHOD("add_dungeon_corridor_data", "dungeon_corridor_data"), &DungeonData::add_dungeon_corridor_data); - ClassDB::bind_method(D_METHOD("remove_dungeon_corridor_data", "index"), &DungeonData::remove_dungeon_corridor_data); - ClassDB::bind_method(D_METHOD("get_dungeon_corridor_data_count"), &DungeonData::get_dungeon_corridor_data_count); - - ClassDB::bind_method(D_METHOD("get_dungeon_corridor_datas"), &DungeonData::get_dungeon_corridor_datas); - ClassDB::bind_method(D_METHOD("set_dungeon_corridor_datas", "dungeon_corridor_datas"), &DungeonData::set_dungeon_corridor_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_corridor_datas", PROPERTY_HINT_NONE, "17/17:DungeonCorridorData", PROPERTY_USAGE_DEFAULT, "DungeonCorridorData"), "set_dungeon_corridor_datas", "get_dungeon_corridor_datas"); - -#ifdef ESS_PRESENT - //Entities - ClassDB::bind_method(D_METHOD("get_entity_data", "index"), &DungeonData::get_entity_data); - ClassDB::bind_method(D_METHOD("set_entity_data", "index", "data"), &DungeonData::set_entity_data); - ClassDB::bind_method(D_METHOD("add_entity_data", "entity_data"), &DungeonData::add_entity_data); - ClassDB::bind_method(D_METHOD("remove_entity_data", "index"), &DungeonData::remove_entity_data); - ClassDB::bind_method(D_METHOD("get_entity_data_count"), &DungeonData::get_entity_data_count); - - ClassDB::bind_method(D_METHOD("get_entity_datas"), &DungeonData::get_entity_datas); - ClassDB::bind_method(D_METHOD("set_entity_datas", "entity_datas"), &DungeonData::set_entity_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "entity_datas", PROPERTY_HINT_NONE, "17/17:EntityData", PROPERTY_USAGE_DEFAULT, "EntityData"), "set_entity_datas", "get_entity_datas"); -#endif - -#ifdef VOXELMAN_PRESENT - //Environments - ClassDB::bind_method(D_METHOD("get_environment_data", "index"), &DungeonData::get_environment_data); - ClassDB::bind_method(D_METHOD("set_environment_data", "index", "data"), &DungeonData::set_environment_data); - ClassDB::bind_method(D_METHOD("add_environment_data", "environment_data"), &DungeonData::add_environment_data); - ClassDB::bind_method(D_METHOD("remove_environment_data", "index"), &DungeonData::remove_environment_data); - ClassDB::bind_method(D_METHOD("get_environment_data_count"), &DungeonData::get_environment_data_count); - - ClassDB::bind_method(D_METHOD("get_environment_datas"), &DungeonData::get_environment_datas); - ClassDB::bind_method(D_METHOD("set_environment_datas", "environment_datas"), &DungeonData::set_environment_datas); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "environment_datas", PROPERTY_HINT_NONE, "17/17:EnvironmentData", PROPERTY_USAGE_DEFAULT, "EnvironmentData"), "set_environment_datas", "get_environment_datas"); - - //Surfaces - ClassDB::bind_method(D_METHOD("get_voxel_surface", "index"), &DungeonData::get_voxel_surface); - ClassDB::bind_method(D_METHOD("set_voxel_surface", "index", "data"), &DungeonData::set_voxel_surface); - ClassDB::bind_method(D_METHOD("add_voxel_surface", "voxel_surface"), &DungeonData::add_voxel_surface); - ClassDB::bind_method(D_METHOD("remove_voxel_surface", "index"), &DungeonData::remove_voxel_surface); - ClassDB::bind_method(D_METHOD("get_voxel_surface_count"), &DungeonData::get_voxel_surface_count); - - ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &DungeonData::get_voxel_surfaces); - ClassDB::bind_method(D_METHOD("set_voxel_surfaces", "voxel_surfaces"), &DungeonData::set_voxel_surfaces); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "voxel_surfaces", PROPERTY_HINT_NONE, "17/17:VoxelSurface", PROPERTY_USAGE_DEFAULT, "VoxelSurface"), "set_voxel_surfaces", "get_voxel_surfaces"); -#endif - - ClassDB::bind_method(D_METHOD("instance"), &DungeonData::instance); -} diff --git a/data/dungeon_data.h b/data/dungeon_data.h deleted file mode 100644 index ad4017f..0000000 --- a/data/dungeon_data.h +++ /dev/null @@ -1,203 +0,0 @@ -/* -Copyright (c) 2019-2020 Péter Magyar - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef DUNGEON_DATA_H -#define DUNGEON_DATA_H - -#include "core/resource.h" -#include "core/script_language.h" -#include "core/ustring.h" -#include "core/vector.h" - -#include "../main/dungeon.h" -#include "dungeon_corridor_data.h" -#include "dungeon_room_data.h" - -#ifdef VOXELMAN_PRESENT -#include "../../voxelman/library/voxel_surface.h" -#include "../../voxelman/world/environment_data.h" -#endif - -#ifdef ESS_PRESENT -#include "../../entity_spell_system/entities/data/entity_data.h" -#endif - -class Dungeon; - -class DungeonData : public Resource { - GDCLASS(DungeonData, Resource); - -public: - Ref get_dungeon(); - void set_dungeon(const Ref &dungeon); - - Vector2 get_level_range(); - void set_level_range(Vector2 value); - - //Min Size - int get_min_sizex(); - void set_min_sizex(int value); - - int get_min_sizey(); - void set_min_sizey(int value); - - int get_min_sizez(); - void set_min_sizez(int value); - - //Max Size - int get_max_sizex(); - void set_max_sizex(int value); - - int get_max_sizey(); - void set_max_sizey(int value); - - int get_max_sizez(); - void set_max_sizez(int value); - - //Room Count - int get_min_room_count(); - void set_min_room_count(int value); - - int get_max_room_count(); - void set_max_room_count(int value); - -#ifdef VOXELMAN_PRESENT - //Environments - Ref get_environment_data(const int index) const; - void set_environment_data(const int index, const Ref environment_data); - void add_environment_data(const Ref environment_data); - void remove_environment_data(const int index); - int get_environment_data_count() const; - - Vector get_environment_datas(); - void set_environment_datas(const Vector &environment_datas); -#endif - - //Rooms - Ref get_dungeon_room_data(const int index) const; - void set_dungeon_room_data(const int index, const Ref dungeon_room_data); - void add_dungeon_room_data(const Ref dungeon_room_data); - void remove_dungeon_room_data(const int index); - int get_dungeon_room_data_count() const; - - Vector get_dungeon_room_datas(); - void set_dungeon_room_datas(const Vector &dungeon_room_datas); - - //Start Rooms - Ref get_dungeon_start_room_data(const int index) const; - void set_dungeon_start_room_data(const int index, const Ref dungeon_start_room_data); - void add_dungeon_start_room_data(const Ref dungeon_start_room_data); - void remove_dungeon_start_room_data(const int index); - int get_dungeon_start_room_data_count() const; - - Vector get_dungeon_start_room_datas(); - void set_dungeon_start_room_datas(const Vector &dungeon_start_room_datas); - - //End Rooms - Ref get_dungeon_end_room_data(const int index) const; - void set_dungeon_end_room_data(const int index, const Ref dungeon_end_room_data); - void add_dungeon_end_room_data(const Ref dungeon_end_room_data); - void remove_dungeon_end_room_data(const int index); - int get_dungeon_end_room_data_count() const; - - Vector get_dungeon_end_room_datas(); - void set_dungeon_end_room_datas(const Vector &dungeon_end_room_datas); - - //Corridors - Ref get_dungeon_corridor_data(const int index) const; - void set_dungeon_corridor_data(const int index, const Ref dungeon_corridor_data); - void add_dungeon_corridor_data(const Ref dungeon_corridor_data); - void remove_dungeon_corridor_data(const int index); - int get_dungeon_corridor_data_count() const; - - Vector get_dungeon_corridor_datas(); - void set_dungeon_corridor_datas(const Vector &dungeon_corridor_datas); - -#ifdef ESS_PRESENT - //Entities - Ref get_entity_data(const int index) const; - void set_entity_data(const int index, const Ref entity_data); - void add_entity_data(const Ref entity_data); - void remove_entity_data(const int index); - int get_entity_data_count() const; - - Vector get_entity_datas(); - void set_entity_datas(const Vector &entity_datas); -#endif - -#ifdef VOXELMAN_PRESENT - //Surfaces - Ref get_voxel_surface(const int index) const; - void set_voxel_surface(const int index, const Ref voxel_surface); - void add_voxel_surface(const Ref voxel_surface); - void remove_voxel_surface(const int index); - int get_voxel_surface_count() const; - - Vector get_voxel_surfaces(); - void set_voxel_surfaces(const Vector &voxel_surfaces); - -#endif - - Ref instance(); - - DungeonData(); - ~DungeonData(); - -protected: - static void _bind_methods(); - -private: - Ref _dungeon; - - Vector2 _level_range; - - int _min_sizex; - int _min_sizey; - int _min_sizez; - - int _max_sizex; - int _max_sizey; - int _max_sizez; - - int _min_room_count; - int _max_room_count; - -#ifdef VOXELMAN_PRESENT - Vector > _environment_datas; -#endif - - Vector > _dungeon_room_datas; - Vector > _dungeon_start_room_datas; - Vector > _dungeon_end_room_datas; - Vector > _dungeon_corridor_datas; - -#ifdef ESS_PRESENT - Vector > _entity_datas; -#endif - -#ifdef VOXELMAN_PRESENT - Vector > _voxel_surfaces; - Vector > _liquid_voxel_surfaces; -#endif -}; - -#endif diff --git a/main/biome.cpp b/main/biome.cpp index 4489b2b..24afa15 100644 --- a/main/biome.cpp +++ b/main/biome.cpp @@ -185,7 +185,7 @@ Vector Biome::get_dungeons() { void Biome::set_dungeons(const Vector &dungeon_datas) { _dungeons.clear(); for (int i = 0; i < dungeon_datas.size(); i++) { - Ref dungeon_data = Ref(dungeon_datas[i]); + Ref dungeon_data = Ref(dungeon_datas[i]); _dungeons.push_back(dungeon_data); } diff --git a/main/dungeon.cpp b/main/dungeon.cpp index 293272a..eda5f01 100644 --- a/main/dungeon.cpp +++ b/main/dungeon.cpp @@ -36,6 +36,64 @@ void Dungeon::set_level_range(Vector2 value) { _level_range = value; } +//Min Size +int Dungeon::get_min_sizex() { + return _min_sizex; +} +void Dungeon::set_min_sizex(int value) { + _min_sizex = value; +} + +int Dungeon::get_min_sizey() { + return _min_sizey; +} +void Dungeon::set_min_sizey(int value) { + _min_sizey = value; +} + +int Dungeon::get_min_sizez() { + return _min_sizez; +} +void Dungeon::set_min_sizez(int value) { + _min_sizez = value; +} + +//Max Size +int Dungeon::get_max_sizex() { + return _max_sizex; +} +void Dungeon::set_max_sizex(int value) { + _max_sizex = value; +} + +int Dungeon::get_max_sizey() { + return _max_sizey; +} +void Dungeon::set_max_sizey(int value) { + _max_sizey = value; +} + +int Dungeon::get_max_sizez() { + return _max_sizez; +} +void Dungeon::set_max_sizez(int value) { + _max_sizez = value; +} + +int Dungeon::get_min_room_count() { + return _min_room_count; +} +void Dungeon::set_min_room_count(int value) { + _min_room_count = value; +} + +int Dungeon::get_max_room_count() { + return _max_room_count; +} +void Dungeon::set_max_room_count(int value) { + _max_room_count = value; +} + //Position int Dungeon::get_posx() { return _posx; @@ -96,13 +154,6 @@ void Dungeon::set_environment(Ref value) { } #endif -Ref Dungeon::get_data() { - return _data; -} -void Dungeon::set_data(Ref value) { - _data = value; -} - //Rooms Ref Dungeon::get_dungeon_room(const int index) const { ERR_FAIL_INDEX_V(index, _dungeon_rooms.size(), Ref()); @@ -127,6 +178,26 @@ int Dungeon::get_dungeon_room_count() const { return _dungeon_rooms.size(); } +Vector Dungeon::get_dungeon_rooms() { + Vector r; + for (int i = 0; i < _dungeon_rooms.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_dungeon_rooms[i].get_ref_ptr()); +#else + r.push_back(_dungeon_rooms[i]); +#endif + } + return r; +} +void Dungeon::set_dungeon_rooms(const Vector &dungeon_rooms) { + _dungeon_rooms.clear(); + for (int i = 0; i < dungeon_rooms.size(); i++) { + Ref dungeon_room_data = Ref(dungeon_rooms[i]); + + _dungeon_rooms.push_back(dungeon_room_data); + } +} + //Start Rooms Ref Dungeon::get_dungeon_start_room(const int index) const { ERR_FAIL_INDEX_V(index, _dungeon_start_rooms.size(), Ref()); @@ -151,6 +222,26 @@ int Dungeon::get_dungeon_start_room_count() const { return _dungeon_start_rooms.size(); } +Vector Dungeon::get_dungeon_start_rooms() { + Vector r; + for (int i = 0; i < _dungeon_start_rooms.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_dungeon_start_rooms[i].get_ref_ptr()); +#else + r.push_back(_dungeon_start_rooms[i]); +#endif + } + return r; +} +void Dungeon::set_dungeon_start_rooms(const Vector &dungeon_start_rooms) { + _dungeon_start_rooms.clear(); + for (int i = 0; i < dungeon_start_rooms.size(); i++) { + Ref dungeon_start_room_data = Ref(dungeon_start_rooms[i]); + + _dungeon_start_rooms.push_back(dungeon_start_room_data); + } +} + //End Rooms Ref Dungeon::get_dungeon_end_room(const int index) const { ERR_FAIL_INDEX_V(index, _dungeon_end_rooms.size(), Ref()); @@ -175,6 +266,26 @@ int Dungeon::get_dungeon_end_room_count() const { return _dungeon_end_rooms.size(); } +Vector Dungeon::get_dungeon_end_rooms() { + Vector r; + for (int i = 0; i < _dungeon_end_rooms.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_dungeon_end_rooms[i].get_ref_ptr()); +#else + r.push_back(_dungeon_end_rooms[i]); +#endif + } + return r; +} +void Dungeon::set_dungeon_end_rooms(const Vector &dungeon_end_rooms) { + _dungeon_end_rooms.clear(); + for (int i = 0; i < dungeon_end_rooms.size(); i++) { + Ref dungeon_end_room_data = Ref(dungeon_end_rooms[i]); + + _dungeon_end_rooms.push_back(dungeon_end_room_data); + } +} + //Corridors Ref Dungeon::get_dungeon_corridor(const int index) const { ERR_FAIL_INDEX_V(index, _dungeon_corridors.size(), Ref()); @@ -198,6 +309,26 @@ int Dungeon::get_dungeon_corridor_count() const { return _dungeon_corridors.size(); } +Vector Dungeon::get_dungeon_corridors() { + Vector r; + for (int i = 0; i < _dungeon_corridors.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_dungeon_corridors[i].get_ref_ptr()); +#else + r.push_back(_dungeon_corridors[i]); +#endif + } + return r; +} +void Dungeon::set_dungeon_corridors(const Vector &dungeon_corridors) { + _dungeon_corridors.clear(); + for (int i = 0; i < dungeon_corridors.size(); i++) { + Ref dungeon_corridor_data = Ref(dungeon_corridors[i]); + + _dungeon_corridors.push_back(dungeon_corridor_data); + } +} + #ifdef ESS_PRESENT //Entities Ref Dungeon::get_entity_data(const int index) const { @@ -221,12 +352,117 @@ void Dungeon::remove_entity_data(const int index) { int Dungeon::get_entity_data_count() const { return _entity_datas.size(); } + +Vector Dungeon::get_entity_datas() { + Vector r; + for (int i = 0; i < _entity_datas.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_entity_datas[i].get_ref_ptr()); +#else + r.push_back(_entity_datas[i]); +#endif + } + return r; +} +void Dungeon::set_entity_datas(const Vector &entity_datas) { + _entity_datas.clear(); + for (int i = 0; i < entity_datas.size(); i++) { + Ref entity_data = Ref(entity_datas[i]); + + _entity_datas.push_back(entity_data); + } +} +#endif + +#ifdef VOXELMAN_PRESENT +//// Surfaces //// +Ref Dungeon::get_voxel_surface(const int index) const { + ERR_FAIL_INDEX_V(index, _voxel_surfaces.size(), Ref()); + + return _voxel_surfaces.get(index); +} +void Dungeon::set_voxel_surface(const int index, const Ref voxel_surface) { + ERR_FAIL_INDEX(index, _voxel_surfaces.size()); + + _voxel_surfaces.set(index, voxel_surface); +} +void Dungeon::add_voxel_surface(const Ref voxel_surface) { + _voxel_surfaces.push_back(voxel_surface); +} +void Dungeon::remove_voxel_surface(const int index) { + ERR_FAIL_INDEX(index, _voxel_surfaces.size()); + + _voxel_surfaces.remove(index); +} +int Dungeon::get_voxel_surface_count() const { + return _voxel_surfaces.size(); +} + +Vector Dungeon::get_voxel_surfaces() { + Vector r; + for (int i = 0; i < _voxel_surfaces.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_voxel_surfaces[i].get_ref_ptr()); +#else + r.push_back(_voxel_surfaces[i]); +#endif + } + return r; +} +void Dungeon::set_voxel_surfaces(const Vector &voxel_surfaces) { + _voxel_surfaces.clear(); + for (int i = 0; i < voxel_surfaces.size(); i++) { + Ref voxel_surface = Ref(voxel_surfaces[i]); + + _voxel_surfaces.push_back(voxel_surface); + } +} + +//Environments +Ref Dungeon::get_environment_data(const int index) const { + ERR_FAIL_INDEX_V(index, _environment_datas.size(), Ref()); + + return _environment_datas.get(index); +} +void Dungeon::set_environment_data(const int index, const Ref environment_data) { + ERR_FAIL_INDEX(index, _environment_datas.size()); + + _environment_datas.set(index, environment_data); +} +void Dungeon::add_environment_data(const Ref environment_data) { + _environment_datas.push_back(environment_data); +} +void Dungeon::remove_environment_data(const int index) { + ERR_FAIL_INDEX(index, _environment_datas.size()); + + _environment_datas.remove(index); +} +int Dungeon::get_environment_data_count() const { + return _environment_datas.size(); +} + +Vector Dungeon::get_environment_datas() { + Vector r; + for (int i = 0; i < _environment_datas.size(); i++) { +#if VERSION_MAJOR < 4 + r.push_back(_environment_datas[i].get_ref_ptr()); +#else + r.push_back(_environment_datas[i]); +#endif + } + return r; +} +void Dungeon::set_environment_datas(const Vector &environment_datas) { + _environment_datas.clear(); + for (int i = 0; i < environment_datas.size(); i++) { + Ref environment_data = Ref(environment_datas[i]); + + _environment_datas.push_back(environment_data); + } +} #endif void Dungeon::setup() { - if (!_data.is_valid()) - return; - if (has_method("_setup")) { call("_setup"); } @@ -234,17 +470,14 @@ void Dungeon::setup() { #ifdef VOXELMAN_PRESENT void Dungeon::setup_library(Ref library) { - if (!_data.is_valid()) - return; - if (has_method("_setup_library")) { call("_setup_library", library); } } void Dungeon::_setup_library(Ref library) { - for (int i = 0; i < _data->get_voxel_surface_count(); ++i) { - Ref s = _data->get_voxel_surface(i); + for (int i = 0; i < get_voxel_surface_count(); ++i) { + Ref s = get_voxel_surface(i); if (s.is_valid()) { library->add_voxel_surface(s); @@ -325,6 +558,17 @@ Ref Dungeon::generate_map() { Dungeon::Dungeon() { _current_seed = 0; + _min_sizex = 0; + _min_sizey = 0; + _min_sizez = 0; + + _max_sizex = 0; + _max_sizey = 0; + _max_sizez = 0; + + _min_room_count = 0; + _max_room_count = 0; + _posx = 0; _posy = 0; _posz = 0; @@ -340,7 +584,6 @@ Dungeon::~Dungeon() { _environment.unref(); #endif - _data.unref(); _dungeon_rooms.clear(); _dungeon_start_rooms.clear(); _dungeon_end_rooms.clear(); @@ -349,6 +592,15 @@ Dungeon::~Dungeon() { #ifdef ESS_PRESENT _entity_datas.clear(); #endif + +#ifdef VOXELMAN_PRESENT + _environment_datas.clear(); +#endif + +#ifdef VOXELMAN_PRESENT + _voxel_surfaces.clear(); + _liquid_voxel_surfaces.clear(); +#endif } void Dungeon::_bind_methods() { @@ -384,6 +636,41 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("set_level_range", "value"), &Dungeon::set_level_range); ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "level_range"), "set_level_range", "get_level_range"); + //Min Size + ClassDB::bind_method(D_METHOD("get_min_sizex"), &Dungeon::get_min_sizex); + ClassDB::bind_method(D_METHOD("set_min_sizex", "value"), &Dungeon::set_min_sizex); + ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizex"), "set_min_sizex", "get_min_sizex"); + + ClassDB::bind_method(D_METHOD("get_min_sizey"), &Dungeon::get_min_sizey); + ClassDB::bind_method(D_METHOD("set_min_sizey", "value"), &Dungeon::set_min_sizey); + ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizey"), "set_min_sizey", "get_min_sizey"); + + ClassDB::bind_method(D_METHOD("get_min_sizez"), &Dungeon::get_min_sizez); + ClassDB::bind_method(D_METHOD("set_min_sizez", "value"), &Dungeon::set_min_sizez); + ADD_PROPERTY(PropertyInfo(Variant::INT, "min_sizez"), "set_min_sizez", "get_min_sizez"); + + //Max Size + ClassDB::bind_method(D_METHOD("get_max_sizex"), &Dungeon::get_max_sizex); + ClassDB::bind_method(D_METHOD("set_max_sizex", "value"), &Dungeon::set_max_sizex); + ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizex"), "set_max_sizex", "get_max_sizex"); + + ClassDB::bind_method(D_METHOD("get_max_sizey"), &Dungeon::get_max_sizey); + ClassDB::bind_method(D_METHOD("set_max_sizey", "value"), &Dungeon::set_max_sizey); + ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizey"), "set_max_sizey", "get_max_sizey"); + + ClassDB::bind_method(D_METHOD("get_max_sizez"), &Dungeon::get_max_sizez); + ClassDB::bind_method(D_METHOD("set_max_sizez", "value"), &Dungeon::set_max_sizez); + ADD_PROPERTY(PropertyInfo(Variant::INT, "max_sizez"), "set_max_sizez", "get_max_sizez"); + + //Room Count + ClassDB::bind_method(D_METHOD("get_min_room_count"), &Dungeon::get_min_room_count); + ClassDB::bind_method(D_METHOD("set_min_room_count", "value"), &Dungeon::set_min_room_count); + ADD_PROPERTY(PropertyInfo(Variant::INT, "min_room_count"), "set_min_room_count", "get_min_room_count"); + + ClassDB::bind_method(D_METHOD("get_max_room_count"), &Dungeon::get_max_room_count); + ClassDB::bind_method(D_METHOD("set_max_room_count", "value"), &Dungeon::set_max_room_count); + ADD_PROPERTY(PropertyInfo(Variant::INT, "max_room_count"), "set_max_room_count", "get_max_room_count"); + //Position ClassDB::bind_method(D_METHOD("get_posx"), &Dungeon::get_posx); ClassDB::bind_method(D_METHOD("set_posx", "value"), &Dungeon::set_posx); @@ -422,10 +709,6 @@ void Dungeon::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "environment", PROPERTY_HINT_RESOURCE_TYPE, "EnvironmentData"), "set_environment", "get_environment"); #endif - ClassDB::bind_method(D_METHOD("get_data"), &Dungeon::get_data); - ClassDB::bind_method(D_METHOD("set_data", "value"), &Dungeon::set_data); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "DungeonData", 0), "set_data", "get_data"); - //Rooms ClassDB::bind_method(D_METHOD("get_dungeon_room", "index"), &Dungeon::get_dungeon_room); ClassDB::bind_method(D_METHOD("set_dungeon_room", "index", "data"), &Dungeon::set_dungeon_room); @@ -434,6 +717,10 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("get_dungeon_room_count"), &Dungeon::get_dungeon_room_count); + ClassDB::bind_method(D_METHOD("get_dungeon_rooms"), &Dungeon::get_dungeon_rooms); + ClassDB::bind_method(D_METHOD("set_dungeon_rooms", "dungeon_rooms"), &Dungeon::set_dungeon_rooms); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_rooms", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_rooms", "get_dungeon_rooms"); + //Start Rooms ClassDB::bind_method(D_METHOD("get_dungeon_start_room", "index"), &Dungeon::get_dungeon_start_room); ClassDB::bind_method(D_METHOD("set_dungeon_start_room", "index", "data"), &Dungeon::set_dungeon_start_room); @@ -442,6 +729,10 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("get_dungeon_start_room_count"), &Dungeon::get_dungeon_start_room_count); + ClassDB::bind_method(D_METHOD("get_dungeon_start_rooms"), &Dungeon::get_dungeon_start_rooms); + ClassDB::bind_method(D_METHOD("set_dungeon_start_rooms", "dungeon_start_rooms"), &Dungeon::set_dungeon_start_rooms); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_start_rooms", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_start_rooms", "get_dungeon_start_rooms"); + //End Rooms ClassDB::bind_method(D_METHOD("get_dungeon_end_room", "index"), &Dungeon::get_dungeon_end_room); ClassDB::bind_method(D_METHOD("set_dungeon_end_room", "index", "data"), &Dungeon::set_dungeon_end_room); @@ -449,6 +740,10 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("remove_dungeon_end_room", "index"), &Dungeon::remove_dungeon_end_room); ClassDB::bind_method(D_METHOD("get_dungeon_end_room_count"), &Dungeon::get_dungeon_end_room_count); + ClassDB::bind_method(D_METHOD("get_dungeon_end_rooms"), &Dungeon::get_dungeon_end_rooms); + ClassDB::bind_method(D_METHOD("set_dungeon_end_rooms", "dungeon_end_rooms"), &Dungeon::set_dungeon_end_rooms); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_end_rooms", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_end_rooms", "get_dungeon_end_rooms"); + //Corridors ClassDB::bind_method(D_METHOD("get_dungeon_corridor", "index"), &Dungeon::get_dungeon_corridor); ClassDB::bind_method(D_METHOD("set_dungeon_corridor", "index", "data"), &Dungeon::set_dungeon_corridor); @@ -456,6 +751,10 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("remove_dungeon_corridor", "index"), &Dungeon::remove_dungeon_corridor); ClassDB::bind_method(D_METHOD("get_dungeon_corridor_count"), &Dungeon::get_dungeon_corridor_count); + ClassDB::bind_method(D_METHOD("get_dungeon_corridors"), &Dungeon::get_dungeon_corridors); + ClassDB::bind_method(D_METHOD("set_dungeon_corridors", "dungeon_corridors"), &Dungeon::set_dungeon_corridors); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_corridors", PROPERTY_HINT_NONE, "17/17:DungeonCorridorData", PROPERTY_USAGE_DEFAULT, "DungeonCorridorData"), "set_dungeon_corridors", "get_dungeon_corridors"); + #ifdef ESS_PRESENT //Entities ClassDB::bind_method(D_METHOD("get_entity_data", "index"), &Dungeon::get_entity_data); @@ -463,6 +762,34 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("add_entity_data", "entity_data"), &Dungeon::add_entity_data); ClassDB::bind_method(D_METHOD("remove_entity_data", "index"), &Dungeon::remove_entity_data); ClassDB::bind_method(D_METHOD("get_entity_data_count"), &Dungeon::get_entity_data_count); + + ClassDB::bind_method(D_METHOD("get_entity_datas"), &Dungeon::get_entity_datas); + ClassDB::bind_method(D_METHOD("set_entity_datas", "entity_datas"), &Dungeon::set_entity_datas); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "entity_datas", PROPERTY_HINT_NONE, "17/17:EntityData", PROPERTY_USAGE_DEFAULT, "EntityData"), "set_entity_datas", "get_entity_datas"); +#endif + +#ifdef VOXELMAN_PRESENT + //Environments + ClassDB::bind_method(D_METHOD("get_environment_data", "index"), &Dungeon::get_environment_data); + ClassDB::bind_method(D_METHOD("set_environment_data", "index", "data"), &Dungeon::set_environment_data); + ClassDB::bind_method(D_METHOD("add_environment_data", "environment_data"), &Dungeon::add_environment_data); + ClassDB::bind_method(D_METHOD("remove_environment_data", "index"), &Dungeon::remove_environment_data); + ClassDB::bind_method(D_METHOD("get_environment_data_count"), &Dungeon::get_environment_data_count); + + ClassDB::bind_method(D_METHOD("get_environment_datas"), &Dungeon::get_environment_datas); + ClassDB::bind_method(D_METHOD("set_environment_datas", "environment_datas"), &Dungeon::set_environment_datas); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "environment_datas", PROPERTY_HINT_NONE, "17/17:EnvironmentData", PROPERTY_USAGE_DEFAULT, "EnvironmentData"), "set_environment_datas", "get_environment_datas"); + + //Surfaces + ClassDB::bind_method(D_METHOD("get_voxel_surface", "index"), &Dungeon::get_voxel_surface); + ClassDB::bind_method(D_METHOD("set_voxel_surface", "index", "data"), &Dungeon::set_voxel_surface); + ClassDB::bind_method(D_METHOD("add_voxel_surface", "voxel_surface"), &Dungeon::add_voxel_surface); + ClassDB::bind_method(D_METHOD("remove_voxel_surface", "index"), &Dungeon::remove_voxel_surface); + ClassDB::bind_method(D_METHOD("get_voxel_surface_count"), &Dungeon::get_voxel_surface_count); + + ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &Dungeon::get_voxel_surfaces); + ClassDB::bind_method(D_METHOD("set_voxel_surfaces", "voxel_surfaces"), &Dungeon::set_voxel_surfaces); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "voxel_surfaces", PROPERTY_HINT_NONE, "17/17:VoxelSurface", PROPERTY_USAGE_DEFAULT, "VoxelSurface"), "set_voxel_surfaces", "get_voxel_surfaces"); #endif BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Image"), "_generate_map")); diff --git a/main/dungeon.h b/main/dungeon.h index d4ba82b..74bcc8b 100644 --- a/main/dungeon.h +++ b/main/dungeon.h @@ -29,8 +29,6 @@ SOFTWARE. #include "dungeon_corridor.h" #include "dungeon_room.h" -#include "../data/dungeon_data.h" - #ifdef VOXELMAN_PRESENT #include "../../voxelman/library/voxelman_library.h" #include "../../voxelman/world/environment_data.h" @@ -44,8 +42,6 @@ SOFTWARE. #include "../../entity_spell_system/entities/data/entity_data.h" #endif -class DungeonData; - class Dungeon : public Resource { GDCLASS(Dungeon, Resource); @@ -56,6 +52,33 @@ public: Vector2 get_level_range(); void set_level_range(Vector2 value); + //Min Size + int get_min_sizex(); + void set_min_sizex(int value); + + int get_min_sizey(); + void set_min_sizey(int value); + + int get_min_sizez(); + void set_min_sizez(int value); + + //Max Size + int get_max_sizex(); + void set_max_sizex(int value); + + int get_max_sizey(); + void set_max_sizey(int value); + + int get_max_sizez(); + void set_max_sizez(int value); + + //Room Count + int get_min_room_count(); + void set_min_room_count(int value); + + int get_max_room_count(); + void set_max_room_count(int value); + //Pos int get_posx(); void set_posx(int value); @@ -86,9 +109,6 @@ public: void set_environment(Ref value); #endif - Ref get_data(); - void set_data(Ref value); - //Rooms Ref get_dungeon_room(const int index) const; void set_dungeon_room(const int index, const Ref dungeon_room); @@ -96,6 +116,9 @@ public: void remove_dungeon_room(const int index); int get_dungeon_room_count() const; + Vector get_dungeon_rooms(); + void set_dungeon_rooms(const Vector &dungeon_rooms); + //Start Rooms Ref get_dungeon_start_room(const int index) const; void set_dungeon_start_room(const int index, const Ref dungeon_start_room); @@ -103,6 +126,9 @@ public: void remove_dungeon_start_room(const int index); int get_dungeon_start_room_count() const; + Vector get_dungeon_start_rooms(); + void set_dungeon_start_rooms(const Vector &dungeon_start_rooms); + //End Rooms Ref get_dungeon_end_room(const int index) const; void set_dungeon_end_room(const int index, const Ref dungeon_end_room); @@ -110,6 +136,9 @@ public: void remove_dungeon_end_room(const int index); int get_dungeon_end_room_count() const; + Vector get_dungeon_end_rooms(); + void set_dungeon_end_rooms(const Vector &dungeon_end_rooms); + //Corridors Ref get_dungeon_corridor(const int index) const; void set_dungeon_corridor(const int index, const Ref dungeon_corridors); @@ -117,6 +146,9 @@ public: void remove_dungeon_corridor(const int index); int get_dungeon_corridor_count() const; + Vector get_dungeon_corridors(); + void set_dungeon_corridors(const Vector &dungeon_corridors); + #ifdef ESS_PRESENT //Entities Ref get_entity_data(const int index) const; @@ -124,6 +156,34 @@ public: void add_entity_data(const Ref entity_datas); void remove_entity_data(const int index); int get_entity_data_count() const; + + Vector get_entity_datas(); + void set_entity_datas(const Vector &entity_datas); +#endif + +#ifdef VOXELMAN_PRESENT + //Environments + Ref get_environment_data(const int index) const; + void set_environment_data(const int index, const Ref environment_data); + void add_environment_data(const Ref environment_data); + void remove_environment_data(const int index); + int get_environment_data_count() const; + + Vector get_environment_datas(); + void set_environment_datas(const Vector &environment_datas); +#endif + +#ifdef VOXELMAN_PRESENT + //Surfaces + Ref get_voxel_surface(const int index) const; + void set_voxel_surface(const int index, const Ref voxel_surface); + void add_voxel_surface(const Ref voxel_surface); + void remove_voxel_surface(const int index); + int get_voxel_surface_count() const; + + Vector get_voxel_surfaces(); + void set_voxel_surfaces(const Vector &voxel_surfaces); + #endif void setup(); @@ -162,11 +222,21 @@ private: int _room_count; + int _min_sizex; + int _min_sizey; + int _min_sizez; + + int _max_sizex; + int _max_sizey; + int _max_sizez; + + int _min_room_count; + int _max_room_count; + #ifdef VOXELMAN_PRESENT Ref _environment; #endif - Ref _data; Vector > _dungeon_rooms; Vector > _dungeon_start_rooms; Vector > _dungeon_end_rooms; @@ -175,6 +245,15 @@ private: #ifdef ESS_PRESENT Vector > _entity_datas; #endif + +#ifdef VOXELMAN_PRESENT + Vector > _environment_datas; +#endif + +#ifdef VOXELMAN_PRESENT + Vector > _voxel_surfaces; + Vector > _liquid_voxel_surfaces; +#endif }; #endif diff --git a/register_types.cpp b/register_types.cpp index 415608e..d06b1e5 100644 --- a/register_types.cpp +++ b/register_types.cpp @@ -23,7 +23,6 @@ SOFTWARE. #include "register_types.h" #include "data/dungeon_corridor_data.h" -#include "data/dungeon_data.h" #include "data/dungeon_room_data.h" #include "data/world_generator_prop_data.h" @@ -38,7 +37,6 @@ SOFTWARE. void register_world_generator_types() { ClassDB::register_class(); ClassDB::register_class(); - ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class();