From d06a6615a00c6679cdf4f085e54c89a2314426a0 Mon Sep 17 00:00:00 2001 From: Relintai Date: Sat, 4 May 2019 03:05:36 +0200 Subject: [PATCH] Added fail cond checks, to the new spell system functions inside Aura, Spell, and Entity, to prevent crashes. --- data/aura.cpp | 58 +++++++++++++++++++++++++++++++++++ data/spell.cpp | 75 +++++++++++++++++++++++++++++++-------------- entities/entity.cpp | 56 +++++++++++++++++++++++++++++++++ 3 files changed, 166 insertions(+), 23 deletions(-) diff --git a/data/aura.cpp b/data/aura.cpp index 8c69fec..e361eae 100644 --- a/data/aura.cpp +++ b/data/aura.cpp @@ -237,147 +237,205 @@ void Aura::set_aura_stat_attribute_percent_mod(int index, float value) { } void Aura::sapply_simple(Entity *caster, Entity *target, float spell_scale) { + ERR_FAIL_COND(caster == NULL || target == NULL); + Ref info(memnew(AuraApplyInfo(caster, target, spell_scale, this))); sapply(info); } void Aura::sapply(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + //always exists call("_sapply", info); } void Aura::sremove(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + //always exists call("_sremove", aura); } void Aura::sremove_expired(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + //always exists call("_sremove_expired", aura); } void Aura::sremove_dispell(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + //always exists call("_sremove_dispell", aura); } void Aura::supdate(Ref aura, float delta) { + ERR_FAIL_COND(!aura.is_valid()); + //always exists call("_supdate", aura, delta); } void Aura::son_before_cast(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_before_cast")) call("_son_before_cast", info); } void Aura::son_before_cast_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_before_cast_target")) call("_son_before_cast_target", info); } void Aura::son_cast_finished(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_finished")) call("_son_cast_finished", info); } void Aura::son_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_started")) call("_son_cast_started", info); } void Aura::son_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_failed")) call("_son_cast_failed", info); } void Aura::son_cast_finished_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_finished_target")) call("_son_cast_finished_target", info); } void Aura::son_before_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_before_damage")) call("_son_before_damage", data); } void Aura::son_damage_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_damage_receive")) call("_son_damage_receive", data); } void Aura::son_hit(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_hit")) call("_son_hit", data); } void Aura::son_damage_dealt(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_damage_dealt")) call("_son_damage_dealt", data); } void Aura::son_remove_expired(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + if (has_method("_son_remove_expired")) call("_son_remove_expired", aura); } void Aura::son_remove(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + if (has_method("_son_remove")) call("_son_remove", aura); } void Aura::son_remove_dispell(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + if (has_method("_son_remove_dispell")) call("_son_remove_dispell", aura); } void Aura::son_before_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_before_aura_applied")) call("_son_before_aura_applied", data); } void Aura::son_after_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_son_after_aura_applied")) call("_son_after_aura_applied", data); } void Aura::con_added(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_con_added")) call("_con_added", data); } void Aura::con_removed(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_con_removed")) call("_con_removed", data); } void Aura::con_refresh(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + if (has_method("_con_refresh")) call("_con_refresh", data); } void Aura::sapply_passives_damage_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //always exists call("_sapply_passives_damage_receive", data); } void Aura::sapply_passives_damage_deal(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //always exists call("_sapply_passives_damage_deal", data); } void Aura::setup_aura_data(Ref data, Ref info) { + ERR_FAIL_COND(!data.is_valid() || !info.is_valid()); + //always exists call("setup_aura_data", data, info); } void Aura::calculate_initial_damage(Ref aura_data, Ref info) { + ERR_FAIL_COND(!aura_data.is_valid() || !info.is_valid()); + //always exists call("_calculate_initial_damage", aura_data, info); } void Aura::handle_aura_damage(Ref aura_data, Ref data) { + ERR_FAIL_COND(!aura_data.is_valid() || !data.is_valid()); + //always exists call("_handle_aura_damage", aura_data, data); } diff --git a/data/spell.cpp b/data/spell.cpp index dfd2c5a..bd5fdbd 100644 --- a/data/spell.cpp +++ b/data/spell.cpp @@ -72,120 +72,155 @@ float Spell::get_absorb_scale_for_level(int level) { //// Spell System //// void Spell::sstart_casting_simple(Entity *caster, float spell_scale) { - Ref info = Ref(memnew(SpellCastInfo())); + ERR_FAIL_COND(caster == NULL); - info->set_caster(caster); - info->set_target(caster->gets_target()); - info->set_has_cast_time(get_has_cast_time()); - info->set_cast_time(get_cast_time()); - info->set_spell_scale(spell_scale); - info->set_spell(Ref(this)); + Ref info = Ref(memnew(SpellCastInfo())); - sstart_casting(info); + info->set_caster(caster); + info->set_target(caster->gets_target()); + info->set_has_cast_time(get_has_cast_time()); + info->set_cast_time(get_cast_time()); + info->set_spell_scale(spell_scale); + info->set_spell(Ref(this)); + sstart_casting(info); } void Spell::sinterrupt_cast_simple(Entity *caster) { - Ref info(memnew(SpellCastInfo())); + ERR_FAIL_COND(caster == NULL); - info->set_caster(caster); - info->set_spell(Ref(this)); + Ref info(memnew(SpellCastInfo())); - sinterrupt_cast(info); + info->set_caster(caster); + info->set_spell(Ref(this)); + + sinterrupt_cast(info); } void Spell::sstart_casting_triggered_simple(Entity *caster) { - Ref info(memnew(SpellCastInfo())); + ERR_FAIL_COND(caster == NULL); - info->set_caster(caster); - info->set_spell(Ref(this)); + Ref info(memnew(SpellCastInfo())); - sstart_casting_triggered(info); + info->set_caster(caster); + info->set_spell(Ref(this)); + + sstart_casting_triggered(info); } //Script methods void Spell::sstart_casting(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_sstart_casting")) { call("_sstart_casting", info); } } void Spell::sstart_casting_triggered(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_sstart_casting_triggered")) { call("_sstart_casting_triggered", info); } } void Spell::sinterrupt_cast(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_sinterrupt_cast")) { call("_sinterrupt_cast", info); } } void Spell::sfinish_cast(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_sfinish_cast")) { call("_sfinish_cast", info); } } void Spell::son_cast_player_moved(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_player_moved")) { call("_son_cast_player_moved", info); } } void Spell::son_cast_damage_received(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_cast_damage_received")) { call("_son_cast_damage_received", info); } } void Spell::son_spell_hit(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_son_spell_hit")) { call("_son_spell_hit", info); } } void Spell::con_spell_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_con_spell_cast_started")) { call("_con_spell_cast_started", info); } } void Spell::con_spell_cast_success(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_con_spell_cast_success")) { call("_con_spell_cast_success", info); } } void Spell::con_spell_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_con_spell_cast_failed")) { call("_con_spell_cast_failed", info); } } void Spell::con_spell_cast_ended(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_con_spell_cast_ended")) { call("_con_spell_cast_ended", info); } } void Spell::con_spell_cast_interrupted(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + if (has_method("_con_spell_cast_interrupted")) { call("_con_spell_cast_interrupted", info); } } void Spell::calculate_initial_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid() || data->get_receiver() == NULL); + call("_calculate_initial_damage", data); } void Spell::handle_spell_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid() || data->get_receiver() == NULL); + call("_handle_spell_damage", data); } void Spell::_sstart_casting(Ref info) { + ERR_FAIL_COND(!info.is_valid() || info->get_spell() == NULL); + Ref spell = info->get_spell(); if (spell->get_needs_target() || spell->get_has_damage()) { @@ -391,7 +426,7 @@ void Spell::_bind_methods() { ClassDB::bind_method(D_METHOD("sstart_casting_triggered", "info"), &Spell::sstart_casting_triggered); ClassDB::bind_method(D_METHOD("sinterrupt_cast", "info"), &Spell::sinterrupt_cast); ClassDB::bind_method(D_METHOD("sfinish_cast", "info"), &Spell::sfinish_cast); - + BIND_VMETHOD(MethodInfo("_sstart_casting", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); BIND_VMETHOD(MethodInfo("_sstart_casting_triggered", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); BIND_VMETHOD(MethodInfo("_sinterrupt_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); @@ -430,7 +465,6 @@ void Spell::_bind_methods() { ClassDB::bind_method(D_METHOD("_calculate_initial_damage", "info"), &Spell::_calculate_initial_damage); ClassDB::bind_method(D_METHOD("_handle_spell_damage", "info"), &Spell::_handle_spell_damage); - //Properties ClassDB::bind_method(D_METHOD("get_spell_id"), &Spell::get_spell_id); @@ -708,10 +742,8 @@ void Spell::_bind_methods() { BIND_ENUM_CONSTANT(SPELL_PROJECTILE_TYPE_STATIONARY); } - //// SpellScript Old - /* void Spell::TriggerGlobalCooldown(Entity* player) { @@ -1249,8 +1281,6 @@ void Spell::AnimStop(Entity* player) bool arg_0A_0 = BSSettings::Getinstance()->AnimStopEnabled; }*/ - - //Generic /* @@ -1444,4 +1474,3 @@ void GenericSpell::COnSpellCastEnded(WorldEntity* player) } */ - diff --git a/entities/entity.cpp b/entities/entity.cpp index 7769c37..8455abe 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -426,6 +426,8 @@ Ref Entity::get_stat_enum(Stat::StatId stat_id) { } void Entity::set_stat_enum(Stat::StatId stat_id, Ref entry) { + ERR_FAIL_COND(!entry.is_valid()); + //ERR_FAIL_COND(stat_id == Stat::STAT_ID_NONE); if (stat_id == Stat::STAT_ID_NONE) { @@ -438,6 +440,8 @@ void Entity::set_stat_enum(Stat::StatId stat_id, Ref entry) { } void Entity::stake_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //serverside if (gets_is_dead()) { @@ -472,6 +476,8 @@ void Entity::stake_damage(Ref data) { } void Entity::son_damage_dealt(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //serverside for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -481,6 +487,8 @@ void Entity::son_damage_dealt(Ref data) { } void Entity::sdeal_damage_to(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //serverside if (gets_is_dead()) { @@ -548,11 +556,15 @@ void Entity::creceive_resurrect() { } void Entity::creceive_damage_taken(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //the current c health should probably be set here. emit_signal("con_damage_taken", this, data); } void Entity::creceiveon_damage_dealt(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + //the current c health should probably be set here. emit_signal("con_damage_dealt", this, data); } @@ -589,6 +601,8 @@ void Entity::creceive_mana_changed(int amount) { } void Entity::son_before_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -597,6 +611,8 @@ void Entity::son_before_aura_applied(Ref data) { } void Entity::son_after_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -663,6 +679,8 @@ void Entity::update_auras(float delta) { } void Entity::son_before_cast(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -671,6 +689,8 @@ void Entity::son_before_cast(Ref info) { } void Entity::son_before_cast_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -679,6 +699,8 @@ void Entity::son_before_cast_target(Ref info) { } void Entity::son_hit(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -687,6 +709,8 @@ void Entity::son_hit(Ref data) { } void Entity::son_before_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -695,6 +719,8 @@ void Entity::son_before_damage(Ref data) { } void Entity::son_damage_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -703,6 +729,8 @@ void Entity::son_damage_receive(Ref data) { } void Entity::son_dealt_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -711,6 +739,8 @@ void Entity::son_dealt_damage(Ref data) { } void Entity::sapply_passives_damage_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -719,6 +749,8 @@ void Entity::sapply_passives_damage_receive(Ref data) { } void Entity::sapply_passives_damage_deal(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -727,6 +759,8 @@ void Entity::sapply_passives_damage_deal(Ref data) { } void Entity::son_cast_finished(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -735,6 +769,8 @@ void Entity::son_cast_finished(Ref info) { } void Entity::son_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -743,6 +779,8 @@ void Entity::son_cast_started(Ref info) { } void Entity::son_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -751,6 +789,8 @@ void Entity::son_cast_failed(Ref info) { } void Entity::son_cast_finished_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + for (int i = 0; i < _s_auras->size(); ++i) { Ref ad = _s_auras->get(i); @@ -759,6 +799,8 @@ void Entity::son_cast_finished_target(Ref info) { } void Entity::sadd_aura(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + son_before_aura_applied(aura); aura->set_owner(this); @@ -773,6 +815,8 @@ void Entity::sadd_aura(Ref aura) { } void Entity::sremove_aura(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _s_auras->size(); i++) { Ref ad = _s_auras->get(i); @@ -792,6 +836,8 @@ void Entity::sremove_aura(Ref aura) { void Entity::sremove_aura_expired(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _s_auras->size(); i++) { Ref ad = _s_auras->get(i); @@ -810,6 +856,8 @@ void Entity::sremove_aura_expired(Ref aura) { } void Entity::sremove_aura_dispelled(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _s_auras->size(); i++) { Ref ad = _s_auras->get(i); @@ -828,11 +876,15 @@ void Entity::sremove_aura_dispelled(Ref aura) { } void Entity::cadd_aura(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + _c_auras->push_back(data); emit_signal("caura_added", data); } void Entity::cremove_aura(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _c_auras->size(); i++) { if (_c_auras->get(i) == aura) { _c_auras->remove(i); @@ -844,6 +896,8 @@ void Entity::cremove_aura(Ref aura) { } void Entity::cremove_aura_dispelled(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _c_auras->size(); i++) { if (_c_auras->get(i) == aura) { _c_auras->remove(i); @@ -855,6 +909,8 @@ void Entity::cremove_aura_dispelled(Ref aura) { } void Entity::cremove_aura_expired(Ref aura) { + ERR_FAIL_COND(!aura.is_valid()); + for (int i = 0; i < _c_auras->size(); i++) { if (_c_auras->get(i) == aura) { _c_auras->remove(i);