Relintai/entity_spell_system
1
0
Fork 0
mirror of https://github.com/Relintai/entity_spell_system.git synced 2025-02-22 17:18:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

Renamed DataManager to EntityDataManager. Also moved it to the root of the project.

Browse Source
This commit is contained in:
Relintai 2019-10-19 13:21:21 +02:00
parent df0aeb715f
commit b0ce9818c1
9 changed files with 177 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
SCsub
View File

@ -13,7 +13,6 @@ module_env.add_source_files(env.modules_sources,"item_enums.cpp")
module_env.add_source_files(env.modules_sources,"data/aura.cpp") module_env.add_source_files(env.modules_sources,"data/aura.cpp")
module_env.add_source_files(env.modules_sources,"data/talent_rank_data.cpp") module_env.add_source_files(env.modules_sources,"data/talent_rank_data.cpp")
module_env.add_source_files(env.modules_sources,"data/data_manager.cpp")
module_env.add_source_files(env.modules_sources,"data/xp_data.cpp") module_env.add_source_files(env.modules_sources,"data/xp_data.cpp")
module_env.add_source_files(env.modules_sources,"data/item_stat_modifier.cpp") module_env.add_source_files(env.modules_sources,"data/item_stat_modifier.cpp")
module_env.add_source_files(env.modules_sources,"data/item_template_stat_modifier.cpp") module_env.add_source_files(env.modules_sources,"data/item_template_stat_modifier.cpp")
@ -124,3 +123,5 @@ env.add_source_files(env.modules_sources,"profile_manager/actionbar/action_bar_p
env.add_source_files(env.modules_sources,"profile_manager/class_profile.cpp") env.add_source_files(env.modules_sources,"profile_manager/class_profile.cpp")
env.add_source_files(env.modules_sources,"profile_manager/profile_manager.cpp") env.add_source_files(env.modules_sources,"profile_manager/profile_manager.cpp")
module_env.add_source_files(env.modules_sources,"entity_data_manager.cpp")

4
data/item_instance.cpp
View File

@ -72,8 +72,8 @@ void ItemInstance::_from_dict(const Dictionary &dict) {
_item_template_id = dict.get("item_id", 0); _item_template_id = dict.get("item_id", 0);
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
_item_template = DataManager::get_instance()->get_item_template(_item_template_id); _item_template = EntityDataManager::get_instance()->get_item_template(_item_template_id);
} }
_stack_size = dict.get("stack_size", 0); _stack_size = dict.get("stack_size", 0);

2
data/item_instance.h
View File

@ -8,7 +8,7 @@
#include "../entities/stats/stat.h" #include "../entities/stats/stat.h"
#include "../item_enums.h" #include "../item_enums.h"
#include "data_manager.h" #include "../entity_data_manager.h"
class ItemTemplate; class ItemTemplate;

4
entities/auras/aura_data.cpp
View File

@ -261,8 +261,8 @@ void AuraData::_from_dict(const Dictionary &dict) {
_aura_group = dict.get("aura_group", 0); _aura_group = dict.get("aura_group", 0);
int aura_id = dict.get("aura_id", 0); int aura_id = dict.get("aura_id", 0);
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
Ref<Aura> aura = DataManager::get_instance()->get_aura(aura_id); Ref<Aura> aura = EntityDataManager::get_instance()->get_aura(aura_id);
if (aura.is_valid()) { if (aura.is_valid()) {
_aura = aura; _aura = aura;

20
entities/entity.cpp
View File

@ -52,8 +52,8 @@ int Entity::gets_entity_data_id() {
void Entity::sets_entity_data_id(int value) { void Entity::sets_entity_data_id(int value) {
_s_class_id = value; _s_class_id = value;
/* /*
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
sets_entity_data(DataManager::get_instance()->get_entity_data(value)); sets_entity_data(EntityDataManager::get_instance()->get_entity_data(value));
}*/ }*/
SEND_RPC(rpc("setc_entity_data_id", value), setc_entity_data_id(value)); SEND_RPC(rpc("setc_entity_data_id", value), setc_entity_data_id(value));
@ -65,8 +65,8 @@ int Entity::getc_entity_data_id() {
void Entity::setc_entity_data_id(int value) { void Entity::setc_entity_data_id(int value) {
_c_class_id = value; _c_class_id = value;
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
setc_entity_data(DataManager::get_instance()->get_entity_data(value)); setc_entity_data(EntityDataManager::get_instance()->get_entity_data(value));
} }
} }
@ -712,8 +712,8 @@ void Entity::_from_dict(const Dictionary &dict) {
for (int i = 0; i < known_recipes.size(); ++i) { for (int i = 0; i < known_recipes.size(); ++i) {
int crid = known_recipes.get(String::num(i), 0); int crid = known_recipes.get(String::num(i), 0);
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
Ref<CraftRecipe> cr = DataManager::get_instance()->get_craft_data(crid); Ref<CraftRecipe> cr = EntityDataManager::get_instance()->get_craft_data(crid);
if (cr.is_valid()) { if (cr.is_valid()) {
adds_craft_recipe(cr); adds_craft_recipe(cr);
@ -730,8 +730,8 @@ void Entity::_from_dict(const Dictionary &dict) {
for (int i = 0; i < known_spells.size(); ++i) { for (int i = 0; i < known_spells.size(); ++i) {
int spell_id = known_spells.get(String::num(i), 0); int spell_id = known_spells.get(String::num(i), 0);
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
Ref<Spell> sp = DataManager::get_instance()->get_spell(spell_id); Ref<Spell> sp = EntityDataManager::get_instance()->get_spell(spell_id);
if (sp.is_valid()) { if (sp.is_valid()) {
_s_spells.push_back(sp); _s_spells.push_back(sp);
@ -789,8 +789,8 @@ void Entity::_from_dict(const Dictionary &dict) {
int edi = dict.get("entity_data_id", 0); int edi = dict.get("entity_data_id", 0);
if (DataManager::get_instance() != NULL) { if (EntityDataManager::get_instance() != NULL) {
sets_entity_data(DataManager::get_instance()->get_entity_data(edi)); sets_entity_data(EntityDataManager::get_instance()->get_entity_data(edi));
} }
sets_entity_data_id(edi); sets_entity_data_id(edi);

2
entities/entity.h
View File

@ -23,7 +23,7 @@
#include "../data/spell.h" #include "../data/spell.h"
#include "stats/stat.h" #include "stats/stat.h"
#include "../data/data_manager.h" #include "../entity_data_manager.h"
#include "../entity_enums.h" #include "../entity_enums.h"
#include "../skeleton/character_skeleton.h" #include "../skeleton/character_skeleton.h"
#include "../utility/entity_create_info.h" #include "../utility/entity_create_info.h"

292
data/data_manager.cpp → entity_data_manager.cpp
View File

@ -1,17 +1,17 @@
#include "data_manager.h" #include "entity_data_manager.h"
#include "../entities/data/entity_data.h" #include "./entities/data/entity_data.h"
#include "aura.h" #include "./data/aura.h"
#include "craft_recipe.h" #include "./data/craft_recipe.h"
#include "spell.h" #include "./data/spell.h"
DataManager *DataManager::instance; EntityDataManager *EntityDataManager::instance;
DataManager *DataManager::get_instance() { EntityDataManager *EntityDataManager::get_instance() {
return instance; return instance;
} }
void DataManager::_notification(int p_what) { void EntityDataManager::_notification(int p_what) {
switch (p_what) { switch (p_what) {
@ -26,263 +26,263 @@ void DataManager::_notification(int p_what) {
} }
} }
Ref<Aura> DataManager::get_skill_for_armor_type(int index) { Ref<Aura> EntityDataManager::get_skill_for_armor_type(int index) {
ERR_FAIL_INDEX_V(index, ItemEnums::ARMOR_TYPE_MAX, Ref<Aura>()); ERR_FAIL_INDEX_V(index, ItemEnums::ARMOR_TYPE_MAX, Ref<Aura>());
return _armor_type_skills[index]; return _armor_type_skills[index];
} }
void DataManager::set_skill_for_armor_type(int index, Ref<Aura> aura) { void EntityDataManager::set_skill_for_armor_type(int index, Ref<Aura> aura) {
ERR_FAIL_INDEX(index, ItemEnums::ARMOR_TYPE_MAX); ERR_FAIL_INDEX(index, ItemEnums::ARMOR_TYPE_MAX);
_armor_type_skills[index] = aura; _armor_type_skills[index] = aura;
} }
String DataManager::get_xp_data_path() { String EntityDataManager::get_xp_data_path() {
return _xp_data_path; return _xp_data_path;
} }
void DataManager::set_xp_data_path(String path) { void EntityDataManager::set_xp_data_path(String path) {
_xp_data_path = path; _xp_data_path = path;
} }
Ref<XPData> DataManager::get_xp_data() { Ref<XPData> EntityDataManager::get_xp_data() {
return _xp_data; return _xp_data;
} }
String DataManager::get_entity_datas_folder() { String EntityDataManager::get_entity_datas_folder() {
return _entity_datas_folder; return _entity_datas_folder;
} }
void DataManager::set_entity_datas_folder(String folder) { void EntityDataManager::set_entity_datas_folder(String folder) {
_entity_datas_folder = folder; _entity_datas_folder = folder;
} }
Vector<Ref<EntityData> > *DataManager::get_entity_datas() { Vector<Ref<EntityData> > *EntityDataManager::get_entity_datas() {
return &_entity_datas; return &_entity_datas;
} }
Ref<EntityData> DataManager::get_entity_data(int class_id) { Ref<EntityData> EntityDataManager::get_entity_data(int class_id) {
if (!_entity_data_map.has(class_id)) if (!_entity_data_map.has(class_id))
return Ref<EntityData>(NULL); return Ref<EntityData>(NULL);
return _entity_data_map.get(class_id); return _entity_data_map.get(class_id);
} }
Ref<EntityData> DataManager::get_entity_data_index(int index) { Ref<EntityData> EntityDataManager::get_entity_data_index(int index) {
ERR_FAIL_INDEX_V(index, _entity_datas.size(), Ref<EntityData>(NULL)); ERR_FAIL_INDEX_V(index, _entity_datas.size(), Ref<EntityData>(NULL));
return _entity_datas.get(index); return _entity_datas.get(index);
} }
int DataManager::get_entity_data_count() { int EntityDataManager::get_entity_data_count() {
return _entity_datas.size(); return _entity_datas.size();
} }
void DataManager::add_entity_data(Ref<EntityData> cls) { void EntityDataManager::add_entity_data(Ref<EntityData> cls) {
ERR_FAIL_COND(!cls.is_valid()); ERR_FAIL_COND(!cls.is_valid());
_entity_datas.push_back(cls); _entity_datas.push_back(cls);
_entity_data_map.set(cls->get_id(), cls); _entity_data_map.set(cls->get_id(), cls);
} }
String DataManager::get_spells_folder() { String EntityDataManager::get_spells_folder() {
return _spells_folder; return _spells_folder;
} }
void DataManager::set_spells_folder(String folder) { void EntityDataManager::set_spells_folder(String folder) {
_spells_folder = folder; _spells_folder = folder;
} }
Vector<Ref<Spell> > *DataManager::get_spells() { Vector<Ref<Spell> > *EntityDataManager::get_spells() {
return &_spells; return &_spells;
} }
Ref<Spell> DataManager::get_spell(int spell_id) { Ref<Spell> EntityDataManager::get_spell(int spell_id) {
ERR_FAIL_COND_V(!_spell_map.has(spell_id), Ref<Spell>(NULL)); ERR_FAIL_COND_V(!_spell_map.has(spell_id), Ref<Spell>(NULL));
return _spell_map.get(spell_id); return _spell_map.get(spell_id);
} }
Ref<Spell> DataManager::get_spell_index(int index) { Ref<Spell> EntityDataManager::get_spell_index(int index) {
ERR_FAIL_INDEX_V(index, _spells.size(), Ref<Spell>(NULL)); ERR_FAIL_INDEX_V(index, _spells.size(), Ref<Spell>(NULL));
return _spells.get(index); return _spells.get(index);
} }
int DataManager::get_spell_count() { int EntityDataManager::get_spell_count() {
return _spells.size(); return _spells.size();
} }
void DataManager::add_spell(Ref<Spell> spell) { void EntityDataManager::add_spell(Ref<Spell> spell) {
ERR_FAIL_COND(!spell.is_valid()); ERR_FAIL_COND(!spell.is_valid());
_spells.push_back(spell); _spells.push_back(spell);
_spell_map.set(spell->get_id(), spell); _spell_map.set(spell->get_id(), spell);
} }
void DataManager::add_aura(Ref<Aura> aura) { void EntityDataManager::add_aura(Ref<Aura> aura) {
ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!aura.is_valid());
_auras.push_back(aura); _auras.push_back(aura);
_aura_map.set(aura->get_id(), aura); _aura_map.set(aura->get_id(), aura);
} }
String DataManager::get_auras_folder() { String EntityDataManager::get_auras_folder() {
return _auras_folder; return _auras_folder;
} }
void DataManager::set_auras_folder(String folder) { void EntityDataManager::set_auras_folder(String folder) {
_auras_folder = folder; _auras_folder = folder;
} }
Vector<Ref<Aura> > *DataManager::get_auras() { Vector<Ref<Aura> > *EntityDataManager::get_auras() {
return &_auras; return &_auras;
} }
Ref<Aura> DataManager::get_aura(int aura_id) { Ref<Aura> EntityDataManager::get_aura(int aura_id) {
ERR_FAIL_COND_V(!_aura_map.has(aura_id), Ref<Aura>(NULL)); ERR_FAIL_COND_V(!_aura_map.has(aura_id), Ref<Aura>(NULL));
return _aura_map.get(aura_id); return _aura_map.get(aura_id);
} }
Ref<Aura> DataManager::get_aura_index(int index) { Ref<Aura> EntityDataManager::get_aura_index(int index) {
ERR_FAIL_INDEX_V(index, _auras.size(), Ref<Aura>(NULL)); ERR_FAIL_INDEX_V(index, _auras.size(), Ref<Aura>(NULL));
return _auras.get(index); return _auras.get(index);
} }
int DataManager::get_aura_count() { int EntityDataManager::get_aura_count() {
return _auras.size(); return _auras.size();
} }
//Craft Data //Craft Data
void DataManager::add_craft_data(Ref<CraftRecipe> cda) { void EntityDataManager::add_craft_data(Ref<CraftRecipe> cda) {
ERR_FAIL_COND(!cda.is_valid()); ERR_FAIL_COND(!cda.is_valid());
_craft_datas.push_back(cda); _craft_datas.push_back(cda);
_craft_data_map.set(cda->get_id(), cda); _craft_data_map.set(cda->get_id(), cda);
} }
String DataManager::get_craft_data_folder() { String EntityDataManager::get_craft_data_folder() {
return _craft_data_folder; return _craft_data_folder;
} }
void DataManager::set_craft_data_folder(String folder) { void EntityDataManager::set_craft_data_folder(String folder) {
_craft_data_folder = folder; _craft_data_folder = folder;
} }
Vector<Ref<CraftRecipe> > *DataManager::get_craft_datas() { Vector<Ref<CraftRecipe> > *EntityDataManager::get_craft_datas() {
return &_craft_datas; return &_craft_datas;
} }
Ref<CraftRecipe> DataManager::get_craft_data(int craft_id) { Ref<CraftRecipe> EntityDataManager::get_craft_data(int craft_id) {
ERR_FAIL_COND_V(!_craft_data_map.has(craft_id), Ref<CraftRecipe>(NULL)); ERR_FAIL_COND_V(!_craft_data_map.has(craft_id), Ref<CraftRecipe>(NULL));
return _craft_data_map.get(craft_id); return _craft_data_map.get(craft_id);
} }
Ref<CraftRecipe> DataManager::get_craft_data_index(int index) { Ref<CraftRecipe> EntityDataManager::get_craft_data_index(int index) {
ERR_FAIL_INDEX_V(index, _craft_datas.size(), Ref<CraftRecipe>(NULL)); ERR_FAIL_INDEX_V(index, _craft_datas.size(), Ref<CraftRecipe>(NULL));
return _craft_datas.get(index); return _craft_datas.get(index);
} }
int DataManager::get_craft_data_count() { int EntityDataManager::get_craft_data_count() {
return _craft_datas.size(); return _craft_datas.size();
} }
String DataManager::get_item_template_folder() { String EntityDataManager::get_item_template_folder() {
return _item_template_folder; return _item_template_folder;
} }
void DataManager::set_item_template_folder(String folder) { void EntityDataManager::set_item_template_folder(String folder) {
_item_template_folder = folder; _item_template_folder = folder;
} }
Vector<Ref<ItemTemplate> > *DataManager::get_item_templates() { Vector<Ref<ItemTemplate> > *EntityDataManager::get_item_templates() {
return &_item_templates; return &_item_templates;
} }
void DataManager::add_item_template(Ref<ItemTemplate> cda) { void EntityDataManager::add_item_template(Ref<ItemTemplate> cda) {
ERR_FAIL_COND(!cda.is_valid()); ERR_FAIL_COND(!cda.is_valid());
_item_templates.push_back(cda); _item_templates.push_back(cda);
_item_template_map.set(cda->get_id(), cda); _item_template_map.set(cda->get_id(), cda);
} }
Ref<ItemTemplate> DataManager::get_item_template(int item_id) { Ref<ItemTemplate> EntityDataManager::get_item_template(int item_id) {
ERR_FAIL_COND_V(!_item_template_map.has(item_id), Ref<ItemTemplate>(NULL)); ERR_FAIL_COND_V(!_item_template_map.has(item_id), Ref<ItemTemplate>(NULL));
return _item_template_map.get(item_id); return _item_template_map.get(item_id);
} }
Ref<ItemTemplate> DataManager::get_item_template_index(int index) { Ref<ItemTemplate> EntityDataManager::get_item_template_index(int index) {
ERR_FAIL_INDEX_V(index, _item_templates.size(), Ref<ItemTemplate>(NULL)); ERR_FAIL_INDEX_V(index, _item_templates.size(), Ref<ItemTemplate>(NULL));
return _item_templates.get(index); return _item_templates.get(index);
} }
int DataManager::get_item_template_count() { int EntityDataManager::get_item_template_count() {
return _item_templates.size(); return _item_templates.size();
} }
String DataManager::get_mob_data_folder() { String EntityDataManager::get_mob_data_folder() {
return _mob_data_folder; return _mob_data_folder;
} }
void DataManager::set_mob_data_folder(String folder) { void EntityDataManager::set_mob_data_folder(String folder) {
_mob_data_folder = folder; _mob_data_folder = folder;
} }
Vector<Ref<EntityData> > *DataManager::get_mob_datas() { Vector<Ref<EntityData> > *EntityDataManager::get_mob_datas() {
return &_mob_datas; return &_mob_datas;
} }
void DataManager::add_mob_data(Ref<EntityData> cda) { void EntityDataManager::add_mob_data(Ref<EntityData> cda) {
ERR_FAIL_COND(!cda.is_valid()); ERR_FAIL_COND(!cda.is_valid());
_mob_datas.push_back(cda); _mob_datas.push_back(cda);
_mob_data_map.set(cda->get_id(), cda); _mob_data_map.set(cda->get_id(), cda);
} }
Ref<EntityData> DataManager::get_mob_data(int item_id) { Ref<EntityData> EntityDataManager::get_mob_data(int item_id) {
ERR_FAIL_COND_V(!_mob_data_map.has(item_id), Ref<EntityData>(NULL)); ERR_FAIL_COND_V(!_mob_data_map.has(item_id), Ref<EntityData>(NULL));
return _mob_data_map.get(item_id); return _mob_data_map.get(item_id);
} }
Ref<EntityData> DataManager::get_mob_data_index(int index) { Ref<EntityData> EntityDataManager::get_mob_data_index(int index) {
ERR_FAIL_INDEX_V(index, _mob_datas.size(), Ref<EntityData>(NULL)); ERR_FAIL_INDEX_V(index, _mob_datas.size(), Ref<EntityData>(NULL));
return _mob_datas.get(index); return _mob_datas.get(index);
} }
int DataManager::get_mob_data_count() { int EntityDataManager::get_mob_data_count() {
return _mob_datas.size(); return _mob_datas.size();
} }
String DataManager::get_player_character_data_folder() { String EntityDataManager::get_player_character_data_folder() {
return _player_character_data_folder; return _player_character_data_folder;
} }
void DataManager::set_player_character_data_folder(String folder) { void EntityDataManager::set_player_character_data_folder(String folder) {
_player_character_data_folder = folder; _player_character_data_folder = folder;
} }
Vector<Ref<EntityData> > *DataManager::get_player_character_datas() { Vector<Ref<EntityData> > *EntityDataManager::get_player_character_datas() {
return &_player_character_datas; return &_player_character_datas;
} }
void DataManager::add_player_character_data(Ref<EntityData> cda) { void EntityDataManager::add_player_character_data(Ref<EntityData> cda) {
ERR_FAIL_COND(!cda.is_valid()); ERR_FAIL_COND(!cda.is_valid());
_player_character_datas.push_back(cda); _player_character_datas.push_back(cda);
_player_character_data_map.set(cda->get_id(), cda); _player_character_data_map.set(cda->get_id(), cda);
} }
Ref<EntityData> DataManager::get_player_character_data(int item_id) { Ref<EntityData> EntityDataManager::get_player_character_data(int item_id) {
ERR_FAIL_COND_V(!_player_character_data_map.has(item_id), Ref<EntityData>(NULL)); ERR_FAIL_COND_V(!_player_character_data_map.has(item_id), Ref<EntityData>(NULL));
return _player_character_data_map.get(item_id); return _player_character_data_map.get(item_id);
} }
Ref<EntityData> DataManager::get_player_character_data_index(int index) { Ref<EntityData> EntityDataManager::get_player_character_data_index(int index) {
ERR_FAIL_INDEX_V(index, _player_character_datas.size(), Ref<EntityData>(NULL)); ERR_FAIL_INDEX_V(index, _player_character_datas.size(), Ref<EntityData>(NULL));
return _player_character_datas.get(index); return _player_character_datas.get(index);
} }
int DataManager::get_player_character_data_count() { int EntityDataManager::get_player_character_data_count() {
return _player_character_datas.size(); return _player_character_datas.size();
} }
void DataManager::load_all() { void EntityDataManager::load_all() {
load_xp_data(); load_xp_data();
load_spells(); load_spells();
load_auras(); load_auras();
@ -293,7 +293,7 @@ void DataManager::load_all() {
load_player_character_datas(); load_player_character_datas();
} }
void DataManager::load_xp_data() { void EntityDataManager::load_xp_data() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_xp_data_path == ""); ERR_FAIL_COND(_xp_data_path == "");
@ -315,7 +315,7 @@ void DataManager::load_xp_data() {
_xp_data = d; _xp_data = d;
} }
void DataManager::load_spells() { void EntityDataManager::load_spells() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_spells_folder.ends_with("/")); ERR_FAIL_COND(_spells_folder.ends_with("/"));
@ -354,7 +354,7 @@ void DataManager::load_spells() {
} }
} }
void DataManager::load_auras() { void EntityDataManager::load_auras() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_auras_folder.ends_with("/")); ERR_FAIL_COND(_auras_folder.ends_with("/"));
@ -393,7 +393,7 @@ void DataManager::load_auras() {
} }
} }
void DataManager::load_characters() { void EntityDataManager::load_characters() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_entity_datas_folder.ends_with("/")); ERR_FAIL_COND(_entity_datas_folder.ends_with("/"));
@ -432,7 +432,7 @@ void DataManager::load_characters() {
} }
} }
void DataManager::load_craft_datas() { void EntityDataManager::load_craft_datas() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_craft_data_folder.ends_with("/")); ERR_FAIL_COND(_craft_data_folder.ends_with("/"));
@ -471,7 +471,7 @@ void DataManager::load_craft_datas() {
} }
} }
void DataManager::load_item_templates() { void EntityDataManager::load_item_templates() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_item_template_folder.ends_with("/")); ERR_FAIL_COND(_item_template_folder.ends_with("/"));
@ -510,7 +510,7 @@ void DataManager::load_item_templates() {
} }
} }
void DataManager::load_mob_datas() { void EntityDataManager::load_mob_datas() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_mob_data_folder.ends_with("/")); ERR_FAIL_COND(_mob_data_folder.ends_with("/"));
@ -549,7 +549,7 @@ void DataManager::load_mob_datas() {
} }
} }
void DataManager::load_player_character_datas() { void EntityDataManager::load_player_character_datas() {
_Directory dir; _Directory dir;
ERR_FAIL_COND(_player_character_data_folder.ends_with("/")); ERR_FAIL_COND(_player_character_data_folder.ends_with("/"));
@ -588,165 +588,165 @@ void DataManager::load_player_character_datas() {
} }
} }
void DataManager::list_characters() { void EntityDataManager::list_characters() {
for (int i = 0; i < _entity_datas.size(); ++i) { for (int i = 0; i < _entity_datas.size(); ++i) {
print_error(itos(i) + ": " + _entity_datas.get(i)->get_text_name()); print_error(itos(i) + ": " + _entity_datas.get(i)->get_text_name());
} }
} }
void DataManager::list_spells() { void EntityDataManager::list_spells() {
for (int i = 0; i < _spells.size(); ++i) { for (int i = 0; i < _spells.size(); ++i) {
print_error(itos(i) + ": " + _spells.get(i)->get_text_name()); print_error(itos(i) + ": " + _spells.get(i)->get_text_name());
} }
} }
void DataManager::list_auras() { void EntityDataManager::list_auras() {
for (int i = 0; i < _auras.size(); ++i) { for (int i = 0; i < _auras.size(); ++i) {
print_error(itos(i) + ": " + _auras.get(i)->get_text_name()); print_error(itos(i) + ": " + _auras.get(i)->get_text_name());
} }
} }
void DataManager::list_craft_data() { void EntityDataManager::list_craft_data() {
for (int i = 0; i < _craft_datas.size(); ++i) { for (int i = 0; i < _craft_datas.size(); ++i) {
print_error(itos(i) + ": " + _craft_datas.get(i)->get_text_name()); print_error(itos(i) + ": " + _craft_datas.get(i)->get_text_name());
} }
} }
void DataManager::list_item_templates() { void EntityDataManager::list_item_templates() {
for (int i = 0; i < _item_templates.size(); ++i) { for (int i = 0; i < _item_templates.size(); ++i) {
print_error(itos(i) + ": " + _item_templates.get(i)->get_text_name()); print_error(itos(i) + ": " + _item_templates.get(i)->get_text_name());
} }
} }
void DataManager::list_mob_datas() { void EntityDataManager::list_mob_datas() {
for (int i = 0; i < _mob_datas.size(); ++i) { for (int i = 0; i < _mob_datas.size(); ++i) {
print_error(itos(i) + ": " + _mob_datas.get(i)->get_text_name()); print_error(itos(i) + ": " + _mob_datas.get(i)->get_text_name());
} }
} }
void DataManager::list_player_character_datas() { void EntityDataManager::list_player_character_datas() {
for (int i = 0; i < _player_character_datas.size(); ++i) { for (int i = 0; i < _player_character_datas.size(); ++i) {
print_error(itos(i) + ": " + _player_character_datas.get(i)->get_text_name()); print_error(itos(i) + ": " + _player_character_datas.get(i)->get_text_name());
} }
} }
void DataManager::_bind_methods() { void EntityDataManager::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_skill_for_armor_type", "index"), &DataManager::get_skill_for_armor_type); ClassDB::bind_method(D_METHOD("get_skill_for_armor_type", "index"), &EntityDataManager::get_skill_for_armor_type);
ClassDB::bind_method(D_METHOD("set_skill_for_armor_type", "index", "aura"), &DataManager::set_skill_for_armor_type); ClassDB::bind_method(D_METHOD("set_skill_for_armor_type", "index", "aura"), &EntityDataManager::set_skill_for_armor_type);
for (int i = 0; i < ItemEnums::ARMOR_TYPE_MAX; ++i) { for (int i = 0; i < ItemEnums::ARMOR_TYPE_MAX; ++i) {
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "skill_for_armor_type_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_skill_for_armor_type", "get_skill_for_armor_type", i); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "skill_for_armor_type_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_skill_for_armor_type", "get_skill_for_armor_type", i);
} }
ClassDB::bind_method(D_METHOD("get_automatic_load"), &DataManager::get_automatic_load); ClassDB::bind_method(D_METHOD("get_automatic_load"), &EntityDataManager::get_automatic_load);
ClassDB::bind_method(D_METHOD("set_automatic_load", "load"), &DataManager::set_automatic_load); ClassDB::bind_method(D_METHOD("set_automatic_load", "load"), &EntityDataManager::set_automatic_load);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "automatic_load"), "set_automatic_load", "get_automatic_load"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "automatic_load"), "set_automatic_load", "get_automatic_load");
//XPData //XPData
ClassDB::bind_method(D_METHOD("get_xp_data_path"), &DataManager::get_xp_data_path); ClassDB::bind_method(D_METHOD("get_xp_data_path"), &EntityDataManager::get_xp_data_path);
ClassDB::bind_method(D_METHOD("set_xp_data_path", "path"), &DataManager::set_xp_data_path); ClassDB::bind_method(D_METHOD("set_xp_data_path", "path"), &EntityDataManager::set_xp_data_path);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "xp_data_path"), "set_xp_data_path", "get_xp_data_path"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "xp_data_path"), "set_xp_data_path", "get_xp_data_path");
ClassDB::bind_method(D_METHOD("get_xp_data"), &DataManager::get_xp_data); ClassDB::bind_method(D_METHOD("get_xp_data"), &EntityDataManager::get_xp_data);
//EntityData //EntityData
ClassDB::bind_method(D_METHOD("get_entity_datas_folder"), &DataManager::get_entity_datas_folder); ClassDB::bind_method(D_METHOD("get_entity_datas_folder"), &EntityDataManager::get_entity_datas_folder);
ClassDB::bind_method(D_METHOD("set_entity_datas_folder", "folder"), &DataManager::set_entity_datas_folder); ClassDB::bind_method(D_METHOD("set_entity_datas_folder", "folder"), &EntityDataManager::set_entity_datas_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "entity_datas_folder"), "set_entity_datas_folder", "get_entity_datas_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "entity_datas_folder"), "set_entity_datas_folder", "get_entity_datas_folder");
ClassDB::bind_method(D_METHOD("add_entity_data", "cls"), &DataManager::add_entity_data); ClassDB::bind_method(D_METHOD("add_entity_data", "cls"), &EntityDataManager::add_entity_data);
ClassDB::bind_method(D_METHOD("get_entity_data", "class_id"), &DataManager::get_entity_data); ClassDB::bind_method(D_METHOD("get_entity_data", "class_id"), &EntityDataManager::get_entity_data);
ClassDB::bind_method(D_METHOD("get_entity_data_index", "index"), &DataManager::get_entity_data_index); ClassDB::bind_method(D_METHOD("get_entity_data_index", "index"), &EntityDataManager::get_entity_data_index);
ClassDB::bind_method(D_METHOD("get_entity_data_count"), &DataManager::get_entity_data_count); ClassDB::bind_method(D_METHOD("get_entity_data_count"), &EntityDataManager::get_entity_data_count);
//Spell //Spell
ClassDB::bind_method(D_METHOD("get_spells_folder"), &DataManager::get_spells_folder); ClassDB::bind_method(D_METHOD("get_spells_folder"), &EntityDataManager::get_spells_folder);
ClassDB::bind_method(D_METHOD("set_spells_folder", "folder"), &DataManager::set_spells_folder); ClassDB::bind_method(D_METHOD("set_spells_folder", "folder"), &EntityDataManager::set_spells_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "spells_folder"), "set_spells_folder", "get_spells_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "spells_folder"), "set_spells_folder", "get_spells_folder");
ClassDB::bind_method(D_METHOD("add_spell", "spell"), &DataManager::add_spell); ClassDB::bind_method(D_METHOD("add_spell", "spell"), &EntityDataManager::add_spell);
ClassDB::bind_method(D_METHOD("get_spell", "spell_id"), &DataManager::get_spell); ClassDB::bind_method(D_METHOD("get_spell", "spell_id"), &EntityDataManager::get_spell);
ClassDB::bind_method(D_METHOD("get_spell_index", "index"), &DataManager::get_spell_index); ClassDB::bind_method(D_METHOD("get_spell_index", "index"), &EntityDataManager::get_spell_index);
ClassDB::bind_method(D_METHOD("get_spell_count"), &DataManager::get_spell_count); ClassDB::bind_method(D_METHOD("get_spell_count"), &EntityDataManager::get_spell_count);
//Aura //Aura
ClassDB::bind_method(D_METHOD("get_auras_folder"), &DataManager::get_auras_folder); ClassDB::bind_method(D_METHOD("get_auras_folder"), &EntityDataManager::get_auras_folder);
ClassDB::bind_method(D_METHOD("set_auras_folder", "folder"), &DataManager::set_auras_folder); ClassDB::bind_method(D_METHOD("set_auras_folder", "folder"), &EntityDataManager::set_auras_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "auras_folder"), "set_auras_folder", "get_auras_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "auras_folder"), "set_auras_folder", "get_auras_folder");
ClassDB::bind_method(D_METHOD("add_aura", "spell"), &DataManager::add_aura); ClassDB::bind_method(D_METHOD("add_aura", "spell"), &EntityDataManager::add_aura);
ClassDB::bind_method(D_METHOD("get_aura", "id"), &DataManager::get_aura); ClassDB::bind_method(D_METHOD("get_aura", "id"), &EntityDataManager::get_aura);
ClassDB::bind_method(D_METHOD("get_aura_index", "index"), &DataManager::get_aura_index); ClassDB::bind_method(D_METHOD("get_aura_index", "index"), &EntityDataManager::get_aura_index);
ClassDB::bind_method(D_METHOD("get_aura_count"), &DataManager::get_aura_count); ClassDB::bind_method(D_METHOD("get_aura_count"), &EntityDataManager::get_aura_count);
//Craft Data //Craft Data
ClassDB::bind_method(D_METHOD("get_craft_data_folder"), &DataManager::get_craft_data_folder); ClassDB::bind_method(D_METHOD("get_craft_data_folder"), &EntityDataManager::get_craft_data_folder);
ClassDB::bind_method(D_METHOD("set_craft_data_folder", "folder"), &DataManager::set_craft_data_folder); ClassDB::bind_method(D_METHOD("set_craft_data_folder", "folder"), &EntityDataManager::set_craft_data_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "craft_data_folder"), "set_craft_data_folder", "get_craft_data_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "craft_data_folder"), "set_craft_data_folder", "get_craft_data_folder");
ClassDB::bind_method(D_METHOD("add_craft_data", "craft_data"), &DataManager::add_craft_data); ClassDB::bind_method(D_METHOD("add_craft_data", "craft_data"), &EntityDataManager::add_craft_data);
ClassDB::bind_method(D_METHOD("get_craft_data", "craft_data_id"), &DataManager::get_craft_data); ClassDB::bind_method(D_METHOD("get_craft_data", "craft_data_id"), &EntityDataManager::get_craft_data);
ClassDB::bind_method(D_METHOD("get_craft_data_index", "index"), &DataManager::get_craft_data_index); ClassDB::bind_method(D_METHOD("get_craft_data_index", "index"), &EntityDataManager::get_craft_data_index);
ClassDB::bind_method(D_METHOD("get_craft_data_count"), &DataManager::get_craft_data_count); ClassDB::bind_method(D_METHOD("get_craft_data_count"), &EntityDataManager::get_craft_data_count);
//Item Templates //Item Templates
ClassDB::bind_method(D_METHOD("get_item_template_folder"), &DataManager::get_item_template_folder); ClassDB::bind_method(D_METHOD("get_item_template_folder"), &EntityDataManager::get_item_template_folder);
ClassDB::bind_method(D_METHOD("set_item_template_folder", "folder"), &DataManager::set_item_template_folder); ClassDB::bind_method(D_METHOD("set_item_template_folder", "folder"), &EntityDataManager::set_item_template_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "item_template_folder"), "set_item_template_folder", "get_item_template_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "item_template_folder"), "set_item_template_folder", "get_item_template_folder");
ClassDB::bind_method(D_METHOD("add_item_template", "item_template"), &DataManager::add_item_template); ClassDB::bind_method(D_METHOD("add_item_template", "item_template"), &EntityDataManager::add_item_template);
ClassDB::bind_method(D_METHOD("get_item_template", "item_template_id"), &DataManager::get_item_template); ClassDB::bind_method(D_METHOD("get_item_template", "item_template_id"), &EntityDataManager::get_item_template);
ClassDB::bind_method(D_METHOD("get_item_template_index", "index"), &DataManager::get_item_template_index); ClassDB::bind_method(D_METHOD("get_item_template_index", "index"), &EntityDataManager::get_item_template_index);
ClassDB::bind_method(D_METHOD("get_item_template_count"), &DataManager::get_item_template_count); ClassDB::bind_method(D_METHOD("get_item_template_count"), &EntityDataManager::get_item_template_count);
//Mob Data //Mob Data
ClassDB::bind_method(D_METHOD("get_mob_data_folder"), &DataManager::get_mob_data_folder); ClassDB::bind_method(D_METHOD("get_mob_data_folder"), &EntityDataManager::get_mob_data_folder);
ClassDB::bind_method(D_METHOD("set_mob_data_folder", "folder"), &DataManager::set_mob_data_folder); ClassDB::bind_method(D_METHOD("set_mob_data_folder", "folder"), &EntityDataManager::set_mob_data_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "mob_data_folder"), "set_mob_data_folder", "get_mob_data_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "mob_data_folder"), "set_mob_data_folder", "get_mob_data_folder");
ClassDB::bind_method(D_METHOD("add_mob_data", "mob_data"), &DataManager::add_mob_data); ClassDB::bind_method(D_METHOD("add_mob_data", "mob_data"), &EntityDataManager::add_mob_data);
ClassDB::bind_method(D_METHOD("get_mob_data", "mob_data_id"), &DataManager::get_mob_data); ClassDB::bind_method(D_METHOD("get_mob_data", "mob_data_id"), &EntityDataManager::get_mob_data);
ClassDB::bind_method(D_METHOD("get_mob_data_index", "index"), &DataManager::get_mob_data_index); ClassDB::bind_method(D_METHOD("get_mob_data_index", "index"), &EntityDataManager::get_mob_data_index);
ClassDB::bind_method(D_METHOD("get_mob_data_count"), &DataManager::get_mob_data_count); ClassDB::bind_method(D_METHOD("get_mob_data_count"), &EntityDataManager::get_mob_data_count);
//Player Character Data //Player Character Data
ClassDB::bind_method(D_METHOD("get_player_character_data_folder"), &DataManager::get_player_character_data_folder); ClassDB::bind_method(D_METHOD("get_player_character_data_folder"), &EntityDataManager::get_player_character_data_folder);
ClassDB::bind_method(D_METHOD("set_player_character_data_folder", "folder"), &DataManager::set_player_character_data_folder); ClassDB::bind_method(D_METHOD("set_player_character_data_folder", "folder"), &EntityDataManager::set_player_character_data_folder);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "player_character_data_folder"), "set_player_character_data_folder", "get_player_character_data_folder"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "player_character_data_folder"), "set_player_character_data_folder", "get_player_character_data_folder");
ClassDB::bind_method(D_METHOD("add_player_character_data", "pcd"), &DataManager::add_player_character_data); ClassDB::bind_method(D_METHOD("add_player_character_data", "pcd"), &EntityDataManager::add_player_character_data);
ClassDB::bind_method(D_METHOD("get_player_character_data", "pcd_id"), &DataManager::get_player_character_data); ClassDB::bind_method(D_METHOD("get_player_character_data", "pcd_id"), &EntityDataManager::get_player_character_data);
ClassDB::bind_method(D_METHOD("get_player_character_data_index", "index"), &DataManager::get_player_character_data_index); ClassDB::bind_method(D_METHOD("get_player_character_data_index", "index"), &EntityDataManager::get_player_character_data_index);
ClassDB::bind_method(D_METHOD("get_player_character_data_count"), &DataManager::get_player_character_data_count); ClassDB::bind_method(D_METHOD("get_player_character_data_count"), &EntityDataManager::get_player_character_data_count);
//load //load
ClassDB::bind_method(D_METHOD("load_all"), &DataManager::load_all); ClassDB::bind_method(D_METHOD("load_all"), &EntityDataManager::load_all);
ClassDB::bind_method(D_METHOD("load_xp_data"), &DataManager::load_xp_data); ClassDB::bind_method(D_METHOD("load_xp_data"), &EntityDataManager::load_xp_data);
ClassDB::bind_method(D_METHOD("load_spells"), &DataManager::load_spells); ClassDB::bind_method(D_METHOD("load_spells"), &EntityDataManager::load_spells);
ClassDB::bind_method(D_METHOD("load_auras"), &DataManager::load_auras); ClassDB::bind_method(D_METHOD("load_auras"), &EntityDataManager::load_auras);
ClassDB::bind_method(D_METHOD("load_characters"), &DataManager::load_characters); ClassDB::bind_method(D_METHOD("load_characters"), &EntityDataManager::load_characters);
ClassDB::bind_method(D_METHOD("load_craft_datas"), &DataManager::load_craft_datas); ClassDB::bind_method(D_METHOD("load_craft_datas"), &EntityDataManager::load_craft_datas);
ClassDB::bind_method(D_METHOD("load_item_templates"), &DataManager::load_item_templates); ClassDB::bind_method(D_METHOD("load_item_templates"), &EntityDataManager::load_item_templates);
ClassDB::bind_method(D_METHOD("load_mob_datas"), &DataManager::load_mob_datas); ClassDB::bind_method(D_METHOD("load_mob_datas"), &EntityDataManager::load_mob_datas);
ClassDB::bind_method(D_METHOD("load_player_character_datas"), &DataManager::load_player_character_datas); ClassDB::bind_method(D_METHOD("load_player_character_datas"), &EntityDataManager::load_player_character_datas);
//tests //tests
ClassDB::bind_method(D_METHOD("list_characters"), &DataManager::list_characters); ClassDB::bind_method(D_METHOD("list_characters"), &EntityDataManager::list_characters);
ClassDB::bind_method(D_METHOD("list_spells"), &DataManager::list_spells); ClassDB::bind_method(D_METHOD("list_spells"), &EntityDataManager::list_spells);
ClassDB::bind_method(D_METHOD("list_auras"), &DataManager::list_auras); ClassDB::bind_method(D_METHOD("list_auras"), &EntityDataManager::list_auras);
ClassDB::bind_method(D_METHOD("list_craft_data"), &DataManager::list_craft_data); ClassDB::bind_method(D_METHOD("list_craft_data"), &EntityDataManager::list_craft_data);
ClassDB::bind_method(D_METHOD("list_item_templates"), &DataManager::list_item_templates); ClassDB::bind_method(D_METHOD("list_item_templates"), &EntityDataManager::list_item_templates);
ClassDB::bind_method(D_METHOD("list_mob_datas"), &DataManager::list_mob_datas); ClassDB::bind_method(D_METHOD("list_mob_datas"), &EntityDataManager::list_mob_datas);
ClassDB::bind_method(D_METHOD("list_player_character_datas"), &DataManager::list_player_character_datas); ClassDB::bind_method(D_METHOD("list_player_character_datas"), &EntityDataManager::list_player_character_datas);
} }
DataManager::DataManager() { EntityDataManager::EntityDataManager() {
instance = this; instance = this;
_automatic_load = true; _automatic_load = true;
} }
DataManager::~DataManager() { EntityDataManager::~EntityDataManager() {
instance = NULL; instance = NULL;
_entity_datas.clear(); _entity_datas.clear();

21
data/data_manager.h → entity_data_manager.h
View File

@ -1,5 +1,5 @@
#ifndef DATA_MANAGER_H #ifndef ENTITY_DATA_MANAGER_H
#define DATA_MANAGER_H #define ENTITY_DATA_MANAGER_H
#include "core/array.h" #include "core/array.h"
#include "core/hash_map.h" #include "core/hash_map.h"
@ -12,9 +12,10 @@
#include "scene/main/node.h" #include "scene/main/node.h"
#include "core/bind/core_bind.h" #include "core/bind/core_bind.h"
#include "../item_enums.h"
#include "xp_data.h" #include "item_enums.h"
#include "./data/xp_data.h"
class Aura; class Aura;
class Spell; class Spell;
@ -22,11 +23,11 @@ class EntityData;
class CraftRecipe; class CraftRecipe;
class ItemTemplate; class ItemTemplate;
class DataManager : public Node { class EntityDataManager : public Node {
GDCLASS(DataManager, Node); GDCLASS(EntityDataManager, Node);
public: public:
static DataManager *get_instance(); static EntityDataManager *get_instance();
Ref<Aura> get_skill_for_armor_type(int index); Ref<Aura> get_skill_for_armor_type(int index);
void set_skill_for_armor_type(int index, Ref<Aura> aura); void set_skill_for_armor_type(int index, Ref<Aura> aura);
@ -112,8 +113,8 @@ public:
bool get_automatic_load() { return _automatic_load; } bool get_automatic_load() { return _automatic_load; }
void set_automatic_load(bool load) { _automatic_load = load; } void set_automatic_load(bool load) { _automatic_load = load; }
DataManager(); EntityDataManager();
~DataManager(); ~EntityDataManager();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -153,7 +154,7 @@ private:
Ref<Aura> _armor_type_skills[ItemEnums::ARMOR_TYPE_MAX]; Ref<Aura> _armor_type_skills[ItemEnums::ARMOR_TYPE_MAX];
static DataManager *instance; static EntityDataManager *instance;
bool _automatic_load; bool _automatic_load;
}; };

4
register_types.cpp
View File

@ -5,7 +5,7 @@
#include "data/aura.h" #include "data/aura.h"
#include "data/aura_stat_attribute.h" #include "data/aura_stat_attribute.h"
#include "data/data_manager.h" #include "entity_data_manager.h"
#include "data/xp_data.h" #include "data/xp_data.h"
#include "data/item_stat_modifier.h" #include "data/item_stat_modifier.h"
#include "data/item_template_stat_modifier.h" #include "data/item_template_stat_modifier.h"
@ -158,7 +158,7 @@ void register_entity_spell_system_types() {
ClassDB::register_class<CharacterSkeletonVisualEntry>(); ClassDB::register_class<CharacterSkeletonVisualEntry>();
ClassDB::register_class<DataManager>(); ClassDB::register_class<EntityDataManager>();
ClassDB::register_class<ItemVisual>(); ClassDB::register_class<ItemVisual>();
ClassDB::register_class<ItemVisualEntry>(); ClassDB::register_class<ItemVisualEntry>();