From 5afc9d4e0868be25a66486075b5a919e0c725403 Mon Sep 17 00:00:00 2001 From: Relintai Date: Sun, 6 Oct 2019 16:47:03 +0200 Subject: [PATCH] Cleaned up the talent related functions in entity. --- entities/data/character_spec.cpp | 6 +- entities/data/character_spec.h | 2 +- entities/data/entity_class_data.cpp | 1 + entities/data/talent_row_data.cpp | 57 ++++++-- entities/data/talent_row_data.h | 14 +- entities/entity.cpp | 214 ++++++++++++++++++++++++++-- entities/entity.h | 41 ++++-- 7 files changed, 294 insertions(+), 41 deletions(-) diff --git a/entities/data/character_spec.cpp b/entities/data/character_spec.cpp index ae6470f..7d921a9 100644 --- a/entities/data/character_spec.cpp +++ b/entities/data/character_spec.cpp @@ -50,11 +50,11 @@ void CharacterSpec::set_talent_rows(const Vector &talent_rows) { } } -Ref CharacterSpec::get_talent(const int row_index, const int index) const { +Ref CharacterSpec::get_talent(const int row_index, const int culomn, const int rank) const { ERR_FAIL_INDEX_V(row_index, _rows.size(), Ref(NULL)); if (_rows[row_index].is_valid()) { - return _rows[row_index]->get_talent(index); + return _rows[row_index]->get_talent(culomn, rank); } return Ref(NULL); @@ -84,6 +84,8 @@ void CharacterSpec::_bind_methods() { ClassDB::bind_method(D_METHOD("get_talent_row", "index"), &CharacterSpec::get_talent_row); ClassDB::bind_method(D_METHOD("set_talent_row", "index", "row"), &CharacterSpec::set_talent_row); + ClassDB::bind_method(D_METHOD("get_talent", "row_index", "culomn", "rank"), &CharacterSpec::get_talent); + ClassDB::bind_method(D_METHOD("get_talent_rows"), &CharacterSpec::get_talent_rows); ClassDB::bind_method(D_METHOD("set_talent_rows", "auras"), &CharacterSpec::set_talent_rows); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "talent_rows", PROPERTY_HINT_NONE, "17/17:TalentRowData", PROPERTY_USAGE_DEFAULT, "TalentRowData"), "set_talent_rows", "get_talent_rows"); diff --git a/entities/data/character_spec.h b/entities/data/character_spec.h index 8df155b..2ec967d 100644 --- a/entities/data/character_spec.h +++ b/entities/data/character_spec.h @@ -28,7 +28,7 @@ public: Vector get_talent_rows(); void set_talent_rows(const Vector &auras); - Ref get_talent(const int row_index, const int index) const; + Ref get_talent(const int row_index, const int culomn, const int rank) const; CharacterSpec(); ~CharacterSpec(); diff --git a/entities/data/entity_class_data.cpp b/entities/data/entity_class_data.cpp index e24d452..dc844ff 100644 --- a/entities/data/entity_class_data.cpp +++ b/entities/data/entity_class_data.cpp @@ -115,6 +115,7 @@ void EntityClassData::set_specs(const Vector &specs) { } } + //// SPELLS //// int EntityClassData::get_num_spells() { diff --git a/entities/data/talent_row_data.cpp b/entities/data/talent_row_data.cpp index 7b617f4..9cff061 100644 --- a/entities/data/talent_row_data.cpp +++ b/entities/data/talent_row_data.cpp @@ -1,32 +1,73 @@ #include "talent_row_data.h" -Ref TalentRowData::get_talent(int index) const { - ERR_FAIL_INDEX_V(index, MAX_TALENTS_IN_ROW, Ref(NULL)); +Ref TalentRowData::get_talent_index(int index) const { + ERR_FAIL_INDEX_V(index, TOTAL_ENTRIES, Ref()); return _talents[index]; } -void TalentRowData::set_talent(int index, Ref talent) { - ERR_FAIL_INDEX(index, MAX_TALENTS_IN_ROW); +void TalentRowData::set_talent_index(int index, Ref talent) { + ERR_FAIL_INDEX(index, TOTAL_ENTRIES); _talents[index] = Ref(talent); } +Ref TalentRowData::get_talent(int culomn, int rank) const { + ERR_FAIL_INDEX_V(culomn, MAX_TALENTS_IN_ROW, Ref()); + ERR_FAIL_INDEX_V(rank, MAX_TALENTS_PER_ENTRY, Ref()); + + return _talents[culomn * MAX_TALENTS_IN_ROW + rank]; +} +void TalentRowData::set_talent(int culomn, int rank, Ref talent) { + ERR_FAIL_INDEX(culomn, MAX_TALENTS_IN_ROW); + ERR_FAIL_INDEX(rank, MAX_TALENTS_PER_ENTRY); + + _talents[culomn * MAX_TALENTS_IN_ROW + rank] = talent; +} + +bool TalentRowData::has_talent_with_id(int id) { + for (int i = 0; i < TOTAL_ENTRIES; ++i) { + if (_talents[i].is_valid() && _talents[i]->get_id() == id) + return true; + } + + return false; +} + +Ref TalentRowData::get_talent_with_id(int id) { + for (int i = 0; i < TOTAL_ENTRIES; ++i) { + if (_talents[i].is_valid() && _talents[i]->get_id() == id) + return _talents[i]; + } + + return Ref(); +} + TalentRowData::TalentRowData() { } TalentRowData::~TalentRowData() { - for (int i = 0; i < MAX_TALENTS_IN_ROW; ++i) { + for (int i = 0; i < TOTAL_ENTRIES; ++i) { _talents[i].unref(); } } void TalentRowData::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_talent", "index"), &TalentRowData::get_talent); - ClassDB::bind_method(D_METHOD("set_talent", "index", "value"), &TalentRowData::set_talent); + ClassDB::bind_method(D_METHOD("get_talent_index", "index"), &TalentRowData::get_talent_index); + ClassDB::bind_method(D_METHOD("set_talent_index", "index", "value"), &TalentRowData::set_talent_index); + + ClassDB::bind_method(D_METHOD("get_talent", "culomn", "rank"), &TalentRowData::get_talent); + ClassDB::bind_method(D_METHOD("set_talent", "culomn", "rank", "talent"), &TalentRowData::set_talent); + + ClassDB::bind_method(D_METHOD("has_talent_with_id", "id"), &TalentRowData::has_talent_with_id); + ClassDB::bind_method(D_METHOD("get_talent_with_id", "id"), &TalentRowData::get_talent_with_id); for (int i = 0; i < MAX_TALENTS_IN_ROW; ++i) { - ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Talent_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "Talent", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_talent", "get_talent", i); + for (int j = 0; j < MAX_TALENTS_PER_ENTRY; ++j) { + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Talent_" + itos(i) + "_" + itos(j), PROPERTY_HINT_RESOURCE_TYPE, "Talent", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_talent_index", "get_talent_index", i * MAX_TALENTS_IN_ROW + j); + } } BIND_CONSTANT(MAX_TALENTS_IN_ROW); + BIND_CONSTANT(MAX_TALENTS_PER_ENTRY); + BIND_CONSTANT(TOTAL_ENTRIES); } diff --git a/entities/data/talent_row_data.h b/entities/data/talent_row_data.h index 201767f..a3f8be5 100644 --- a/entities/data/talent_row_data.h +++ b/entities/data/talent_row_data.h @@ -12,8 +12,14 @@ class TalentRowData : public Resource { GDCLASS(TalentRowData, Resource); public: - Ref get_talent(int index) const; - void set_talent(int index, Ref talent); + Ref get_talent_index(int index) const; + void set_talent_index(int index, Ref talent); + + Ref get_talent(int culomn, int rank) const; + void set_talent(int culomn, int rank, Ref talent); + + bool has_talent_with_id(int id); + Ref get_talent_with_id(int id); TalentRowData(); ~TalentRowData(); @@ -21,13 +27,15 @@ public: public: enum { MAX_TALENTS_IN_ROW = 5, + MAX_TALENTS_PER_ENTRY = 5, + TOTAL_ENTRIES = MAX_TALENTS_IN_ROW * MAX_TALENTS_PER_ENTRY, }; protected: static void _bind_methods(); private: - Ref _talents[MAX_TALENTS_IN_ROW]; + Ref _talents[TOTAL_ENTRIES]; }; #endif diff --git a/entities/entity.cpp b/entities/entity.cpp index 283918c..67c987c 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -7,6 +7,8 @@ #include "../inventory/bag.h" #include "../pipelines/spell_damage_info.h" #include "../pipelines/spell_heal_info.h" +#include "./data/character_spec.h" +#include "./data/talent_row_data.h" NodePath Entity::get_character_skeleton_path() { return _character_skeleton_path; @@ -3342,26 +3344,177 @@ void Entity::setc_target(Node *p_target) { emit_signal("ctarget_changed", this, original_target); } -//// TalentComponent //// +//// Talents //// -void Entity::crequest_rank_increase(int talent_x, int talent_y) { - sreceive_talent_rank_increase_request(talent_x, talent_y); +void Entity::crequest_talent_learn(int spec_index, int talent_row, int talent_culomn) { + sreceive_talent_learn_request(spec_index, talent_row, talent_culomn); } -void Entity::sreceive_talent_rank_increase_request(int talent_x, int talent_y) { - if (has_method("_sreceive_talent_rank_increase_request")) { - call("_sreceive_talent_rank_increase_request", talent_x, talent_y); +void Entity::sreceive_talent_learn_request(int spec_index, int talent_row, int talent_culomn) { + call("_sreceive_talent_learn_request", spec_index, talent_row, talent_culomn); +} + +void Entity::_sreceive_talent_learn_request(int spec_index, int talent_row, int talent_culomn) { + if (gets_talent_count() <= 0) + return; + + ERR_FAIL_COND(!_s_entity_data.is_valid()); + + Ref class_data = _s_entity_data->get_entity_class_data(); + + ERR_FAIL_COND(!class_data.is_valid()); + + Ref spec = class_data->get_spec(spec_index); + + ERR_FAIL_COND(!spec.is_valid()); + + Ref tr = spec->get_talent_row(talent_row); + + ERR_FAIL_COND(!tr.is_valid()); + + for (int i = 0; i < TalentRowData::MAX_TALENTS_PER_ENTRY; ++i) { + Ref talent = tr->get_talent(talent_culomn, i); + + if (!talent.is_valid()) + return; + + int talent_id = talent->get_id(); + + if (hass_talent(talent_id)) + continue; + + //check requirement + + Ref info; + info.instance(); + + info->set_caster(this); + info->set_target(this); + info->set_spell_scale(1); + info->set_aura(talent); + + talent->sapply(info); + + adds_talent(talent_id); + + return; } } void Entity::crequest_talent_reset() { sreceive_reset_talent_request(); } - void Entity::sreceive_reset_talent_request() { - if (has_method("_sreceive_reset_talent_request")) { - call("_sreceive_reset_talent_request"); + call("_sreceive_reset_talent_request"); +} +void Entity::_sreceive_reset_talent_request() { + sreset_talents(); +} + +void Entity::sreset_talents() { + + _s_talents.clear(); + + if (has_method("_son_talent_reset")) + call("_son_talent_reset", this); + + emit_signal("stalent_reset", this); + + SEND_RPC(rpc("creset_talents"), creset_talents()); +} +void Entity::creset_talents() { + _c_talents.clear(); + + if (has_method("_con_talent_reset")) + call("_con_talent_reset", this); + + emit_signal("ctalent_reset", this); +} + +void Entity::adds_talent(int talent) { + if (hass_talent(talent)) + return; + + _s_talents.push_back(talent); + + if (has_method("_son_talent_learned")) + call("_son_talent_learned", talent); + + emit_signal("stalent_learned", this, talent); + + SEND_RPC(rpc("addc_talent", talent), addc_talent(talent)); +} +void Entity::removes_talent(int talent) { + for (int i = 0; i < _s_talents.size(); ++i) { + if (_s_talents[i] == talent) { + _s_talents.remove(i); + break; + } } + + SEND_RPC(rpc("removec_talent", talent), removec_talent(talent)); +} +bool Entity::hass_talent(int talent) { + for (int i = 0; i < _s_talents.size(); ++i) { + if (_s_talents[i] == talent) { + return true; + } + } + + return false; +} +int Entity::gets_talent(int index) { + ERR_FAIL_INDEX_V(index, _s_talents.size(), 0); + + return _s_talents.get(index); +} +int Entity::gets_talent_count() { + return _s_talents.size(); +} +void Entity::sclear_talents() { + _s_talents.clear(); + + SEND_RPC(rpc("cclear_talents"), cclear_talents()); +} + +void Entity::addc_talent(int talent) { + if (hasc_talent(talent)) + return; + + if (has_method("_con_talent_learned")) + call("_con_talent_learned", talent); + + emit_signal("ctalent_learned", this, talent); + + _c_talents.push_back(talent); +} +void Entity::removec_talent(int talent) { + for (int i = 0; i < _c_talents.size(); ++i) { + if (_c_talents[i] == talent) { + _c_talents.remove(i); + return; + } + } +} +bool Entity::hasc_talent(int talent) { + for (int i = 0; i < _c_talents.size(); ++i) { + if (_c_talents[i] == talent) { + return true; + } + } + + return false; +} +int Entity::getc_talent(int index) { + ERR_FAIL_INDEX_V(index, _c_talents.size(), 0); + + return _c_talents.get(index); +} +int Entity::getc_talent_count() { + return _c_talents.size(); +} +void Entity::cclear_talents() { + _c_talents.clear(); } //// Bag //// @@ -3763,9 +3916,6 @@ void Entity::_bind_methods() { BIND_VMETHOD(MethodInfo("_son_target_changed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "old_target", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); BIND_VMETHOD(MethodInfo("_con_target_changed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "old_target", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - BIND_VMETHOD(MethodInfo("_sreceive_talent_rank_increase_request", PropertyInfo(Variant::INT, "talent_x"), PropertyInfo(Variant::INT, "talent_y"))); - BIND_VMETHOD(MethodInfo("_sreceive_reset_talent_request")); - ClassDB::bind_method(D_METHOD("son_before_aura_applied", "data"), &Entity::son_before_aura_applied); ClassDB::bind_method(D_METHOD("son_after_aura_applied", "data"), &Entity::son_after_aura_applied); @@ -3798,11 +3948,47 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("son_xp_gained", "value"), &Entity::son_xp_gained); ClassDB::bind_method(D_METHOD("son_level_up", "value"), &Entity::son_level_up); - ClassDB::bind_method(D_METHOD("crequest_rank_increase", "talent_x", "talent_y"), &Entity::crequest_rank_increase); - ClassDB::bind_method(D_METHOD("sreceive_talent_rank_increase_request", "talent_x", "talent_y"), &Entity::sreceive_talent_rank_increase_request); + //Talents + + BIND_VMETHOD(MethodInfo("_sreceive_talent_learn_request", PropertyInfo(Variant::INT, "spec_index"), PropertyInfo(Variant::INT, "talent_row"), PropertyInfo(Variant::INT, "talent_culomn"))); + BIND_VMETHOD(MethodInfo("_sreceive_reset_talent_request")); + + ADD_SIGNAL(MethodInfo("stalent_learned", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::INT, "talent_id"))); + ADD_SIGNAL(MethodInfo("ctalent_learned", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::INT, "talent_id"))); + + ADD_SIGNAL(MethodInfo("stalent_reset", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + ADD_SIGNAL(MethodInfo("ctalent_reset", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + + BIND_VMETHOD(MethodInfo("_son_talent_learned", PropertyInfo(Variant::INT, "talent_id"))); + BIND_VMETHOD(MethodInfo("_con_talent_learned", PropertyInfo(Variant::INT, "talent_id"))); + + BIND_VMETHOD(MethodInfo("_son_talent_reset")); + BIND_VMETHOD(MethodInfo("_con_talent_reset")); + + ClassDB::bind_method(D_METHOD("crequest_talent_learn", "spec_index", "talent_row", "talent_culomn"), &Entity::crequest_talent_learn); + ClassDB::bind_method(D_METHOD("sreceive_talent_learn_request", "spec_index", "talent_row", "talent_culomn"), &Entity::sreceive_talent_learn_request); + ClassDB::bind_method(D_METHOD("_sreceive_talent_learn_request", "spec_index", "talent_row", "talent_culomn"), &Entity::_sreceive_talent_learn_request); ClassDB::bind_method(D_METHOD("crequest_talent_reset"), &Entity::crequest_talent_reset); ClassDB::bind_method(D_METHOD("sreceive_reset_talent_request"), &Entity::sreceive_reset_talent_request); + ClassDB::bind_method(D_METHOD("_sreceive_reset_talent_request"), &Entity::_sreceive_reset_talent_request); + + ClassDB::bind_method(D_METHOD("sreset_talents"), &Entity::sreset_talents); + ClassDB::bind_method(D_METHOD("creset_talents"), &Entity::creset_talents); + + ClassDB::bind_method(D_METHOD("adds_talent", "talent"), &Entity::adds_talent); + ClassDB::bind_method(D_METHOD("removes_talent", "talent"), &Entity::removes_talent); + ClassDB::bind_method(D_METHOD("hass_talent", "talent"), &Entity::hass_talent); + ClassDB::bind_method(D_METHOD("gets_talent", "index"), &Entity::gets_talent); + ClassDB::bind_method(D_METHOD("gets_talent_count"), &Entity::gets_talent_count); + ClassDB::bind_method(D_METHOD("sclear_talents"), &Entity::sclear_talents); + + ClassDB::bind_method(D_METHOD("addc_talent", "talent"), &Entity::addc_talent); + ClassDB::bind_method(D_METHOD("removec_talent", "talent"), &Entity::removec_talent); + ClassDB::bind_method(D_METHOD("hasc_talent", "talent"), &Entity::hasc_talent); + ClassDB::bind_method(D_METHOD("getc_talent", "index"), &Entity::getc_talent); + ClassDB::bind_method(D_METHOD("getc_talent_count"), &Entity::getc_talent_count); + ClassDB::bind_method(D_METHOD("cclear_talents"), &Entity::cclear_talents); //Clientside EventHandlers BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); diff --git a/entities/entity.h b/entities/entity.h index 6e34e14..a339db2 100644 --- a/entities/entity.h +++ b/entities/entity.h @@ -20,25 +20,18 @@ #include "core/vector.h" #include "entity_resource.h" - #include "../data/spell.h" #include "stats/stat.h" #include "../data/data_manager.h" - #include "../entity_enums.h" - #include "../skeleton/character_skeleton.h" - #include "../utility/entity_create_info.h" #include "../utility/category_cooldown.h" #include "../utility/cooldown.h" - #include "../inventory/bag.h" - #include "./data/entity_data_container.h" - #include "./skills/entity_skill.h" class EntityData; @@ -48,6 +41,8 @@ class SpellDamageInfo; class SpellHealInfo; class SpellCastInfo; class EntityCreateInfo; +class TalentRowData; +class CharacterSpec; enum SpellCastDataSignals { CastFailed, @@ -538,11 +533,30 @@ public: //// Talents //// - void crequest_rank_increase(int talent_x, int talent_y); - void sreceive_talent_rank_increase_request(int talent_x, int talent_y); + void crequest_talent_learn(int spec_index, int talent_row, int talent_culomn); + void sreceive_talent_learn_request(int spec_index, int talent_row, int talent_culomn); + void _sreceive_talent_learn_request(int spec_index, int talent_row, int talent_culomn); void crequest_talent_reset(); void sreceive_reset_talent_request(); + void _sreceive_reset_talent_request(); + + void sreset_talents(); + void creset_talents(); + + void adds_talent(int talent); + void removes_talent(int talent); + bool hass_talent(int talent); + int gets_talent(int index); + int gets_talent_count(); + void sclear_talents(); + + void addc_talent(int talent); + void removec_talent(int talent); + bool hasc_talent(int talent); + int getc_talent(int index); + int getc_talent_count(); + void cclear_talents(); //// Inventory //// @@ -562,6 +576,7 @@ public: void sloot(int index); //// Data //// + void adds_data(Ref data); void removes_data(int index); Ref gets_data(int index); @@ -718,16 +733,16 @@ private: int _s_active_category_cooldowns; int _c_active_category_cooldowns; - //// targetComponent //// + //// Targeting //// int _s_target_guid; Entity *_s_target; Entity *_c_target; - //// TalentComponent //// + //// Talents //// - //Vector > _s_talents; - //Vector > _c_talents; + Vector _s_talents; + Vector _c_talents; //// Data //// Vector > _s_data;