From b176ecc7bf9678ed4ad7fc5e4622844bbaa86ac7 Mon Sep 17 00:00:00 2001 From: Relintai Date: Fri, 18 Oct 2019 10:22:11 +0200 Subject: [PATCH] More work on the bindings. --- data/dungeon_data.cpp | 323 +++++++++++++++++++++++++++++++++++++++++- data/dungeon_data.h | 108 ++++++++++++-- main/dungeon.cpp | 48 +++++++ main/dungeon.h | 19 +++ 4 files changed, 488 insertions(+), 10 deletions(-) diff --git a/data/dungeon_data.cpp b/data/dungeon_data.cpp index 99e74d3..534152a 100644 --- a/data/dungeon_data.cpp +++ b/data/dungeon_data.cpp @@ -1,5 +1,64 @@ #include "dungeon_data.h" +//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()); @@ -39,6 +98,167 @@ void DungeonData::set_dungeon_room_datas(const Vector &dungeon_room_dat } } +//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++) { + r.push_back(_dungeon_start_room_datas[i].get_ref_ptr()); + } + 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++) { + r.push_back(_dungeon_end_room_datas[i].get_ref_ptr()); + } + 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++) { + r.push_back(_dungeon_corridor_datas[i].get_ref_ptr()); + } + 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); + } +} + +//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++) { + r.push_back(_entity_datas[i].get_ref_ptr()); + } + 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); + } +} + + //Environments Ref DungeonData::get_environment_data(const int index) const { ERR_FAIL_INDEX_V(index, _environment_datas.size(), Ref()); @@ -78,19 +298,36 @@ void DungeonData::set_environment_datas(const Vector &environment_datas } } + + Ref DungeonData::setup_dungeon(int seed) { if (has_method("_setup_dungeon")) { return call("_setup_dungeon", seed); } - return Ref(NULL); + return Ref(); } 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() { + _environment_datas.clear(); + _dungeon_room_datas.clear(); + _dungeon_start_room_datas.clear(); + _dungeon_end_room_datas.clear(); + _dungeon_corridor_datas.clear(); + _entity_datas.clear(); } void DungeonData::_bind_methods() { @@ -98,6 +335,42 @@ void DungeonData::_bind_methods() { ClassDB::bind_method(D_METHOD("setup_dungeon", "seed"), &DungeonData::setup_dungeon); + //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); @@ -109,6 +382,54 @@ void DungeonData::_bind_methods() { 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"); + + //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"); + //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); diff --git a/data/dungeon_data.h b/data/dungeon_data.h index c199f02..f22645d 100644 --- a/data/dungeon_data.h +++ b/data/dungeon_data.h @@ -6,22 +6,41 @@ #include "../main/dungeon.h" #include "dungeon_room_data.h" +#include "dungeon_corridor_data.h" #include "../../voxelman/world/environment_data.h" +#include "../../entity_spell_system/entities/data/entity_data.h" + class DungeonData : public Resource { GDCLASS(DungeonData, Resource); public: - //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); + //Min Size + int get_min_sizex(); + void set_min_sizex(int value); - int get_dungeon_room_data_count() const; + int get_min_sizey(); + void set_min_sizey(int value); - Vector get_dungeon_room_datas(); - void set_dungeon_room_datas(const Vector &dungeon_room_datas); + 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); //Environments Ref get_environment_data(const int index) const; @@ -34,6 +53,61 @@ public: Vector get_environment_datas(); void set_environment_datas(const Vector &environment_datas); + //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); + + //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); + Ref setup_dungeon(int seed); DungeonData(); @@ -43,8 +117,24 @@ protected: static void _bind_methods(); private: - Vector > _dungeon_room_datas; + 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; + Vector > _environment_datas; + + Vector > _dungeon_room_datas; + Vector > _dungeon_start_room_datas; + Vector > _dungeon_end_room_datas; + Vector > _dungeon_corridor_datas; + Vector > _entity_datas; }; #endif diff --git a/main/dungeon.cpp b/main/dungeon.cpp index e06231b..cb4aae5 100644 --- a/main/dungeon.cpp +++ b/main/dungeon.cpp @@ -51,6 +51,13 @@ void Dungeon::set_sizez(int value) { _sizez = value; } +int Dungeon::get_room_count() { + return _room_count; +} +void Dungeon::set_room_count(int value) { + _room_count = value; +} + Ref Dungeon::get_environment() { return _environment; } @@ -154,6 +161,31 @@ int Dungeon::get_dungeon_corridor_count() const { return _dungeon_corridors.size(); } +//Entities +Ref Dungeon::get_entity_data(const int index) const { + ERR_FAIL_INDEX_V(index, _entity_datas.size(), Ref()); + + return _entity_datas.get(index); +} +void Dungeon::set_entity_data(const int index, const Ref entity_data) { + ERR_FAIL_INDEX(index, _entity_datas.size()); + + _entity_datas.set(index, entity_data); +} +void Dungeon::add_entity_data(const Ref entity_data) { + _entity_datas.push_back(entity_data); +} +void Dungeon::remove_entity_data(const int index) { + ERR_FAIL_INDEX(index, _entity_datas.size()); + + _entity_datas.remove(index); +} + +int Dungeon::get_entity_data_count() const { + return _entity_datas.size(); +} + + void Dungeon::setup() { if (has_method("_setup")) { call("_setup"); @@ -188,6 +220,8 @@ Dungeon::Dungeon() { _sizex = 0; _sizey = 0; _sizez = 0; + + _room_count = 0; } Dungeon::~Dungeon() { _environment.unref(); @@ -195,6 +229,7 @@ Dungeon::~Dungeon() { _dungeon_start_rooms.clear(); _dungeon_end_rooms.clear(); _dungeon_corridors.clear(); + _entity_datas.clear(); } void Dungeon::_bind_methods() { @@ -236,6 +271,11 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("set_sizez", "value"), &Dungeon::set_sizez); ADD_PROPERTY(PropertyInfo(Variant::INT, "sizez"), "set_sizez", "get_sizez"); + //Room Count + ClassDB::bind_method(D_METHOD("get_room_count"), &Dungeon::get_room_count); + ClassDB::bind_method(D_METHOD("set_room_count", "value"), &Dungeon::set_room_count); + ADD_PROPERTY(PropertyInfo(Variant::INT, "room_count"), "set_room_count", "get_room_count"); + //Environment ClassDB::bind_method(D_METHOD("get_environment"), &Dungeon::get_environment); ClassDB::bind_method(D_METHOD("set_environment", "value"), &Dungeon::set_environment); @@ -273,6 +313,14 @@ void Dungeon::_bind_methods() { ClassDB::bind_method(D_METHOD("get_dungeon_corridor_count"), &Dungeon::get_dungeon_corridor_count); + //Entities + ClassDB::bind_method(D_METHOD("get_entity_data", "index"), &Dungeon::get_entity_data); + ClassDB::bind_method(D_METHOD("set_entity_data", "index", "data"), &Dungeon::set_entity_data); + 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); + BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Image"), "_generate_map")); ClassDB::bind_method(D_METHOD("generate_map"), &Dungeon::generate_map); diff --git a/main/dungeon.h b/main/dungeon.h index 45d0bba..69bd641 100644 --- a/main/dungeon.h +++ b/main/dungeon.h @@ -10,6 +10,8 @@ #include "../../voxelman/world/voxel_structure.h" #include "../../voxelman/world/environment_data.h" +#include "../../entity_spell_system/entities/data/entity_data.h" + class Dungeon : public Reference { GDCLASS(Dungeon, Reference); @@ -17,6 +19,7 @@ public: int get_seed(); void set_seed(int value); + //Pos int get_posx(); void set_posx(int value); @@ -26,6 +29,7 @@ public: int get_posz(); void set_posz(int value); + //Size int get_sizex(); void set_sizex(int value); @@ -35,6 +39,10 @@ public: int get_sizez(); void set_sizez(int value); + //Room Count + int get_room_count(); + void set_room_count(int value); + //Environment Ref get_environment(); void set_environment(Ref value); @@ -71,6 +79,14 @@ public: int get_dungeon_corridor_count() const; + //Entities + Ref get_entity_data(const int index) const; + void set_entity_data(const int index, const Ref entity_datas); + void add_entity_data(const Ref entity_datas); + void remove_entity_data(const int index); + + int get_entity_data_count() const; + void setup(); void generate_chunk(Ref chunk); void generate_structure(Ref structure); @@ -94,11 +110,14 @@ private: int _sizey; int _sizez; + int _room_count; + Ref _environment; Vector > _dungeon_rooms; Vector > _dungeon_start_rooms; Vector > _dungeon_end_rooms; Vector > _dungeon_corridors; + Vector > _entity_datas; }; #endif