Relintai/entity_spell_system
1
0
Fork 0
mirror of https://github.com/Relintai/entity_spell_system.git synced 2025-04-19 21:33:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Renamed CraftDataAttribute into CraftRecipe. Also added a few more crafting categories.

Browse Source
This commit is contained in:
Relintai 2019-10-07 15:25:36 +02:00
parent 53cd756d06
commit 3fc6579aee
12 changed files with 275 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
SCsub
View File

@ -45,8 +45,8 @@ module_env.add_source_files(env.modules_sources,"atlases/character_atlas_entry.c
module_env.add_source_files(env.modules_sources,"skeleton/character_bones.cpp")
module_env.add_source_files(env.modules_sources,"data/craft_data_attribute_helper.cpp")
module_env.add_source_files(env.modules_sources,"data/craft_data_attribute.cpp")
module_env.add_source_files(env.modules_sources,"data/craft_recipe_helper.cpp")
module_env.add_source_files(env.modules_sources,"data/craft_recipe.cpp")
module_env.add_source_files(env.modules_sources,"data/spell.cpp")
module_env.add_source_files(env.modules_sources,"data/spell/spell_data_constants.cpp")

159
data/craft_data_attribute.cpp
View File

@ -1,159 +0,0 @@
#include "craft_data_attribute.h"
const String CraftDataAttribute::BINDING_STRING_CRAFT_CATEGORIES = "None, Alchemy";
const String CraftDataAttribute::BINDING_STRING_CRAFT_SUB_CATEGORIES = "None, Potions";
int CraftDataAttribute::get_id() {
return _id;
}
void CraftDataAttribute::set_id(int value) {
_id = value;
}
CraftDataAttribute::CraftCategories CraftDataAttribute::get_category() {
return _category;
}
void CraftDataAttribute::set_category(CraftCategories value) {
_category = value;
}
CraftDataAttribute::CraftSubCategories CraftDataAttribute::get_sub_category() {
return _sub_category;
}
void CraftDataAttribute::set_sub_category(CraftSubCategories value) {
_sub_category = value;
}
Ref<CraftDataAttributeHelper> CraftDataAttribute::get_required_tool(int index) {
return _required_tools[index];
}
void CraftDataAttribute::set_required_tool(int index, const Ref<CraftDataAttributeHelper> value) {
_required_tools[index] = value;
}
int CraftDataAttribute::get_required_tools_count() {
return _required_tools_count;
}
void CraftDataAttribute::set_required_tools_count(int value) {
_required_tools_count = value;
}
void CraftDataAttribute::set_required_material(int index, const Ref<CraftDataAttributeHelper> value) {
_required_materials[index] = value;
}
Ref<CraftDataAttributeHelper> CraftDataAttribute::get_required_material(int index) {
return _required_materials[index];
}
int CraftDataAttribute::get_required_materials_count() {
return _required_materials_count;
}
void CraftDataAttribute::set_required_materials_count(int value) {
_required_materials_count = value;
}
Ref<CraftDataAttributeHelper> CraftDataAttribute::get_item() {
return _item;
}
void CraftDataAttribute::set_item(Ref<CraftDataAttributeHelper> value) {
_item = value;
}
CraftDataAttribute::CraftDataAttribute() {
_id = 0;
_category = CraftCategories::CRAFT_CATEGORY_NONE;
_sub_category = CraftSubCategories::CRAFT_SUB_CATEGORY_NONE;
//_item = Ref<CraftDataAttributeHelper>(memnew(CraftDataAttributeHelper()));
_required_materials_count = 0;
_required_tools_count = 0;
//for (int i = 0; i < MAX_REQUIRED_TOOLS; ++i) {
// _required_tools[i] = Ref<CraftDataAttributeHelper>(memnew(CraftDataAttributeHelper()));
//}
//for (int i = 0; i < MAX_REQUIRED_MATERIALS; ++i) {
// _required_materials[i] = Ref<CraftDataAttributeHelper>(memnew(CraftDataAttributeHelper()));
//}
}
CraftDataAttribute::~CraftDataAttribute() {
//TODO check if the array destrutors actually unref the objects.
//_item = Ref<CraftDataAttributeHelper>(NULL);
}
void CraftDataAttribute::_validate_property(PropertyInfo &property) const {
String prop = property.name;
if (prop.begins_with("RequiredMaterials_")) {
int frame = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
if (frame >= _required_materials_count) {
property.usage = 0;
}
} else if (prop.begins_with("RequiredTools_")) {
int frame = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
if (frame >= _required_tools_count) {
property.usage = 0;
}
}
}
void CraftDataAttribute::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_id"), &CraftDataAttribute::get_id);
ClassDB::bind_method(D_METHOD("set_id", "value"), &CraftDataAttribute::set_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
ClassDB::bind_method(D_METHOD("get_category"), &CraftDataAttribute::get_category);
ClassDB::bind_method(D_METHOD("set_category", "value"), &CraftDataAttribute::set_category);
ADD_PROPERTY(PropertyInfo(Variant::INT, "category", PROPERTY_HINT_ENUM, CraftDataAttribute::BINDING_STRING_CRAFT_CATEGORIES), "set_category", "get_category");
ClassDB::bind_method(D_METHOD("get_sub_category"), &CraftDataAttribute::get_sub_category);
ClassDB::bind_method(D_METHOD("set_sub_category", "value"), &CraftDataAttribute::set_sub_category);
ADD_PROPERTY(PropertyInfo(Variant::INT, "sub_category", PROPERTY_HINT_ENUM, CraftDataAttribute::BINDING_STRING_CRAFT_SUB_CATEGORIES), "set_sub_category", "get_sub_category");
ClassDB::bind_method(D_METHOD("get_required_material"), &CraftDataAttribute::get_required_material);
ClassDB::bind_method(D_METHOD("set_required_material", "mat"), &CraftDataAttribute::set_required_material);
ClassDB::bind_method(D_METHOD("get_required_materials_count"), &CraftDataAttribute::get_required_materials_count);
ClassDB::bind_method(D_METHOD("set_required_materials_count", "count"), &CraftDataAttribute::set_required_materials_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "required_materials_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_REQUIRED_MATERIALS), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_required_materials_count", "get_required_materials_count");
for (int i = 0; i < MAX_REQUIRED_MATERIALS; i++) {
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "RequiredMaterials_" + itos(i) + "", PROPERTY_HINT_RESOURCE_TYPE, "CraftDataAttributeHelper", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_required_material", "get_required_material", i);
}
ClassDB::bind_method(D_METHOD("get_required_tool"), &CraftDataAttribute::get_required_tool);
ClassDB::bind_method(D_METHOD("set_required_tool", "value"), &CraftDataAttribute::set_required_tool);
ClassDB::bind_method(D_METHOD("get_required_tools_count"), &CraftDataAttribute::get_required_tools_count);
ClassDB::bind_method(D_METHOD("set_required_tools_count", "value"), &CraftDataAttribute::set_required_tools_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "required_tools_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_REQUIRED_TOOLS), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_required_tools_count", "get_required_tools_count");
for (int i = 0; i < MAX_REQUIRED_TOOLS; i++) {
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "RequiredTools_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "CraftDataAttributeHelper", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_required_tool", "get_required_tool", i);
}
ClassDB::bind_method(D_METHOD("get_item"), &CraftDataAttribute::get_item);
ClassDB::bind_method(D_METHOD("set_item", "value"), &CraftDataAttribute::set_item);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "CraftDataAttributeHelper"), "set_item", "get_item");
BIND_CONSTANT(MAX_REQUIRED_TOOLS);
BIND_CONSTANT(MAX_REQUIRED_MATERIALS);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_NONE);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_ALCHEMY);
BIND_ENUM_CONSTANT(CRAFT_SUB_CATEGORY_NONE);
BIND_ENUM_CONSTANT(CRAFT_SUB_CATEGORY_POTIONS);
}

57
data/craft_data_attribute_helper.cpp
View File

@ -1,57 +0,0 @@
#include "craft_data_attribute_helper.h"
#if ENTITY_MEM_TOOLS
int CraftDataAttributeHelper::allocs = 0;
#endif
Ref<ItemTemplate> CraftDataAttributeHelper::get_item() {
return _item;
}
void CraftDataAttributeHelper::set_item(Ref<ItemTemplate> value) {
_item = value;
}
int CraftDataAttributeHelper::get_count() {
return _count;
}
void CraftDataAttributeHelper::set_count(int value) {
_count = value;
}
CraftDataAttributeHelper::CraftDataAttributeHelper(Ref<ItemTemplate> item, int count) {
set_item(item);
set_count(count);
#if ENTITY_MEM_TOOLS
CraftDataAttributeHelper::allocs++;
print_error("CraftDataAttributeHelper alloc " + String::num(CraftDataAttributeHelper::allocs));
#endif
}
CraftDataAttributeHelper::CraftDataAttributeHelper() {
set_count(0);
#if ENTITY_MEM_TOOLS
CraftDataAttributeHelper::allocs++;
print_error("CraftDataAttributeHelper alloc " + String::num(CraftDataAttributeHelper::allocs));
#endif
}
CraftDataAttributeHelper::~CraftDataAttributeHelper() {
#if ENTITY_MEM_TOOLS
CraftDataAttributeHelper::allocs--;
print_error("CraftDataAttributeHelper dealloc " + String::num(CraftDataAttributeHelper::allocs));
#endif
}
void CraftDataAttributeHelper::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_item"), &CraftDataAttributeHelper::get_item);
ClassDB::bind_method(D_METHOD("set_item", "value"), &CraftDataAttributeHelper::set_item);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemTemplate"), "set_item", "get_item");
ClassDB::bind_method(D_METHOD("get_count"), &CraftDataAttributeHelper::get_count);
ClassDB::bind_method(D_METHOD("set_count", "value"), &CraftDataAttributeHelper::set_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "count"), "set_count", "get_count");
}

28
data/craft_data_attribute_helper.h
View File

@ -1,28 +0,0 @@
#ifndef CRAFT_DATA_ATTRIBUTE_HELPER_H
#define CRAFT_DATA_ATTRIBUTE_HELPER_H
#include "core/resource.h"
#include "item_template.h"
class CraftDataAttributeHelper : public Resource {
GDCLASS(CraftDataAttributeHelper, Resource);
public:
Ref<ItemTemplate> get_item();
void set_item(Ref<ItemTemplate> value);
int get_count();
void set_count(int value);
CraftDataAttributeHelper(Ref<ItemTemplate> item, int count);
CraftDataAttributeHelper();
~CraftDataAttributeHelper();
protected:
static void _bind_methods();
private:
Ref<ItemTemplate> _item;
int _count;
};
#endif

163
data/craft_recipe.cpp Normal file
View File

@ -0,0 +1,163 @@
#include "craft_recipe.h"
const String CraftRecipe::BINDING_STRING_CRAFT_CATEGORIES = "None,Alchemy,Smithing,Tailoring,Enchanting,Engineering";
const String CraftRecipe::BINDING_STRING_CRAFT_SUB_CATEGORIES = "None,Potions";
int CraftRecipe::get_id() {
return _id;
}
void CraftRecipe::set_id(int value) {
_id = value;
}
CraftRecipe::CraftCategories CraftRecipe::get_category() {
return _category;
}
void CraftRecipe::set_category(CraftCategories value) {
_category = value;
}
CraftRecipe::CraftSubCategories CraftRecipe::get_sub_category() {
return _sub_category;
}
void CraftRecipe::set_sub_category(CraftSubCategories value) {
_sub_category = value;
}
Ref<CraftRecipeHelper> CraftRecipe::get_required_tool(int index) {
return _required_tools[index];
}
void CraftRecipe::set_required_tool(int index, const Ref<CraftRecipeHelper> value) {
_required_tools[index] = value;
}
int CraftRecipe::get_required_tools_count() {
return _required_tools_count;
}
void CraftRecipe::set_required_tools_count(int value) {
_required_tools_count = value;
}
void CraftRecipe::set_required_material(int index, const Ref<CraftRecipeHelper> value) {
_required_materials[index] = value;
}
Ref<CraftRecipeHelper> CraftRecipe::get_required_material(int index) {
return _required_materials[index];
}
int CraftRecipe::get_required_materials_count() {
return _required_materials_count;
}
void CraftRecipe::set_required_materials_count(int value) {
_required_materials_count = value;
}
Ref<CraftRecipeHelper> CraftRecipe::get_item() {
return _item;
}
void CraftRecipe::set_item(Ref<CraftRecipeHelper> value) {
_item = value;
}
CraftRecipe::CraftRecipe() {
_id = 0;
_category = CraftCategories::CRAFT_CATEGORY_NONE;
_sub_category = CraftSubCategories::CRAFT_SUB_CATEGORY_NONE;
//_item = Ref<CraftRecipeHelper>(memnew(CraftRecipeHelper()));
_required_materials_count = 0;
_required_tools_count = 0;
//for (int i = 0; i < MAX_REQUIRED_TOOLS; ++i) {
// _required_tools[i] = Ref<CraftRecipeHelper>(memnew(CraftRecipeHelper()));
//}
//for (int i = 0; i < MAX_REQUIRED_MATERIALS; ++i) {
// _required_materials[i] = Ref<CraftRecipeHelper>(memnew(CraftRecipeHelper()));
//}
}
CraftRecipe::~CraftRecipe() {
//TODO check if the array destrutors actually unref the objects.
//_item = Ref<CraftRecipeHelper>(NULL);
}
void CraftRecipe::_validate_property(PropertyInfo &property) const {
String prop = property.name;
if (prop.begins_with("RequiredMaterials_")) {
int frame = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
if (frame >= _required_materials_count) {
property.usage = 0;
}
} else if (prop.begins_with("RequiredTools_")) {
int frame = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
if (frame >= _required_tools_count) {
property.usage = 0;
}
}
}
void CraftRecipe::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_id"), &CraftRecipe::get_id);
ClassDB::bind_method(D_METHOD("set_id", "value"), &CraftRecipe::set_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
ClassDB::bind_method(D_METHOD("get_category"), &CraftRecipe::get_category);
ClassDB::bind_method(D_METHOD("set_category", "value"), &CraftRecipe::set_category);
ADD_PROPERTY(PropertyInfo(Variant::INT, "category", PROPERTY_HINT_ENUM, CraftRecipe::BINDING_STRING_CRAFT_CATEGORIES), "set_category", "get_category");
ClassDB::bind_method(D_METHOD("get_sub_category"), &CraftRecipe::get_sub_category);
ClassDB::bind_method(D_METHOD("set_sub_category", "value"), &CraftRecipe::set_sub_category);
ADD_PROPERTY(PropertyInfo(Variant::INT, "sub_category", PROPERTY_HINT_ENUM, CraftRecipe::BINDING_STRING_CRAFT_SUB_CATEGORIES), "set_sub_category", "get_sub_category");
ClassDB::bind_method(D_METHOD("get_required_material"), &CraftRecipe::get_required_material);
ClassDB::bind_method(D_METHOD("set_required_material", "mat"), &CraftRecipe::set_required_material);
ClassDB::bind_method(D_METHOD("get_required_materials_count"), &CraftRecipe::get_required_materials_count);
ClassDB::bind_method(D_METHOD("set_required_materials_count", "count"), &CraftRecipe::set_required_materials_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "required_materials_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_REQUIRED_MATERIALS), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_required_materials_count", "get_required_materials_count");
for (int i = 0; i < MAX_REQUIRED_MATERIALS; i++) {
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "RequiredMaterials_" + itos(i) + "", PROPERTY_HINT_RESOURCE_TYPE, "CraftRecipeHelper", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_required_material", "get_required_material", i);
}
ClassDB::bind_method(D_METHOD("get_required_tool"), &CraftRecipe::get_required_tool);
ClassDB::bind_method(D_METHOD("set_required_tool", "value"), &CraftRecipe::set_required_tool);
ClassDB::bind_method(D_METHOD("get_required_tools_count"), &CraftRecipe::get_required_tools_count);
ClassDB::bind_method(D_METHOD("set_required_tools_count", "value"), &CraftRecipe::set_required_tools_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "required_tools_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_REQUIRED_TOOLS), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_required_tools_count", "get_required_tools_count");
for (int i = 0; i < MAX_REQUIRED_TOOLS; i++) {
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "RequiredTools_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "CraftRecipeHelper", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_required_tool", "get_required_tool", i);
}
ClassDB::bind_method(D_METHOD("get_item"), &CraftRecipe::get_item);
ClassDB::bind_method(D_METHOD("set_item", "value"), &CraftRecipe::set_item);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "CraftRecipeHelper"), "set_item", "get_item");
BIND_CONSTANT(MAX_REQUIRED_TOOLS);
BIND_CONSTANT(MAX_REQUIRED_MATERIALS);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_NONE);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_ALCHEMY);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_SMITHING);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_TAILORING);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_ENCHANTING);
BIND_ENUM_CONSTANT(CRAFT_CATEGORY_ENGINEERING);
BIND_ENUM_CONSTANT(CRAFT_SUB_CATEGORY_NONE);
BIND_ENUM_CONSTANT(CRAFT_SUB_CATEGORY_POTIONS);
}

40
data/craft_data_attribute.h → data/craft_recipe.h
View File

@ -1,5 +1,5 @@
#ifndef CRAFT_DATA_ATTRIBUTE_H
#define CRAFT_DATA_ATTRIBUTE_H
#ifndef CRAFT_RECIPE_H
#define CRAFT_RECIPE_H
#include "core/vector.h"
#include "core/resource.h"
@ -7,10 +7,10 @@
#include "item_template.h"
#include "craft_data_attribute_helper.h"
#include "craft_recipe_helper.h"
class CraftDataAttribute : public Resource {
GDCLASS(CraftDataAttribute, Resource);
class CraftRecipe : public Resource {
GDCLASS(CraftRecipe, Resource);
public:
static const String BINDING_STRING_CRAFT_CATEGORIES;
@ -19,6 +19,10 @@ public:
enum CraftCategories {
CRAFT_CATEGORY_NONE,
CRAFT_CATEGORY_ALCHEMY,
CRAFT_CATEGORY_SMITHING,
CRAFT_CATEGORY_TAILORING,
CRAFT_CATEGORY_ENCHANTING,
CRAFT_CATEGORY_ENGINEERING,
};
enum CraftSubCategories {
@ -37,25 +41,25 @@ public:
void set_sub_category(CraftSubCategories value);
//Tools
Ref<CraftDataAttributeHelper> get_required_tool(int index);
void set_required_tool(int index, const Ref<CraftDataAttributeHelper> value);
Ref<CraftRecipeHelper> get_required_tool(int index);
void set_required_tool(int index, const Ref<CraftRecipeHelper> value);
int get_required_tools_count();
void set_required_tools_count(int value);
//Materials
Ref<CraftDataAttributeHelper> get_required_material(int index);
void set_required_material(int index, const Ref<CraftDataAttributeHelper> value);
Ref<CraftRecipeHelper> get_required_material(int index);
void set_required_material(int index, const Ref<CraftRecipeHelper> value);
int get_required_materials_count();
void set_required_materials_count(int value);
//Item
Ref<CraftDataAttributeHelper> get_item();
void set_item(Ref<CraftDataAttributeHelper> value);
Ref<CraftRecipeHelper> get_item();
void set_item(Ref<CraftRecipeHelper> value);
CraftDataAttribute();
~CraftDataAttribute();
CraftRecipe();
~CraftRecipe();
protected:
static void _bind_methods();
@ -73,15 +77,15 @@ private:
CraftSubCategories _sub_category;
int _required_tools_count;
Ref<CraftDataAttributeHelper> _required_tools[MAX_REQUIRED_TOOLS];
Ref<CraftRecipeHelper> _required_tools[MAX_REQUIRED_TOOLS];
int _required_materials_count;
Ref<CraftDataAttributeHelper> _required_materials[MAX_REQUIRED_MATERIALS];
Ref<CraftRecipeHelper> _required_materials[MAX_REQUIRED_MATERIALS];
Ref<CraftDataAttributeHelper> _item;
Ref<CraftRecipeHelper> _item;
};
VARIANT_ENUM_CAST(CraftDataAttribute::CraftSubCategories);
VARIANT_ENUM_CAST(CraftDataAttribute::CraftCategories);
VARIANT_ENUM_CAST(CraftRecipe::CraftSubCategories);
VARIANT_ENUM_CAST(CraftRecipe::CraftCategories);
#endif

39
data/craft_recipe_helper.cpp Normal file
View File

@ -0,0 +1,39 @@
#include "craft_recipe_helper.h"
Ref<ItemTemplate> CraftRecipeHelper::get_item() {
return _item;
}
void CraftRecipeHelper::set_item(Ref<ItemTemplate> value) {
_item = value;
}
int CraftRecipeHelper::get_count() {
return _count;
}
void CraftRecipeHelper::set_count(int value) {
_count = value;
}
CraftRecipeHelper::CraftRecipeHelper(Ref<ItemTemplate> item, int count) {
set_item(item);
set_count(count);
}
CraftRecipeHelper::CraftRecipeHelper() {
set_count(0);
}
CraftRecipeHelper::~CraftRecipeHelper() {
}
void CraftRecipeHelper::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_item"), &CraftRecipeHelper::get_item);
ClassDB::bind_method(D_METHOD("set_item", "value"), &CraftRecipeHelper::set_item);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemTemplate"), "set_item", "get_item");
ClassDB::bind_method(D_METHOD("get_count"), &CraftRecipeHelper::get_count);
ClassDB::bind_method(D_METHOD("set_count", "value"), &CraftRecipeHelper::set_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "count"), "set_count", "get_count");
}

28
data/craft_recipe_helper.h Normal file
View File

@ -0,0 +1,28 @@
#ifndef CRAFT_RECIPE_HELPER_H
#define CRAFT_RECIPE_HELPER_H
#include "core/resource.h"
#include "item_template.h"
class CraftRecipeHelper : public Resource {
GDCLASS(CraftRecipeHelper, Resource);
public:
Ref<ItemTemplate> get_item();
void set_item(Ref<ItemTemplate> value);
int get_count();
void set_count(int value);
CraftRecipeHelper(Ref<ItemTemplate> item, int count);
CraftRecipeHelper();
~CraftRecipeHelper();
protected:
static void _bind_methods();
private:
Ref<ItemTemplate> _item;
int _count;
};
#endif

18
data/data_manager.cpp
View File

@ -2,7 +2,7 @@
#include "../entities/data/entity_data.h"
#include "aura.h"
#include "craft_data_attribute.h"
#include "craft_recipe.h"
#include "spell.h"
DataManager *DataManager::instance;
@ -139,7 +139,7 @@ int DataManager::get_aura_count() {
}
//Craft Data
void DataManager::add_craft_data(Ref<CraftDataAttribute> cda) {
void DataManager::add_craft_data(Ref<CraftRecipe> cda) {
ERR_FAIL_COND(!cda.is_valid());
_craft_datas.push_back(cda);
@ -152,18 +152,18 @@ String DataManager::get_craft_data_folder() {
void DataManager::set_craft_data_folder(String folder) {
_craft_data_folder = folder;
}
Vector<Ref<CraftDataAttribute> > *DataManager::get_craft_datas() {
Vector<Ref<CraftRecipe> > *DataManager::get_craft_datas() {
return &_craft_datas;
}
Ref<CraftDataAttribute> DataManager::get_craft_data(int craft_id) {
ERR_FAIL_COND_V(!_craft_data_map.has(craft_id), Ref<CraftDataAttribute>(NULL));
Ref<CraftRecipe> DataManager::get_craft_data(int craft_id) {
ERR_FAIL_COND_V(!_craft_data_map.has(craft_id), Ref<CraftRecipe>(NULL));
return _craft_data_map.get(craft_id);
}
Ref<CraftDataAttribute> DataManager::get_craft_data_index(int index) {
ERR_FAIL_INDEX_V(index, _craft_datas.size(), Ref<CraftDataAttribute>(NULL));
Ref<CraftRecipe> DataManager::get_craft_data_index(int index) {
ERR_FAIL_INDEX_V(index, _craft_datas.size(), Ref<CraftRecipe>(NULL));
return _craft_datas.get(index);
}
@ -438,7 +438,7 @@ void DataManager::load_craft_datas() {
_ResourceLoader *rl = _ResourceLoader::get_singleton();
Ref<ResourceInteractiveLoader> resl = rl->load_interactive(path, "CraftDataAttribute");
Ref<ResourceInteractiveLoader> resl = rl->load_interactive(path, "CraftRecipe");
resl->wait();
@ -446,7 +446,7 @@ void DataManager::load_craft_datas() {
ERR_CONTINUE(!s.is_valid());
Ref<CraftDataAttribute> cda = s;
Ref<CraftRecipe> cda = s;
ERR_CONTINUE(!cda.is_valid());

14
data/data_manager.h
View File

@ -18,7 +18,7 @@
class Aura;
class Spell;
class EntityData;
class CraftDataAttribute;
class CraftRecipe;
class ItemTemplate;
class DataManager : public Node {
@ -57,11 +57,11 @@ public:
String get_craft_data_folder();
void set_craft_data_folder(String folder);
Vector<Ref<CraftDataAttribute> > *get_craft_datas();
Ref<CraftDataAttribute> get_craft_data(int craft_id);
Ref<CraftDataAttribute> get_craft_data_index(int index);
Vector<Ref<CraftRecipe> > *get_craft_datas();
Ref<CraftRecipe> get_craft_data(int craft_id);
Ref<CraftRecipe> get_craft_data_index(int index);
int get_craft_data_count();
void add_craft_data(Ref<CraftDataAttribute> aura);
void add_craft_data(Ref<CraftRecipe> aura);
String get_item_template_folder();
void set_item_template_folder(String folder);
@ -132,8 +132,8 @@ private:
HashMap<int, Ref<Aura> > _aura_map;
String _craft_data_folder;
Vector<Ref<CraftDataAttribute> > _craft_datas;
HashMap<int, Ref<CraftDataAttribute> > _craft_data_map;
Vector<Ref<CraftRecipe> > _craft_datas;
HashMap<int, Ref<CraftRecipe> > _craft_data_map;
String _item_template_folder;
Vector<Ref<ItemTemplate> > _item_templates;

2
entities/entity.h
View File

@ -9,7 +9,7 @@
#include "scene/3d/physics_body.h"
#endif
#include "../data/craft_data_attribute.h"
#include "../data/craft_recipe.h"
#include "../data/item_instance.h"
#include "../data/spell.h"
#include "../data/xp_data.h"

8
register_types.cpp
View File

@ -48,8 +48,8 @@
#include "inventory/bag.h"
//#include "inventory/inventory.h"
#include "data/craft_data_attribute_helper.h"
#include "data/craft_data_attribute.h"
#include "data/craft_recipe_helper.h"
#include "data/craft_recipe.h"
#include "infos/spell_cast_info.h"
#include "infos/aura_infos.h"
@ -112,8 +112,8 @@ void register_entity_spell_system_types() {
ClassDB::register_class<SpellEnums>();
//data
ClassDB::register_class<CraftDataAttributeHelper>();
ClassDB::register_class<CraftDataAttribute>();
ClassDB::register_class<CraftRecipeHelper>();
ClassDB::register_class<CraftRecipe>();
ClassDB::register_class<Spell>();
ClassDB::register_class<Aura>();