From b3cb5b2def4aeed8b17857b19d047ea114288e3d Mon Sep 17 00:00:00 2001 From: Relintai Date: Sat, 30 Nov 2019 21:46:11 +0100 Subject: [PATCH] Added EntityResourceDatas to the DataManager, also more refactorings. --- entities/entity.cpp | 8 ++-- entities/resources/entity_resource.cpp | 43 +++++++++++++----- entities/resources/entity_resource.h | 15 +++++-- entities/resources/entity_resource_data.cpp | 12 +++++ entities/resources/entity_resource_data.h | 6 +++ entity_data_manager.cpp | 49 ++++++++++++++++++--- entity_data_manager.h | 13 ++++++ 7 files changed, 123 insertions(+), 23 deletions(-) diff --git a/entities/entity.cpp b/entities/entity.cpp index da6cb8f..9fad3bd 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -1553,16 +1553,16 @@ Ref Entity::gets_resource(int index) { return _s_resources.get(index); } -Ref Entity::gets_resource_type(int type) { +Ref Entity::gets_resource_type(int id) { for (int i = 0; i < _s_resources.size(); ++i) { Ref r = _s_resources.get(i); - if (r->get_resource_type() == type) { + if (r->get_data_id() == id) { return r; } } - return Ref(NULL); + return Ref(); } void Entity::adds_resource(Ref resource) { ERR_FAIL_COND(!resource.is_valid()); @@ -1595,7 +1595,7 @@ Ref Entity::getc_resource_type(int type) { for (int i = 0; i < _c_resources.size(); ++i) { Ref r = _c_resources.get(i); - if (r->get_resource_type() == type) { + if (r->get_data_id() == type) { return r; } } diff --git a/entities/resources/entity_resource.cpp b/entities/resources/entity_resource.cpp index 4feb550..0cd5ba4 100644 --- a/entities/resources/entity_resource.cpp +++ b/entities/resources/entity_resource.cpp @@ -2,6 +2,7 @@ #include "../entity.h" #include "../stats/stat.h" +#include "entity_resource_data.h" bool EntityResource::get_dirty() { return _dirty; @@ -17,15 +18,27 @@ void EntityResource::set_should_process(bool value) { _should_process = value; } -int EntityResource::get_resource_type() { - return _type; +Ref EntityResource::get_resource_data() { + return _data; } -void EntityResource::set_resource_type(int value) { - _type = value; +void EntityResource::set_resource_data(Ref value) { + _data = value; + + if (_data.is_valid()) + _data_id = _data->get_id(); + else + _data_id = 0; emit_signal("changed", Ref(this)); } +int EntityResource::get_data_id() { + return _data_id; +} +void EntityResource::set_data_id(int value) { + _data_id = value; +} + int EntityResource::get_current() { return _current; } @@ -113,6 +126,12 @@ void EntityResource::receivec_update_string(String str) { call("_receivec_update_string", str); } +void EntityResource::resolve_references() { + if (EntityDataManager::get_instance() != NULL) { + _data = EntityDataManager::get_instance()->get_entity_resource(_data_id); + } +} + Dictionary EntityResource::to_dict() { return call("_to_dict"); } @@ -126,7 +145,7 @@ Dictionary EntityResource::_to_dict() { dict["dirty"] = _dirty; dict["should_process"] = _should_process; - dict["type"] = _type; + dict["data_id"] = _data_id; dict["current"] = _current; dict["max"] = _max; @@ -138,7 +157,7 @@ void EntityResource::_from_dict(const Dictionary &dict) { _dirty = dict.get("dirty", false); _should_process = dict.get("should_process", false); - _type = dict.get("type", 0); + _data_id = dict.get("data_id", 0); _current = dict.get("current", 0); _max = dict.get("max", 0); } @@ -148,7 +167,7 @@ EntityResource::EntityResource() { _should_process = has_method("_process"); - _type = 0; + _data_id = 0; _current = 0; _max = 0; } @@ -162,9 +181,13 @@ void EntityResource::_bind_methods() { ClassDB::bind_method(D_METHOD("set_should_process", "value"), &EntityResource::set_should_process); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "should_process"), "set_should_process", "get_should_process"); - ClassDB::bind_method(D_METHOD("get_resource_type"), &EntityResource::get_resource_type); - ClassDB::bind_method(D_METHOD("set_resource_type", "value"), &EntityResource::set_resource_type); - ADD_PROPERTY(PropertyInfo(Variant::INT, "resource_type"), "set_resource_type", "get_resource_type"); + ClassDB::bind_method(D_METHOD("get_resource_data"), &EntityResource::get_resource_data); + ClassDB::bind_method(D_METHOD("set_resource_data", "value"), &EntityResource::set_resource_data); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "resource_data", PROPERTY_HINT_RESOURCE_TYPE, "EntityResourceData"), "set_resource_data", "get_resource_data"); + + ClassDB::bind_method(D_METHOD("get_data_id"), &EntityResource::get_data_id); + ClassDB::bind_method(D_METHOD("set_data_id", "value"), &EntityResource::set_data_id); + ADD_PROPERTY(PropertyInfo(Variant::INT, "data_id"), "set_data_id", "get_data_id"); ClassDB::bind_method(D_METHOD("get_current"), &EntityResource::get_current); ClassDB::bind_method(D_METHOD("set_current", "value"), &EntityResource::set_current); diff --git a/entities/resources/entity_resource.h b/entities/resources/entity_resource.h index 5fbeff4..41a4356 100644 --- a/entities/resources/entity_resource.h +++ b/entities/resources/entity_resource.h @@ -5,6 +5,7 @@ class Stat; class Entity; +class EntityResourceData; class EntityResource : public Reference { GDCLASS(EntityResource, Reference); @@ -16,8 +17,11 @@ public: bool get_should_process(); void set_should_process(bool value); - int get_resource_type(); - void set_resource_type(int value); + Ref get_resource_data(); + void set_resource_data(Ref value); + + int get_data_id(); + void set_data_id(int value); int get_current(); void set_current(int value); @@ -44,6 +48,8 @@ public: String gets_update_string(); void receivec_update_string(String str); + void resolve_references(); + Dictionary to_dict(); void from_dict(const Dictionary &dict); @@ -59,7 +65,10 @@ private: Entity *_owner; bool _dirty; bool _should_process; - int _type; + + Ref _data; + int _data_id; + int _current; int _max; }; diff --git a/entities/resources/entity_resource_data.cpp b/entities/resources/entity_resource_data.cpp index 4013848..5ff0d89 100644 --- a/entities/resources/entity_resource_data.cpp +++ b/entities/resources/entity_resource_data.cpp @@ -1,5 +1,12 @@ #include "entity_resource_data.h" +int EntityResourceData::get_id() { + return _id; +} +void EntityResourceData::set_id(int value) { + _id = value; +} + Ref EntityResourceData::get_entity_resource_instance() { if (has_method("_get_entity_resource_instance")) { return call("_get_entity_resource_instance"); @@ -9,9 +16,14 @@ Ref EntityResourceData::get_entity_resource_instance() { } EntityResourceData::EntityResourceData() { + _id = 0; } void EntityResourceData::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_id"), &EntityResourceData::get_id); + ClassDB::bind_method(D_METHOD("set_id", "value"), &EntityResourceData::set_id); + ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id"); + BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "res", PROPERTY_HINT_RESOURCE_TYPE, "EntityResource"), "_get_entity_resource_instance")); ClassDB::bind_method(D_METHOD("get_entity_resource_instance"), &EntityResourceData::get_entity_resource_instance); diff --git a/entities/resources/entity_resource_data.h b/entities/resources/entity_resource_data.h index 9ac8c5c..7ad9c22 100644 --- a/entities/resources/entity_resource_data.h +++ b/entities/resources/entity_resource_data.h @@ -10,12 +10,18 @@ class EntityResourceData : public Resource { GDCLASS(EntityResourceData, Resource); public: + int get_id(); + void set_id(int value); + Ref get_entity_resource_instance(); EntityResourceData(); protected: static void _bind_methods(); + +private: + int _id; }; #endif diff --git a/entity_data_manager.cpp b/entity_data_manager.cpp index 84dd6d9..6e088ce 100644 --- a/entity_data_manager.cpp +++ b/entity_data_manager.cpp @@ -47,35 +47,59 @@ Ref EntityDataManager::get_xp_data() { return _xp_data; } +String EntityDataManager::get_entity_resources_folder() { + return _entity_resources_folder; +} +void EntityDataManager::set_entity_resources_folder(String folder) { + _entity_resources_folder = folder; +} +Vector > *EntityDataManager::get_entity_resources() { + return &_entity_resources; +} +Ref EntityDataManager::get_entity_resource(int class_id) { + if (!_entity_resource_map.has(class_id)) + return Ref(NULL); + + return _entity_resource_map.get(class_id); +} +Ref EntityDataManager::get_entity_resource_index(int index) { + ERR_FAIL_INDEX_V(index, _entity_resources.size(), Ref(NULL)); + + return _entity_resources.get(index); +} +int EntityDataManager::get_entity_resource_count() { + return _entity_resources.size(); +} +void EntityDataManager::add_entity_resource(Ref cls) { + ERR_FAIL_COND(!cls.is_valid()); + + _entity_resources.push_back(cls); + _entity_resource_map.set(cls->get_id(), cls); +} + String EntityDataManager::get_entity_datas_folder() { return _entity_datas_folder; } - void EntityDataManager::set_entity_datas_folder(String folder) { _entity_datas_folder = folder; } - Vector > *EntityDataManager::get_entity_datas() { return &_entity_datas; } - Ref EntityDataManager::get_entity_data(int class_id) { if (!_entity_data_map.has(class_id)) return Ref(NULL); return _entity_data_map.get(class_id); } - Ref EntityDataManager::get_entity_data_index(int index) { ERR_FAIL_INDEX_V(index, _entity_datas.size(), Ref(NULL)); return _entity_datas.get(index); } - int EntityDataManager::get_entity_data_count() { return _entity_datas.size(); } - void EntityDataManager::add_entity_data(Ref cls) { ERR_FAIL_COND(!cls.is_valid()); @@ -649,6 +673,16 @@ void EntityDataManager::_bind_methods() { ClassDB::bind_method(D_METHOD("get_xp_data"), &EntityDataManager::get_xp_data); + //EntityResourceData + ClassDB::bind_method(D_METHOD("get_entity_resources_folder"), &EntityDataManager::get_entity_resources_folder); + ClassDB::bind_method(D_METHOD("set_entity_resources_folder", "folder"), &EntityDataManager::set_entity_resources_folder); + ADD_PROPERTY(PropertyInfo(Variant::STRING, "entity_resources_folder"), "set_entity_resources_folder", "get_entity_resources_folder"); + + ClassDB::bind_method(D_METHOD("add_entity_resource", "cls"), &EntityDataManager::add_entity_resource); + ClassDB::bind_method(D_METHOD("get_entity_resource", "class_id"), &EntityDataManager::get_entity_resource); + ClassDB::bind_method(D_METHOD("get_entity_resource_index", "index"), &EntityDataManager::get_entity_resource_index); + ClassDB::bind_method(D_METHOD("get_entity_resource_count"), &EntityDataManager::get_entity_resource_count); + //EntityData ClassDB::bind_method(D_METHOD("get_entity_datas_folder"), &EntityDataManager::get_entity_datas_folder); ClassDB::bind_method(D_METHOD("set_entity_datas_folder", "folder"), &EntityDataManager::set_entity_datas_folder); @@ -749,6 +783,9 @@ EntityDataManager::EntityDataManager() { EntityDataManager::~EntityDataManager() { instance = NULL; + _entity_resources.clear(); + _entity_resource_map.clear(); + _entity_datas.clear(); _entity_data_map.clear(); diff --git a/entity_data_manager.h b/entity_data_manager.h index ca679e6..db6f315 100644 --- a/entity_data_manager.h +++ b/entity_data_manager.h @@ -22,6 +22,7 @@ class Spell; class EntityData; class CraftRecipe; class ItemTemplate; +class EntityResourceData; class EntityDataManager : public Node { GDCLASS(EntityDataManager, Node); @@ -36,6 +37,14 @@ public: void set_xp_data_path(String path); Ref get_xp_data(); + String get_entity_resources_folder(); + void set_entity_resources_folder(String folder); + Vector > *get_entity_resources(); + Ref get_entity_resource(int class_id); + Ref get_entity_resource_index(int index); + int get_entity_resource_count(); + void add_entity_resource(Ref cls); + String get_entity_datas_folder(); void set_entity_datas_folder(String folder); Vector > *get_entity_datas(); @@ -124,6 +133,10 @@ private: String _xp_data_path; Ref _xp_data; + String _entity_resources_folder; + Vector > _entity_resources; + HashMap > _entity_resource_map; + String _entity_datas_folder; Vector > _entity_datas; HashMap > _entity_data_map;