From d87668f7792ad4636fd00a54fbf288a74124122e Mon Sep 17 00:00:00 2001 From: Relintai Date: Thu, 12 Sep 2019 23:28:18 +0200 Subject: [PATCH] Now caster aura apply, and target aura apply in Spell are done using Arrays. Also added a new array "Apply Auras On Learn". --- data/item_template.cpp | 2 +- data/spell.cpp | 278 +++++++++++++++++++++-------------------- data/spell.h | 55 ++++---- 3 files changed, 180 insertions(+), 155 deletions(-) diff --git a/data/item_template.cpp b/data/item_template.cpp index 9534a01..d893fc9 100644 --- a/data/item_template.cpp +++ b/data/item_template.cpp @@ -473,7 +473,7 @@ void ItemTemplate::_bind_methods() { ClassDB::bind_method(D_METHOD("set_aura", "index", "aura"), &ItemTemplate::set_aura); ClassDB::bind_method(D_METHOD("get_auras"), &ItemTemplate::get_auras); - ClassDB::bind_method(D_METHOD("set_auras", "spells"), &ItemTemplate::set_auras); + ClassDB::bind_method(D_METHOD("set_auras", "auras"), &ItemTemplate::set_auras); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "auras", PROPERTY_HINT_NONE, "17/17:Aura", PROPERTY_USAGE_DEFAULT, "Aura"), "set_auras", "get_auras"); //StatMods Property binds diff --git a/data/spell.cpp b/data/spell.cpp index dbba2bb..66df590 100644 --- a/data/spell.cpp +++ b/data/spell.cpp @@ -51,58 +51,6 @@ void Spell::set_target_relation_type(TargetRelationType value) { _target_relation_type = value; } -Ref Spell::get_caster_aura_apply() { - return Ref(_caster_aura_apply); -} - -void Spell::set_caster_aura_apply(Ref value) { - _caster_aura_apply = (*value); - - if (_caster_aura_apply_ref) - memdelete(_caster_aura_apply_ref); - - _caster_aura_apply_ref = memnew(Ref(value)); -} - -Ref Spell::get_caster_aura_apply2() { - return Ref(_caster_aura_apply2); -} - -void Spell::set_caster_aura_apply2(Ref value) { - _caster_aura_apply2 = (*value); - - if (_caster_aura_apply2_ref) - memdelete(_caster_aura_apply2_ref); - - _caster_aura_apply2_ref = memnew(Ref(value)); -} - -Ref Spell::get_target_aura_apply() { - return Ref(_target_aura_apply); -} - -void Spell::set_target_aura_apply(Ref value) { - _target_aura_apply = (*value); - - if (_target_aura_apply_ref) - memdelete(_target_aura_apply_ref); - - _target_aura_apply_ref = memnew(Ref(value)); -} - -Ref Spell::get_target_aura_apply2() { - return Ref(_target_aura_apply2); -} - -void Spell::set_target_aura_apply2(Ref value) { - _target_aura_apply2 = (*value); - - if (_target_aura_apply2_ref) - memdelete(_target_aura_apply2_ref); - - _target_aura_apply2_ref = memnew(Ref(value)); -} - int Spell::get_level() { return _level; } @@ -251,6 +199,116 @@ float Spell::get_absorb_scale_for_level(int level) { return 1; } +//// Caster Aura Apply //// + +int Spell::get_num_caster_aura_applys() { + return _caster_aura_applys.size(); +} +void Spell::set_num_caster_aura_applys(int value) { + _caster_aura_applys.resize(value); +} + +Ref Spell::get_caster_aura_apply(int index) const { + ERR_FAIL_INDEX_V(index, _caster_aura_applys.size(), Ref()); + + return _caster_aura_applys[index]; +} +void Spell::set_caster_aura_apply(int index, Ref caster_aura_apply) { + ERR_FAIL_INDEX(index, _caster_aura_applys.size()); + + _caster_aura_applys.set(index, Ref(caster_aura_apply)); +} + +Vector Spell::get_caster_aura_applys() { + Vector r; + for (int i = 0; i < _caster_aura_applys.size(); i++) { + r.push_back(_caster_aura_applys[i].get_ref_ptr()); + } + return r; +} +void Spell::set_caster_aura_applys(const Vector &caster_aura_applys) { + _caster_aura_applys.clear(); + for (int i = 0; i < caster_aura_applys.size(); i++) { + Ref aura = Ref(caster_aura_applys[i]); + + _caster_aura_applys.push_back(aura); + } +} + +//// Target Aura Apply //// + +int Spell::get_num_target_aura_applys() { + return _target_aura_applys.size(); +} +void Spell::set_num_target_aura_applys(int value) { + _target_aura_applys.resize(value); +} + +Ref Spell::get_target_aura_apply(int index) const { + ERR_FAIL_INDEX_V(index, _target_aura_applys.size(), Ref()); + + return _target_aura_applys[index]; +} +void Spell::set_target_aura_apply(int index, Ref target_aura_apply) { + ERR_FAIL_INDEX(index, _target_aura_applys.size()); + + _target_aura_applys.set(index, Ref(target_aura_apply)); +} + +Vector Spell::get_target_aura_applys() { + Vector r; + for (int i = 0; i < _target_aura_applys.size(); i++) { + r.push_back(_target_aura_applys[i].get_ref_ptr()); + } + return r; +} +void Spell::set_target_aura_applys(const Vector &target_aura_applys) { + _target_aura_applys.clear(); + for (int i = 0; i < target_aura_applys.size(); i++) { + Ref aura = Ref(target_aura_applys[i]); + + _target_aura_applys.push_back(aura); + } +} + +//// Apply Auras On Learn //// + +int Spell::get_num_on_learn_auras() { + return _on_learn_auras.size(); +} +void Spell::set_num_on_learn_auras(int value) { + _on_learn_auras.resize(value); +} + +Ref Spell::get_on_learn_aura(int index) const { + ERR_FAIL_INDEX_V(index, _on_learn_auras.size(), Ref()); + + return _on_learn_auras[index]; +} +void Spell::set_on_learn_aura(int index, Ref on_learn_aura_apply) { + ERR_FAIL_INDEX(index, _on_learn_auras.size()); + + _on_learn_auras.set(index, Ref(on_learn_aura_apply)); +} + +Vector Spell::get_on_learn_auras() { + Vector r; + for (int i = 0; i < _on_learn_auras.size(); i++) { + r.push_back(_on_learn_auras[i].get_ref_ptr()); + } + return r; +} +void Spell::set_on_learn_auras(const Vector &on_learn_aura_applys) { + _on_learn_auras.clear(); + for (int i = 0; i < on_learn_aura_applys.size(); i++) { + Ref aura = Ref(on_learn_aura_applys[i]); + + _on_learn_auras.push_back(aura); + } +} + +//// Range //// + bool Spell::get_has_range() { return _has_range; } @@ -647,49 +705,7 @@ void Spell::_sstart_casting(Ref info) { handle_spell_damage(dpd); } - if (spell->get_caster_aura_apply() != NULL) { - Ref aainfo(memnew(AuraApplyInfo(info->get_caster(), info->get_caster(), info->get_spell_scale()))); - - spell->get_caster_aura_apply()->sapply(aainfo); - } - - if (spell->get_caster_aura_apply2() != NULL) { - Ref aainfo(memnew(AuraApplyInfo(info->get_caster(), info->get_caster(), info->get_spell_scale()))); - - spell->get_caster_aura_apply2()->sapply(aainfo); - } - - if (spell->get_target_aura_apply() != NULL) { - Ref aainfo(memnew(AuraApplyInfo(info->get_caster(), info->get_caster()->getc_target(), info->get_spell_scale()))); - - spell->get_target_aura_apply()->sapply(aainfo); - } - - if (spell->get_target_aura_apply2() != NULL) { - Ref aainfo(memnew(AuraApplyInfo(info->get_caster(), info->get_caster()->getc_target(), info->get_spell_scale()))); - - spell->get_target_aura_apply2()->sapply(aainfo); - } } - /* - WorldEntity *worldEntity = null; - if (spell->GenericSpellData->NeedsTarget || damage) { - worldEntity = Spell::GetTarget(caster); - } - - if (!hasCastTime) { - if (spell->SpellRangeData->Enabled && !Spell::isInRange(caster, worldEntity)) { - return; - } - HandleSpellEffect(caster, worldEntity, spellScale); - return; - } else { - if (!Spell::SpellCostCheck(caster)) { - return; - } - Spell::DoStartCasting(caster, spellId, spell->SpellName, spell->CastTime, !spell->GenericSpellData->CanMoveWhileCasting, spellScale); - return; - }*/ } void Spell::_calculate_initial_damage(Ref data) { @@ -774,36 +790,13 @@ Spell::Spell() { _projectile_destroy_on_impact = false; _projectile_collision = false; - _caster_aura_apply = NULL; - _caster_aura_apply2 = NULL; - _target_aura_apply = NULL; - _target_aura_apply2 = NULL; - - _caster_aura_apply_ref = NULL; - _caster_aura_apply2_ref = NULL; - _target_aura_apply_ref = NULL; - _target_aura_apply2_ref = NULL; - _spell_cooldown_mainpulation_data_count = 0; } Spell::~Spell() { - if (_caster_aura_apply_ref != NULL) - memdelete(_caster_aura_apply_ref); - - if (_caster_aura_apply2_ref != NULL) - memdelete(_caster_aura_apply2_ref); - - if (_target_aura_apply_ref != NULL) - memdelete(_target_aura_apply_ref); - - if (_target_aura_apply2_ref != NULL) - memdelete(_target_aura_apply2_ref); - - _caster_aura_apply = NULL; - _caster_aura_apply2 = NULL; - _target_aura_apply = NULL; - _target_aura_apply2 = NULL; + _caster_aura_applys.clear(); + _target_aura_applys.clear(); + _on_learn_auras.clear(); } void Spell::_bind_methods() { @@ -939,22 +932,41 @@ void Spell::_bind_methods() { ClassDB::bind_method(D_METHOD("set_has_global_cooldown", "value"), &Spell::set_has_global_cooldown); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cooldown_global_cooldown"), "set_has_global_cooldown", "has_global_cooldown"); - ADD_GROUP("Auras", "aura"); - ClassDB::bind_method(D_METHOD("get_caster_aura_apply"), &Spell::get_caster_aura_apply); - ClassDB::bind_method(D_METHOD("set_caster_aura_apply", "value"), &Spell::set_caster_aura_apply); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "aura_caster_apply", PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_caster_aura_apply", "get_caster_aura_apply"); + ADD_GROUP("Caster Aura Applys", "caster_aura_applys"); + ClassDB::bind_method(D_METHOD("get_num_caster_aura_applys"), &Spell::get_num_caster_aura_applys); + ClassDB::bind_method(D_METHOD("set_num_caster_aura_applys", "value"), &Spell::set_num_caster_aura_applys); - ClassDB::bind_method(D_METHOD("get_caster_aura_apply2"), &Spell::get_caster_aura_apply2); - ClassDB::bind_method(D_METHOD("set_caster_aura_apply2", "value"), &Spell::set_caster_aura_apply2); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "aura_caster_aura_apply2", PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_caster_aura_apply2", "get_caster_aura_apply2"); + ClassDB::bind_method(D_METHOD("get_caster_aura_apply", "index"), &Spell::get_caster_aura_apply); + ClassDB::bind_method(D_METHOD("set_caster_aura_apply", "index", "aura"), &Spell::set_caster_aura_apply); - ClassDB::bind_method(D_METHOD("get_target_aura_apply"), &Spell::get_target_aura_apply); - ClassDB::bind_method(D_METHOD("set_target_aura_apply", "value"), &Spell::set_target_aura_apply); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "aura_target_apply", PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_target_aura_apply", "get_target_aura_apply"); + ClassDB::bind_method(D_METHOD("get_caster_aura_applys"), &Spell::get_caster_aura_applys); + ClassDB::bind_method(D_METHOD("set_caster_aura_applys", "caster_aura_applys"), &Spell::set_caster_aura_applys); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "caster_aura_applys", PROPERTY_HINT_NONE, "17/17:Aura", PROPERTY_USAGE_DEFAULT, "Aura"), "set_caster_aura_applys", "get_caster_aura_applys"); + + + ADD_GROUP("Target Aura Apply", "target_aura_applys"); + ClassDB::bind_method(D_METHOD("get_num_target_aura_applys"), &Spell::get_num_target_aura_applys); + ClassDB::bind_method(D_METHOD("set_num_target_aura_applys", "value"), &Spell::set_num_target_aura_applys); + + ClassDB::bind_method(D_METHOD("get_target_aura_apply", "index"), &Spell::get_target_aura_apply); + ClassDB::bind_method(D_METHOD("set_target_aura_apply", "index", "aura"), &Spell::set_target_aura_apply); + + ClassDB::bind_method(D_METHOD("get_target_aura_applys"), &Spell::get_target_aura_applys); + ClassDB::bind_method(D_METHOD("set_target_aura_applys", "target_aura_applys"), &Spell::set_target_aura_applys); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "target_aura_applys", PROPERTY_HINT_NONE, "17/17:Aura", PROPERTY_USAGE_DEFAULT, "Aura"), "set_target_aura_applys", "get_target_aura_applys"); + + + ADD_GROUP("Apply Auras On Learn", "on_learn_auras"); + ClassDB::bind_method(D_METHOD("get_num_on_learn_auras"), &Spell::get_num_on_learn_auras); + ClassDB::bind_method(D_METHOD("set_num_on_learn_auras", "value"), &Spell::set_num_on_learn_auras); + + ClassDB::bind_method(D_METHOD("get_on_learn_aura", "index"), &Spell::get_on_learn_aura); + ClassDB::bind_method(D_METHOD("set_on_learn_aura", "index", "aura"), &Spell::set_on_learn_aura); + + ClassDB::bind_method(D_METHOD("get_on_learn_auras"), &Spell::get_on_learn_auras); + ClassDB::bind_method(D_METHOD("set_on_learn_auras", "spells"), &Spell::set_on_learn_auras); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "on_learn_auras", PROPERTY_HINT_NONE, "17/17:Aura", PROPERTY_USAGE_DEFAULT, "Aura"), "set_on_learn_auras", "get_on_learn_auras"); - ClassDB::bind_method(D_METHOD("get_target_aura_apply2"), &Spell::get_target_aura_apply2); - ClassDB::bind_method(D_METHOD("set_target_aura_apply2", "value"), &Spell::set_target_aura_apply2); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "aura_target_apply2", PROPERTY_HINT_RESOURCE_TYPE, "Aura"), "set_target_aura_apply2", "get_target_aura_apply2"); ADD_GROUP("Range", "range"); ClassDB::bind_method(D_METHOD("get_has_range"), &Spell::get_has_range); diff --git a/data/spell.h b/data/spell.h index c442185..e757c98 100644 --- a/data/spell.h +++ b/data/spell.h @@ -103,18 +103,6 @@ public: TargetRelationType get_target_relation_type(); void set_target_relation_type(TargetRelationType value); - Ref get_caster_aura_apply(); - void set_caster_aura_apply(Ref value); - - Ref get_caster_aura_apply2(); - void set_caster_aura_apply2(Ref value); - - Ref get_target_aura_apply(); - void set_target_aura_apply(Ref value); - - Ref get_target_aura_apply2(); - void set_target_aura_apply2(Ref value); - int get_level(); void set_level(int value); @@ -176,6 +164,37 @@ public: float get_heal_scale_for_level(int level); float get_absorb_scale_for_level(int level); + //Caster Aura Apply + int get_num_caster_aura_applys(); + void set_num_caster_aura_applys(int value); + + Ref get_caster_aura_apply(int index) const; + void set_caster_aura_apply(int index, Ref caster_aura_apply); + + Vector get_caster_aura_applys(); + void set_caster_aura_applys(const Vector &caster_aura_applys); + + //Target Aura Apply + int get_num_target_aura_applys(); + void set_num_target_aura_applys(int value); + + Ref get_target_aura_apply(int index) const; + void set_target_aura_apply(int index, Ref target_aura_apply); + + Vector get_target_aura_applys(); + void set_target_aura_applys(const Vector &target_aura_applys); + + //Apply Auras On Learn + int get_num_on_learn_auras(); + void set_num_on_learn_auras(int value); + + Ref get_on_learn_aura(int index) const; + void set_on_learn_aura(int index, Ref on_learn_aura); + + Vector get_on_learn_auras(); + void set_on_learn_auras(const Vector &on_learn_auras); + + //Range bool get_has_range(); void set_has_range(bool value); @@ -322,15 +341,9 @@ private: SpellTargetType _target_type; TargetRelationType _target_relation_type; - Ref *_caster_aura_apply_ref; - Ref *_caster_aura_apply2_ref; - Ref *_target_aura_apply_ref; - Ref *_target_aura_apply2_ref; - - Aura *_caster_aura_apply; - Aura *_caster_aura_apply2; - Aura *_target_aura_apply; - Aura *_target_aura_apply2; + Vector > _caster_aura_applys; + Vector > _target_aura_applys; + Vector > _on_learn_auras; int _level; int _rank;