diff --git a/data/aura.cpp b/data/aura.cpp index 6c81e88..2aeefae 100644 --- a/data/aura.cpp +++ b/data/aura.cpp @@ -77,28 +77,6 @@ void Aura::set_ability_scale_data_id(int value) { ability_scale_data_id = value; } -/* -AnimationCurve *Aura::getDamageLevelScaling() { - return this->damageLevelScaling; -} - -AnimationCurve *Aura::getAbsorbLevelScaling() { - return this->absorbLevelScaling; -} - -AnimationCurve *Aura::getHealLevelScaling() { - return this->healLevelScaling; -}*/ - -/* -void Aura::Start() { - AbilityScalingDataLoader::getInstance()->GetData(this->abilityScaleDataId)->RegisterOnAssetLoaded(new AbilityScalingDataLoaderHelper::AssetLoadedAction(DELEGATE_FUNC(Aura::OnAuraAbilityScalingDataLoaded, _1))); - if (this->AuraEffectData->Enabled) { - this->AuraEffectData->LoadEffect(); - } -} -*/ - float Aura::get_damage_scale_for_level(int level) { //return this->getDamageLevelScaling()->Evaluate((float)(level)); return 1; @@ -427,7 +405,7 @@ void Aura::sapply_simple(Entity *caster, Entity *target, float spell_scale) { void Aura::sapply(Ref info) { ERR_FAIL_COND(!info.is_valid()); - + //always exists call("_sapply", info); } @@ -460,109 +438,124 @@ void Aura::supdate(Ref aura, float delta) { call("_supdate", aura, delta); } -void Aura::son_before_cast(Ref info) { +void Aura::son_before_cast(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_before_cast")) - call("_son_before_cast", info); + call("_son_before_cast", aura, info); } -void Aura::son_before_cast_target(Ref info) { +void Aura::son_before_cast_target(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_before_cast_target")) - call("_son_before_cast_target", info); + call("_son_before_cast_target", aura, info); } -void Aura::son_cast_finished(Ref info) { +void Aura::son_cast_finished(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_cast_finished")) - call("_son_cast_finished", info); + call("_son_cast_finished", aura, info); } -void Aura::son_cast_started(Ref info) { +void Aura::son_cast_started(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_cast_started")) - call("_son_cast_started", info); + call("_son_cast_started", aura, info); } -void Aura::son_cast_failed(Ref info) { +void Aura::son_cast_failed(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_cast_failed")) - call("_son_cast_failed", info); + call("_son_cast_failed", aura, info); } -void Aura::son_cast_finished_target(Ref info) { +void Aura::son_cast_finished_target(Ref aura, Ref info) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!info.is_valid()); if (has_method("_son_cast_finished_target")) - call("_son_cast_finished_target", info); + call("_son_cast_finished_target", aura, info); } -void Aura::son_hit(Ref data) { +void Aura::son_hit(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_hit")) - call("_son_hit", data); + call("_son_hit", aura, data); } -void Aura::son_before_damage(Ref data) { +void Aura::son_before_damage(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_before_damage")) - call("_son_before_damage", data); + call("_son_before_damage", aura, data); } -void Aura::son_damage_receive(Ref data) { +void Aura::son_damage_receive(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_damage_receive")) - call("_son_damage_receive", data); + call("_son_damage_receive", aura, data); } -void Aura::son_dealt_damage(Ref data) { +void Aura::son_dealt_damage(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_dealt_damage")) - call("_son_dealt_damage", data); + call("_son_dealt_damage", aura, data); } -void Aura::son_damage_dealt(Ref data) { +void Aura::son_damage_dealt(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_damage_dealt")) - call("_son_damage_dealt", data); + call("_son_damage_dealt", aura, data); } -void Aura::son_before_heal(Ref data) { +void Aura::son_before_heal(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_before_heal")) - call("_son_before_heal", data); + call("_son_before_heal", aura, data); } -void Aura::son_heal_receive(Ref data) { +void Aura::son_heal_receive(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_heal_receive")) - call("_son_heal_receive", data); + call("_son_heal_receive", aura, data); } -void Aura::son_dealt_heal(Ref data) { +void Aura::son_dealt_heal(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_dealt_heal")) - call("_son_dealt_heal", data); + call("_son_dealt_heal", aura, data); } -void Aura::son_heal_dealt(Ref data) { +void Aura::son_heal_dealt(Ref aura, Ref data) { + ERR_FAIL_COND(!aura.is_valid()); ERR_FAIL_COND(!data.is_valid()); if (has_method("_son_heal_dealt")) - call("_son_heal_dealt", data); + call("_son_heal_dealt", aura, data); } void Aura::son_remove_expired(Ref aura) { @@ -605,6 +598,67 @@ void Aura::son_death(Ref data) { call("_son_death", data); } +void Aura::son_cooldown_added(Ref data, Ref cooldown) { + if (has_method("_son_cooldown_added")) + call("_son_cooldown_added", data, cooldown); +} +void Aura::son_cooldown_removed(Ref data, Ref cooldown) { + if (has_method("_son_cooldown_removed")) + call("_son_cooldown_removed", data, cooldown); +} + +void Aura::son_category_cooldown_added(Ref data, Ref category_cooldown) { + if (has_method("_son_category_cooldown_added")) + call("_son_category_cooldown_added", data, category_cooldown); +} +void Aura::son_category_cooldown_removed(Ref data, Ref category_cooldown) { + if (has_method("_son_category_cooldown_removed")) + call("_son_category_cooldown_removed", data, category_cooldown); +} + +void Aura::con_cast_failed(Ref data, Ref info) { + if (has_method("_con_cast_failed")) + call("_con_cast_failed", data, info); +} +void Aura::con_cast_started(Ref data, Ref info) { + if (has_method("_con_cast_started")) + call("_con_cast_started", data, info); +} +void Aura::con_cast_state_changed(Ref data, Ref info) { + if (has_method("_con_cast_state_changed")) + call("_con_cast_state_changed", data, info); +} +void Aura::con_cast_finished(Ref data, Ref info) { + if (has_method("_con_cast_finished")) + call("_con_cast_finished", data, info); +} +void Aura::con_spell_cast_success(Ref data, Ref info) { + if (has_method("_con_spell_cast_success")) + call("_con_spell_cast_success", data, info); +} + +void Aura::con_death(Ref data) { + if (has_method("_con_death")) + call("_con_death", data); +} + +void Aura::con_cooldown_added(Ref data, Ref cooldown) { + if (has_method("_con_cooldown_added")) + call("_con_cooldown_added", data,cooldown); +} +void Aura::con_cooldown_removed(Ref data, Ref cooldown) { + if (has_method("_con_cooldown_removed")) + call("_con_cooldown_removed", data, cooldown); +} +void Aura::con_category_cooldown_added(Ref data, Ref category_cooldown) { + if (has_method("_con_category_cooldown_added")) + call("_con_category_cooldown_added", data, category_cooldown); +} +void Aura::con_category_cooldown_removed(Ref data, Ref category_cooldown) { + if (has_method("_con_category_cooldown_removed")) + call("_con_category_cooldown_removed", data, category_cooldown); +} + void Aura::con_aura_added(Ref data) { ERR_FAIL_COND(!data.is_valid()); @@ -626,9 +680,36 @@ void Aura::con_aura_refresh(Ref data) { call("_con_aura_refresh", data); } -void Aura::con_death(Ref data) { - if (has_method("_con_death")) - call("_con_death", data); +void Aura::con_damage_dealt(Ref data, Ref info) { + ERR_FAIL_COND(!data.is_valid()); + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_damage_dealt")) + call("_con_damage_dealt", data, info); +} + +void Aura::con_dealt_damage(Ref data, Ref info) { + ERR_FAIL_COND(!data.is_valid()); + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_dealt_damage")) + call("_con_dealt_damage", data, info); +} + +void Aura::con_heal_dealt(Ref data, Ref info) { + ERR_FAIL_COND(!data.is_valid()); + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_heal_dealt")) + call("_con_heal_dealt", data, info); +} + +void Aura::con_dealt_heal(Ref data, Ref info){ + ERR_FAIL_COND(!data.is_valid()); + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_dealt_heal")) + call("_con_dealt_heal", data, info); } void Aura::setup_aura_data(Ref data, Ref info) { @@ -859,24 +940,24 @@ void Aura::_bind_methods() { ClassDB::bind_method(D_METHOD("_supdate", "aura", "delta"), &Aura::_supdate); //EventHandlers - ClassDB::bind_method(D_METHOD("son_before_cast", "info"), &Aura::son_before_cast); - ClassDB::bind_method(D_METHOD("son_before_cast_target", "info"), &Aura::son_before_cast_target); - ClassDB::bind_method(D_METHOD("son_cast_started", "info"), &Aura::son_cast_started); - ClassDB::bind_method(D_METHOD("son_cast_failed", "info"), &Aura::son_cast_failed); - ClassDB::bind_method(D_METHOD("son_cast_finished", "info"), &Aura::son_cast_finished); - ClassDB::bind_method(D_METHOD("son_cast_finished_target", "info"), &Aura::son_cast_finished_target); + ClassDB::bind_method(D_METHOD("son_before_cast", "aura", "info"), &Aura::son_before_cast); + ClassDB::bind_method(D_METHOD("son_before_cast_target", "aura", "info"), &Aura::son_before_cast_target); + ClassDB::bind_method(D_METHOD("son_cast_started", "aura", "info"), &Aura::son_cast_started); + ClassDB::bind_method(D_METHOD("son_cast_failed", "aura", "info"), &Aura::son_cast_failed); + ClassDB::bind_method(D_METHOD("son_cast_finished", "aura", "info"), &Aura::son_cast_finished); + ClassDB::bind_method(D_METHOD("son_cast_finished_target", "aura", "info"), &Aura::son_cast_finished_target); - ClassDB::bind_method(D_METHOD("son_hit", "data"), &Aura::son_hit); + ClassDB::bind_method(D_METHOD("son_hit", "aura", "data"), &Aura::son_hit); - ClassDB::bind_method(D_METHOD("son_before_damage", "data"), &Aura::son_before_damage); - ClassDB::bind_method(D_METHOD("son_damage_receive", "data"), &Aura::son_damage_receive); - ClassDB::bind_method(D_METHOD("son_dealt_damage", "data"), &Aura::son_dealt_damage); - ClassDB::bind_method(D_METHOD("son_damage_dealt", "data"), &Aura::son_damage_dealt); + ClassDB::bind_method(D_METHOD("son_before_damage", "aura", "data"), &Aura::son_before_damage); + ClassDB::bind_method(D_METHOD("son_damage_receive", "aura", "data"), &Aura::son_damage_receive); + ClassDB::bind_method(D_METHOD("son_dealt_damage", "aura", "data"), &Aura::son_dealt_damage); + ClassDB::bind_method(D_METHOD("son_damage_dealt", "aura", "data"), &Aura::son_damage_dealt); - ClassDB::bind_method(D_METHOD("son_before_heal", "data"), &Aura::son_before_heal); - ClassDB::bind_method(D_METHOD("son_heal_receive", "data"), &Aura::son_heal_receive); - ClassDB::bind_method(D_METHOD("son_dealt_heal", "data"), &Aura::son_dealt_heal); - ClassDB::bind_method(D_METHOD("son_heal_dealt", "data"), &Aura::son_heal_dealt); + ClassDB::bind_method(D_METHOD("son_before_heal", "aura", "data"), &Aura::son_before_heal); + ClassDB::bind_method(D_METHOD("son_heal_receive", "aura", "data"), &Aura::son_heal_receive); + ClassDB::bind_method(D_METHOD("son_dealt_heal", "aura", "data"), &Aura::son_dealt_heal); + ClassDB::bind_method(D_METHOD("son_heal_dealt", "aura", "data"), &Aura::son_heal_dealt); ClassDB::bind_method(D_METHOD("son_remove", "aura"), &Aura::son_remove); ClassDB::bind_method(D_METHOD("son_remove_expired", "aura"), &Aura::son_remove_expired); @@ -886,25 +967,31 @@ void Aura::_bind_methods() { ClassDB::bind_method(D_METHOD("son_after_aura_applied", "data"), &Aura::son_after_aura_applied); ClassDB::bind_method(D_METHOD("son_death", "data"), &Aura::son_death); + + ClassDB::bind_method(D_METHOD("son_cooldown_added", "data", "cooldown"), &Aura::son_cooldown_added); + ClassDB::bind_method(D_METHOD("son_cooldown_removed", "data", "cooldown"), &Aura::son_cooldown_removed); + + ClassDB::bind_method(D_METHOD("son_category_cooldown_added", "data", "category_cooldown"), &Aura::son_category_cooldown_added); + ClassDB::bind_method(D_METHOD("son_category_cooldown_removed", "data", "category_cooldown"), &Aura::son_category_cooldown_removed); + + BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); BIND_VMETHOD(MethodInfo("_son_remove", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); BIND_VMETHOD(MethodInfo("_son_remove_expired", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); @@ -914,18 +1001,57 @@ void Aura::_bind_methods() { BIND_VMETHOD(MethodInfo("_son_after_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); BIND_VMETHOD(MethodInfo("_son_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + BIND_VMETHOD(MethodInfo("_son_cooldown_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_son_cooldown_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_son_category_cooldown_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("_son_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); //Clientside Event Handlers + ClassDB::bind_method(D_METHOD("con_cast_failed", "data", "info"), &Aura::con_cast_failed); + ClassDB::bind_method(D_METHOD("con_cast_started", "data", "info"), &Aura::con_cast_started); + ClassDB::bind_method(D_METHOD("con_cast_state_changed", "data", "info"), &Aura::con_cast_state_changed); + ClassDB::bind_method(D_METHOD("con_cast_finished", "data", "info"), &Aura::con_cast_finished); + ClassDB::bind_method(D_METHOD("con_spell_cast_success", "data", "info"), &Aura::con_spell_cast_success); + + ClassDB::bind_method(D_METHOD("con_death", "data"), &Aura::con_death); + + ClassDB::bind_method(D_METHOD("con_cooldown_added", "data", "info"), &Aura::con_cooldown_added); + ClassDB::bind_method(D_METHOD("con_cooldown_removed", "data", "info"), &Aura::con_cooldown_removed); + ClassDB::bind_method(D_METHOD("con_category_cooldown_added", "data", "info"), &Aura::con_category_cooldown_added); + ClassDB::bind_method(D_METHOD("con_category_cooldown_removed", "data", "info"), &Aura::con_category_cooldown_removed); + ClassDB::bind_method(D_METHOD("con_aura_added", "data"), &Aura::con_aura_added); ClassDB::bind_method(D_METHOD("con_aura_removed", "data"), &Aura::con_aura_removed); ClassDB::bind_method(D_METHOD("con_aura_refresh", "data"), &Aura::con_aura_refresh); - ClassDB::bind_method(D_METHOD("con_death", "data"), &Aura::con_death); - + + ClassDB::bind_method(D_METHOD("con_damage_dealt", "data", "info"), &Aura::con_damage_dealt); + ClassDB::bind_method(D_METHOD("con_dealt_damage", "data", "info"), &Aura::con_dealt_damage); + ClassDB::bind_method(D_METHOD("con_heal_dealt", "data", "info"), &Aura::con_heal_dealt); + ClassDB::bind_method(D_METHOD("con_dealt_heal", "data", "info"), &Aura::con_dealt_heal); + + BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_state_changed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_finished", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_spell_cast_success", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + + BIND_VMETHOD(MethodInfo("_con_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + BIND_VMETHOD(MethodInfo("_con_cooldown_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_con_cooldown_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_con_category_cooldown_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("_con_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("_con_aura_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - + + BIND_VMETHOD(MethodInfo("_con_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_con_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_con_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_con_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + //Calculations / Queries ClassDB::bind_method(D_METHOD("setup_aura_data", "data", "info"), &Aura::setup_aura_data); diff --git a/data/aura.h b/data/aura.h index 4b5adde..9fb0f64 100644 --- a/data/aura.h +++ b/data/aura.h @@ -20,6 +20,9 @@ #include "../pipelines/spell_heal_info.h" #include "../infos/spell_cast_info.h" +#include "../utility/cooldown.h" +#include "../utility/category_cooldown.h" + class AuraApplyInfo; class AuraScript; class Entity; @@ -206,24 +209,24 @@ public: virtual void _sremove_dispell(Ref aura); //EventHandlers - void son_before_cast(Ref info); - void son_before_cast_target(Ref info); - void son_cast_started(Ref info); - void son_cast_failed(Ref info); - void son_cast_finished(Ref info); - void son_cast_finished_target(Ref info); + void son_before_cast(Ref aura, Ref info); + void son_before_cast_target(Ref aura, Ref info); + void son_cast_started(Ref aura, Ref info); + void son_cast_failed(Ref aura, Ref info); + void son_cast_finished(Ref aura, Ref info); + void son_cast_finished_target(Ref aura, Ref info); - void son_hit(Ref data); + void son_hit(Ref aura, Ref data); - void son_before_damage(Ref data); - void son_damage_receive(Ref data); - void son_dealt_damage(Ref data); - void son_damage_dealt(Ref data); + void son_before_damage(Ref aura, Ref data); + void son_damage_receive(Ref aura, Ref data); + void son_dealt_damage(Ref aura, Ref data); + void son_damage_dealt(Ref aura, Ref data); - void son_before_heal(Ref data); - void son_heal_receive(Ref data); - void son_dealt_heal(Ref data); - void son_heal_dealt(Ref data); + void son_before_heal(Ref aura, Ref data); + void son_heal_receive(Ref aura, Ref data); + void son_dealt_heal(Ref aura, Ref data); + void son_heal_dealt(Ref aura, Ref data); void son_remove(Ref aura); void son_remove_expired(Ref aura); @@ -233,12 +236,35 @@ public: void son_after_aura_applied(Ref data); void son_death(Ref data); + + void son_cooldown_added(Ref data, Ref cooldown); + void son_cooldown_removed(Ref data, Ref cooldown); + + void son_category_cooldown_added(Ref data, Ref category_cooldown); + void son_category_cooldown_removed(Ref data, Ref category_cooldown); //Clientside Event Handlers + void con_cast_failed(Ref data, Ref info); + void con_cast_started(Ref data, Ref info); + void con_cast_state_changed(Ref data, Ref info); + void con_cast_finished(Ref data, Ref info); + void con_spell_cast_success(Ref data, Ref info); + + void con_death(Ref data); + + void con_cooldown_added(Ref data, Ref cooldown); + void con_cooldown_removed(Ref data, Ref cooldown); + void con_category_cooldown_added(Ref data, Ref category_cooldown); + void con_category_cooldown_removed(Ref data, Ref category_cooldown); + void con_aura_added(Ref data); void con_aura_removed(Ref data); void con_aura_refresh(Ref data); - void con_death(Ref data); + + void con_damage_dealt(Ref data, Ref info); + void con_dealt_damage(Ref data, Ref info); + void con_heal_dealt(Ref data, Ref info); + void con_dealt_heal(Ref data, Ref info); //Calculations / Queries void setup_aura_data(Ref data, Ref info); diff --git a/data/character_class.cpp b/data/character_class.cpp index 10cbad2..c62bf7f 100644 --- a/data/character_class.cpp +++ b/data/character_class.cpp @@ -284,6 +284,98 @@ void CharacterClass::son_death_bind(Node *entity) { son_death(e); } +void CharacterClass::son_cooldown_added(Ref cooldown) { + if (has_method("_son_cooldown_added")) + call("_son_cooldown_added", cooldown); +} +void CharacterClass::son_cooldown_removed(Ref cooldown) { + if (has_method("_son_cooldown_removed")) + call("_son_cooldown_removed", cooldown); +} + +void CharacterClass::son_category_cooldown_added(Ref category_cooldown) { + if (has_method("_son_category_cooldown_added")) + call("_son_category_cooldown_added", category_cooldown); +} +void CharacterClass::son_category_cooldown_removed(Ref category_cooldown) { + if (has_method("_son_category_cooldown_removed")) + call("_son_category_cooldown_removed", category_cooldown); +} + +//Clientside Event Handlers +void CharacterClass::con_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_cast_failed")) + call("_con_cast_failed", info); +} +void CharacterClass::con_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_cast_started")) + call("_con_cast_started", info); +} +void CharacterClass::con_cast_state_changed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_cast_state_changed")) + call("_con_cast_state_changed", info); +} +void CharacterClass::con_cast_finished(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_cast_finished")) + call("_con_cast_finished", info); +} +void CharacterClass::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 CharacterClass::con_death(Entity *entity) { + ERR_FAIL_COND(entity == NULL); + + if (has_method("_con_death")) + call("_con_death", entity); +} + +void CharacterClass::con_death_bind(Node *entity) { + ERR_FAIL_COND(entity == NULL); + + Entity *e = Object::cast_to(entity); + + ERR_FAIL_COND(e == NULL); + + con_death(e); +} + +void CharacterClass::con_cooldown_added(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (has_method("_con_cooldown_added")) + call("_con_cooldown_added", cooldown); +} +void CharacterClass::con_cooldown_removed(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (has_method("_con_cooldown_removed")) + call("_con_cooldown_removed", cooldown); +} +void CharacterClass::con_category_cooldown_added(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (has_method("_con_category_cooldown_added")) + call("_con_category_cooldown_added", category_cooldown); +} +void CharacterClass::con_category_cooldown_removed(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (has_method("_con_category_cooldown_removed")) + call("_con_category_cooldown_removed", category_cooldown); +} + void CharacterClass::con_aura_added(Ref data) { ERR_FAIL_COND(!data.is_valid()); @@ -305,21 +397,35 @@ void CharacterClass::con_aura_refresh(Ref data) { call("_con_aura_refresh", data); } -void CharacterClass::con_death(Entity *entity) { - if (has_method("_con_death")) - call("_con_death", entity); +void CharacterClass::con_damage_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_damage_dealt")) + call("_con_damage_dealt", info); } -void CharacterClass::con_death_bind(Node *entity) { - ERR_FAIL_COND(entity == NULL); +void CharacterClass::con_dealt_damage(Ref info) { + ERR_FAIL_COND(!info.is_valid()); - Entity *e = Object::cast_to(entity); - - ERR_FAIL_COND(e == NULL); - - con_death(e); + if (has_method("_con_dealt_damage")) + call("_con_dealt_damage", info); } +void CharacterClass::con_heal_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_heal_dealt")) + call("_con_heal_dealt", info); +} + +void CharacterClass::con_dealt_heal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_con_dealt_heal")) + call("_con_dealt_heal", info); +} + + void CharacterClass::sai_follow(Entity *entity) { ERR_FAIL_COND(entity == NULL); @@ -407,41 +513,6 @@ void CharacterClass::_validate_property(PropertyInfo &property) const { } void CharacterClass::_bind_methods() { - BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - - BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_son_after_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - - BIND_VMETHOD(MethodInfo("_son_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - - BIND_VMETHOD(MethodInfo("_con_aura_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - - BIND_VMETHOD(MethodInfo("_con_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - - BIND_VMETHOD(MethodInfo("_sai_follow", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - BIND_VMETHOD(MethodInfo("_sai_rest", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - BIND_VMETHOD(MethodInfo("_sai_regenerate", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - BIND_VMETHOD(MethodInfo("_sai_attack", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); - //EventHandlers ClassDB::bind_method(D_METHOD("son_before_cast", "info"), &CharacterClass::son_before_cast); ClassDB::bind_method(D_METHOD("son_before_cast_target", "info"), &CharacterClass::son_before_cast_target); @@ -466,12 +537,83 @@ void CharacterClass::_bind_methods() { ClassDB::bind_method(D_METHOD("son_after_aura_applied", "data"), &CharacterClass::son_after_aura_applied); ClassDB::bind_method(D_METHOD("son_death", "data"), &CharacterClass::son_death_bind); + + ClassDB::bind_method(D_METHOD("son_cooldown_added", "cooldown"), &CharacterClass::son_cooldown_added); + ClassDB::bind_method(D_METHOD("son_cooldown_removed", "cooldown"), &CharacterClass::son_cooldown_removed); + + ClassDB::bind_method(D_METHOD("son_category_cooldown_added", "category_cooldown"), &CharacterClass::son_category_cooldown_added); + ClassDB::bind_method(D_METHOD("son_category_cooldown_removed", "category_cooldown"), &CharacterClass::son_category_cooldown_removed); + + BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + + BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_son_after_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + BIND_VMETHOD(MethodInfo("_son_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + + BIND_VMETHOD(MethodInfo("_sai_follow", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + BIND_VMETHOD(MethodInfo("_sai_rest", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + BIND_VMETHOD(MethodInfo("_sai_regenerate", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + BIND_VMETHOD(MethodInfo("_sai_attack", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + + BIND_VMETHOD(MethodInfo("_son_cooldown_added", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_son_cooldown_removed", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + + BIND_VMETHOD(MethodInfo("_son_category_cooldown_added", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("_son_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + //Clientside Event Handlers + ClassDB::bind_method(D_METHOD("con_cast_failed", "info"), &CharacterClass::con_cast_failed); + ClassDB::bind_method(D_METHOD("con_cast_started", "info"), &CharacterClass::con_cast_started); + ClassDB::bind_method(D_METHOD("con_cast_state_changed", "info"), &CharacterClass::con_cast_state_changed); + ClassDB::bind_method(D_METHOD("con_cast_finished", "info"), &CharacterClass::con_cast_finished); + ClassDB::bind_method(D_METHOD("con_spell_cast_success", "info"), &CharacterClass::con_spell_cast_success); + + ClassDB::bind_method(D_METHOD("con_death", "data"), &CharacterClass::con_death_bind); + + ClassDB::bind_method(D_METHOD("con_cooldown_added", "cooldown"), &CharacterClass::con_cooldown_added); + ClassDB::bind_method(D_METHOD("con_cooldown_removed", "cooldown"), &CharacterClass::con_cooldown_removed); + ClassDB::bind_method(D_METHOD("con_category_cooldown_added", "cooldown"), &CharacterClass::con_category_cooldown_added); + ClassDB::bind_method(D_METHOD("con_category_cooldown_removed", "cooldown"), &CharacterClass::con_category_cooldown_removed); + ClassDB::bind_method(D_METHOD("con_aura_added", "data"), &CharacterClass::con_aura_added); ClassDB::bind_method(D_METHOD("con_aura_removed", "data"), &CharacterClass::con_aura_removed); ClassDB::bind_method(D_METHOD("con_aura_refresh", "data"), &CharacterClass::con_aura_refresh); - ClassDB::bind_method(D_METHOD("con_death", "data"), &CharacterClass::con_death_bind); + + BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_state_changed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_spell_cast_success", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + + BIND_VMETHOD(MethodInfo("_con_death", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + + BIND_VMETHOD(MethodInfo("_con_cooldown_added", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_con_cooldown_removed", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("_con_category_cooldown_added", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("_con_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + + BIND_VMETHOD(MethodInfo("_con_aura_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); ClassDB::bind_method(D_METHOD("sai_follow", "entity"), &CharacterClass::sai_follow_bind); ClassDB::bind_method(D_METHOD("sai_rest", "entity"), &CharacterClass::sai_rest_bind); diff --git a/data/character_class.h b/data/character_class.h index cafc7c8..2be8f87 100644 --- a/data/character_class.h +++ b/data/character_class.h @@ -14,6 +14,9 @@ #include "../pipelines/spell_heal_info.h" #include "../infos/spell_cast_info.h" +#include "../utility/cooldown.h" +#include "../utility/category_cooldown.h" + class Aura; class Spell; class Entity; @@ -112,13 +115,35 @@ public: void son_death(Entity *entity); void son_death_bind(Node *entity); + void son_cooldown_added(Ref cooldown); + void son_cooldown_removed(Ref cooldown); + + void son_category_cooldown_added(Ref category_cooldown); + void son_category_cooldown_removed(Ref category_cooldown); + //Clientside Event Handlers + void con_cast_failed(Ref info); + void con_cast_started(Ref info); + void con_cast_state_changed(Ref info); + void con_cast_finished(Ref info); + void con_spell_cast_success(Ref info); + + void con_death(Entity *entity); + void con_death_bind(Node *entity); + + void con_cooldown_added(Ref cooldown); + void con_cooldown_removed(Ref cooldown); + void con_category_cooldown_added(Ref category_cooldown); + void con_category_cooldown_removed(Ref category_cooldown); + void con_aura_added(Ref data); void con_aura_removed(Ref data); void con_aura_refresh(Ref data); - - void con_death(Entity *entity); - void con_death_bind(Node *entity); + + void con_damage_dealt(Ref info); + void con_dealt_damage(Ref info); + void con_heal_dealt(Ref info); + void con_dealt_heal(Ref info); // AI // void sai_follow(Entity *entity); diff --git a/entities/auras/aura_data.cpp b/entities/auras/aura_data.cpp index 1a7abcb..22827ca 100644 --- a/entities/auras/aura_data.cpp +++ b/entities/auras/aura_data.cpp @@ -80,7 +80,11 @@ Entity *AuraData::get_owner() { return _owner; } -void AuraData::set_owner(Node *value) { +void AuraData::set_owner(Entity *value) { + _owner = value; +} + +void AuraData::set_owner_bind(Node *value) { if (!value) { return; } @@ -98,7 +102,11 @@ Entity *AuraData::get_caster() { return _caster; } -void AuraData::set_caster(Node *value) { +void AuraData::set_caster(Entity *value) { + _caster = value; +} + +void AuraData::set_caster_bind(Node *value) { if (!value) { return; } @@ -247,11 +255,11 @@ void AuraData::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::REAL, "remaining_time"), "set_remaining_time", "get_remaining_time"); ClassDB::bind_method(D_METHOD("get_owner"), &AuraData::get_owner); - ClassDB::bind_method(D_METHOD("set_owner", "value"), &AuraData::set_owner); + ClassDB::bind_method(D_METHOD("set_owner", "value"), &AuraData::set_owner_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "owner", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_owner", "get_owner"); ClassDB::bind_method(D_METHOD("get_caster"), &AuraData::get_caster); - ClassDB::bind_method(D_METHOD("set_caster", "value"), &AuraData::set_caster); + ClassDB::bind_method(D_METHOD("set_caster", "value"), &AuraData::set_caster_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "caster", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_caster", "get_caster"); ClassDB::bind_method(D_METHOD("get_caster_guid"), &AuraData::get_caster_guid); diff --git a/entities/auras/aura_data.h b/entities/auras/aura_data.h index d32e45d..bff3f48 100644 --- a/entities/auras/aura_data.h +++ b/entities/auras/aura_data.h @@ -22,10 +22,12 @@ public: bool update(float delta); Entity *get_owner(); - void set_owner(Node *value); + void set_owner(Entity *value); + void set_owner_bind(Node *value); Entity *get_caster(); - void set_caster(Node *value); + void set_caster(Entity *value); + void set_caster_bind(Node *value); int get_caster_guid(); void set_caster_guid(int value); diff --git a/entities/entity.cpp b/entities/entity.cpp index 65369a6..a96002a 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -248,6 +248,9 @@ Entity::Entity() { _s_spell_target_guid = 0; _s_spell_cast_game_object_guid = 0; + _s_active_category_cooldowns = 0; + _c_active_category_cooldowns = 0; + _s_entity_type = EntityEnums::EntityType::ENITIY_TYPE_NONE; _c_entity_type = EntityEnums::EntityType::ENITIY_TYPE_NONE; @@ -349,10 +352,10 @@ Entity::Entity() { //Clientside hooks - SET_RPC_REMOTE("creceive_damage_taken"); - SET_RPC_REMOTE("creceiveon_damage_dealt"); - SET_RPC_REMOTE("creceive_heal_taken"); - SET_RPC_REMOTE("creceiveon_heal_dealt"); + SET_RPC_REMOTE("con_damage_dealt"); + SET_RPC_REMOTE("con_dealt_damage"); + SET_RPC_REMOTE("con_heal_dealt"); + SET_RPC_REMOTE("con_dealt_heal"); //// Casting System //// @@ -621,8 +624,8 @@ void Entity::removec_resource(int index) { _c_resources.remove(index); } -void Entity::stake_damage(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::stake_damage(Ref info) { + ERR_FAIL_COND(!info.is_valid()); //serverside @@ -631,34 +634,36 @@ void Entity::stake_damage(Ref data) { } //send it through the passive damage reductions pipeline - sapply_passives_damage_receive(data); + sapply_passives_damage_receive(info); //send it through the onbeforehit handler - son_before_damage(data); + son_before_damage(info); //send it throug the onhit pipeliine - son_hit(data); - son_damage_receive(data); + son_hit(info); + son_damage_receive(info); - int h = get_health()->gets_current() - data->get_damage(); + int h = get_health()->gets_current() - info->get_damage(); if (h < 0) { h = 0; } get_health()->sets_current(h); - - //send an event to client - SEND_RPC(rpc("creceive_damage_taken", data), creceive_damage_taken(data)); - + + son_damage_dealt(info); + //signal - emit_signal("son_damage_received", this, data); + emit_signal("son_damage_received", this, info); + + //send an event to client + SEND_RPC(rpc("con_damage_dealt", info), con_damage_dealt(info)); if (get_health()->gets_current() <= 0) { sdie(); } } -void Entity::sdeal_damage_to(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::sdeal_damage_to(Ref info) { + ERR_FAIL_COND(!info.is_valid()); //serverside @@ -666,13 +671,23 @@ void Entity::sdeal_damage_to(Ref data) { return; } - sapply_passives_damage_deal(data); - data->get_receiver()->stake_damage(data); - son_damage_dealt(data); + sapply_passives_damage_deal(info); + info->get_receiver()->stake_damage(info); + son_dealt_damage(info); + + //send an event to client + SEND_RPC(rpc("con_dealt_damage", info), con_dealt_damage(info)); + + //signal + emit_signal("son_damage_received", this, info); + + if (get_health()->gets_current() <= 0) { + sdie(); + } } -void Entity::stake_heal(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::stake_heal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); //serverside @@ -681,13 +696,13 @@ void Entity::stake_heal(Ref data) { } //send it through the passive damage reductions pipeline - sapply_passives_heal_receive(data); + sapply_passives_heal_receive(info); //send it through the onbeforehit handler - son_before_heal(data); + son_before_heal(info); - son_heal_receive(data); + son_heal_receive(info); - int h = get_health()->gets_current() + data->get_heal(); + int h = get_health()->gets_current() + info->get_heal(); if (h > get_health()->gets_max()) { h = get_health()->gets_max(); @@ -695,15 +710,15 @@ void Entity::stake_heal(Ref data) { get_health()->sets_current(h); //send an event to client - SEND_RPC(rpc("creceive_heal_taken", data), creceive_heal_taken(data)); + SEND_RPC(rpc("con_heal_dealt", info), con_heal_dealt(info)); //signal - emit_signal("son_heal_received", this, data); + emit_signal("son_heal_received", this, info); } -void Entity::sdeal_heal_to(Ref data) { - ERR_FAIL_COND(!data.is_valid()); - ERR_FAIL_COND(data->get_receiver() == NULL); +void Entity::sdeal_heal_to(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + ERR_FAIL_COND(info->get_receiver() == NULL); //serverside @@ -711,9 +726,9 @@ void Entity::sdeal_heal_to(Ref data) { return; } - sapply_passives_heal_deal(data); - data->get_receiver()->stake_heal(data); - son_heal_dealt(data); + sapply_passives_heal_deal(info); + info->get_receiver()->stake_heal(info); + son_heal_dealt(info); } void Entity::resurrect() { @@ -743,46 +758,6 @@ void Entity::creceive_resurrect() { CHealth->Dirty = false;*/ } -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_received", 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); -} - -void Entity::creceive_heal_taken(Ref data) { - ERR_FAIL_COND(!data.is_valid()); - - //the current c health should probably be set here. - emit_signal("con_heal_received", this, data); -} - -void Entity::creceiveon_heal_dealt(Ref data) { - ERR_FAIL_COND(!data.is_valid()); - - //the current c health should probably be set here. - emit_signal("con_heal_dealt", this, data); -} - -void Entity::creceive_died() { - /* - cIsDead = true; - cRezTimer = (float)5; - if (OnDeath != null) { - DELEGATE_INVOKE(OnDeath); - } - for (int i = 0; i < eventHandlers->Count; i += 1) { - eventHandlers->GetData(i)->OnDied(owner->transform->gameObject); - }*/ -} - void Entity::creceive_mana_changed(int amount) { /* Stat *expr_06 = CMana; @@ -866,7 +841,7 @@ void Entity::son_before_cast(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast(info); + ad->get_aura()->son_before_cast(ad, info); } } @@ -883,202 +858,202 @@ void Entity::son_before_cast_target(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast_target(info); + ad->get_aura()->son_before_cast_target(ad, info); } } -void Entity::son_hit(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_hit(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_hit(data); + _s_character_class->son_hit(info); } if (has_method("_son_hit")) - call("_son_hit", data); + call("_son_hit", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_hit(data); + ad->get_aura()->son_hit(ad, info); } } -void Entity::son_before_damage(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_before_damage(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_before_damage(data); + _s_character_class->son_before_damage(info); } if (has_method("_son_before_damage")) - call("_son_before_damage", data); + call("_son_before_damage", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_damage(data); + ad->get_aura()->son_before_damage(ad, info); } } -void Entity::son_damage_receive(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_damage_receive(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_damage_receive(data); + _s_character_class->son_damage_receive(info); } if (has_method("_son_damage_receive")) - call("_son_damage_receive", data); + call("_son_damage_receive", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_damage_receive(data); + ad->get_aura()->son_damage_receive(ad, info); } } -void Entity::son_dealt_damage(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_dealt_damage(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_dealt_damage(data); + _s_character_class->son_dealt_damage(info); } if (has_method("_son_dealt_damage")) - call("_son_dealt_damage", data); + call("_son_dealt_damage", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_dealt_damage(data); + ad->get_aura()->son_dealt_damage(ad, info); } } -void Entity::son_damage_dealt(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_damage_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_damage_dealt(data); + _s_character_class->son_damage_dealt(info); } if (has_method("_son_damage_dealt")) - call("_son_damage_dealt", data); + call("_son_damage_dealt", info); //serverside for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_damage_dealt(data); + ad->get_aura()->son_damage_dealt(ad, info); } } -void Entity::son_before_heal(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_before_heal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_before_heal(data); + _s_character_class->son_before_heal(info); } if (has_method("_son_before_heal")) - call("_son_before_heal", data); + call("_son_before_heal", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_heal(data); + ad->get_aura()->son_before_heal(ad, info); } } -void Entity::son_heal_receive(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_heal_receive(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_heal_receive(data); + _s_character_class->son_heal_receive(info); } if (has_method("_son_heal_receive")) - call("_son_heal_receive", data); + call("_son_heal_receive", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_heal_receive(data); + ad->get_aura()->son_heal_receive(ad, info); } } -void Entity::son_dealt_heal(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_dealt_heal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_dealt_heal(data); + _s_character_class->son_dealt_heal(info); } if (has_method("_son_dealt_heal")) - call("_son_dealt_heal", data); + call("_son_dealt_heal", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_dealt_heal(data); + ad->get_aura()->son_dealt_heal(ad, info); } } -void Entity::son_heal_dealt(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::son_heal_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); if (_s_character_class.is_valid()) { - _s_character_class->son_heal_dealt(data); + _s_character_class->son_heal_dealt(info); } if (has_method("_son_heal_dealt")) - call("_son_heal_dealt", data); + call("_son_heal_dealt", info); //serverside for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_heal_dealt(data); + ad->get_aura()->son_heal_dealt(ad, info); } } -void Entity::sapply_passives_damage_receive(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::sapply_passives_damage_receive(Ref info) { + ERR_FAIL_COND(!info.is_valid()); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->sapply_passives_damage_receive(data); + ad->get_aura()->sapply_passives_damage_receive(info); } } -void Entity::sapply_passives_damage_deal(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::sapply_passives_damage_deal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->sapply_passives_damage_deal(data); + ad->get_aura()->sapply_passives_damage_deal(info); } } -void Entity::sapply_passives_heal_receive(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::sapply_passives_heal_receive(Ref info) { + ERR_FAIL_COND(!info.is_valid()); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->sapply_passives_heal_receive(data); + ad->get_aura()->sapply_passives_heal_receive(info); } } -void Entity::sapply_passives_heal_deal(Ref data) { - ERR_FAIL_COND(!data.is_valid()); +void Entity::sapply_passives_heal_deal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->sapply_passives_heal_deal(data); + ad->get_aura()->sapply_passives_heal_deal(info); } } @@ -1095,7 +1070,7 @@ void Entity::son_cast_finished(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_cast_finished(info); + ad->get_aura()->son_cast_finished(ad, info); } } @@ -1112,7 +1087,7 @@ void Entity::son_cast_started(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_cast_started(info); + ad->get_aura()->son_cast_started(ad, info); } } @@ -1129,7 +1104,7 @@ void Entity::son_cast_failed(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_cast_failed(info); + ad->get_aura()->son_cast_failed(ad, info); } } @@ -1146,7 +1121,7 @@ void Entity::son_cast_finished_target(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_cast_finished_target(info); + ad->get_aura()->son_cast_finished_target(ad, info); } } @@ -1165,6 +1140,72 @@ void Entity::son_death() { call("_son_death"); } +void Entity::son_cooldown_added(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (_s_character_class.is_valid()) { + _s_character_class->son_cooldown_added(cooldown); + } + + if (has_method("_son_cooldown_added")) + call("_son_cooldown_added", cooldown); + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->son_cooldown_added(ad, cooldown); + } +} +void Entity::son_cooldown_removed(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (_s_character_class.is_valid()) { + _s_character_class->son_cooldown_removed(cooldown); + } + + if (has_method("_son_cooldown_removed")) + call("_son_cooldown_removed", cooldown); + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->son_cooldown_removed(ad, cooldown); + } +} + +void Entity::son_category_cooldown_added(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (_s_character_class.is_valid()) { + _s_character_class->son_category_cooldown_added(category_cooldown); + } + + if (has_method("_son_category_cooldown_added")) + call("_son_category_cooldown_added", category_cooldown); + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->son_category_cooldown_added(ad, category_cooldown); + } +} +void Entity::son_category_cooldown_removed(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (_s_character_class.is_valid()) { + _s_character_class->son_category_cooldown_removed(category_cooldown); + } + + if (has_method("_son_category_cooldown_removed")) + call("_son_category_cooldown_removed", category_cooldown); + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->son_category_cooldown_removed(ad, category_cooldown); + } +} + void Entity::sadd_aura(Ref aura) { ERR_FAIL_COND(!aura.is_valid()); @@ -1419,27 +1460,97 @@ void Entity::moved() { } void Entity::con_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cast_failed(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cast_failed(ad, info); + } + + if (has_method("_con_cast_failed")) + call("_con_cast_failed"); } void Entity::con_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cast_started(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cast_started(ad, info); + } + + if (has_method("_con_cast_started")) + call("_con_cast_started"); } void Entity::con_cast_state_changed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cast_state_changed(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cast_state_changed(ad, info); + } + + if (has_method("_con_cast_state_changed")) + call("_con_cast_state_changed"); } void Entity::con_cast_finished(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cast_finished(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cast_finished(ad, info); + } + + if (has_method("_con_cast_finished")) + call("_con_cast_finished"); } void Entity::con_spell_cast_success(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_spell_cast_success(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_spell_cast_success(ad, info); + } + + if (has_method("_con_spell_cast_success")) + call("_con_spell_cast_success"); } void Entity::con_death() { - if (_s_character_class.is_valid()) { - _s_character_class->con_death(this); + if (_c_character_class.is_valid()) { + _c_character_class->con_death(this); } - for (int i = 0; i < _s_auras.size(); ++i) { - Ref ad = _s_auras.get(i); + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); ad->get_aura()->con_death(ad); } @@ -1448,30 +1559,203 @@ void Entity::con_death() { call("_con_death"); } +void Entity::con_cooldown_added(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cooldown_added(cooldown); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cooldown_added(ad, cooldown); + } + + if (has_method("_con_cooldown_added")) + call("_con_cooldown_added"); +} +void Entity::con_cooldown_removed(Ref cooldown) { + ERR_FAIL_COND(!cooldown.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_cooldown_removed(cooldown); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_cooldown_removed(ad, cooldown); + } + + if (has_method("_con_cooldown_removed")) + call("_con_cooldown_removed"); +} +void Entity::con_category_cooldown_added(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_category_cooldown_added(category_cooldown); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_category_cooldown_added(ad, category_cooldown); + } + + if (has_method("_con_category_cooldown_added")) + call("_con_category_cooldown_added"); +} +void Entity::con_category_cooldown_removed(Ref category_cooldown) { + ERR_FAIL_COND(!category_cooldown.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_category_cooldown_removed(category_cooldown); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_category_cooldown_removed(ad, category_cooldown); + } + + if (has_method("_con_category_cooldown_removed")) + call("_con_category_cooldown_removed"); +} + void Entity::con_aura_added(Ref data) { ERR_FAIL_COND(!data.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_aura_added(data); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + ad->get_aura()->con_aura_added(data); + } + if (has_method("_con_aura_added")) - call("_con_aura_added", data); + call("_con_aura_added"); } void Entity::con_aura_removed(Ref data) { ERR_FAIL_COND(!data.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_aura_removed(data); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + ad->get_aura()->con_aura_removed(data); + } + if (has_method("_con_aura_removed")) - call("_con_aura_removed", data); + call("_con_aura_removed"); } void Entity::con_aura_refresh(Ref data) { ERR_FAIL_COND(!data.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_aura_refresh(data); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + ad->get_aura()->con_aura_refresh(data); + } + if (has_method("_con_aura_refresh")) - call("_con_aura_refresh", data); + call("_con_aura_refresh"); } -void Entity::setup_on_player_moves(Entity *bopmccc, Vector *sspells) { +void Entity::con_damage_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_damage_dealt(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_damage_dealt(ad, info); + } + + if (has_method("_con_damage_dealt")) + call("_con_damage_dealt", info); + + //the current c health should probably be set here. + emit_signal("con_damage_dealt", this, info); } +void Entity::con_dealt_damage(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_dealt_damage(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_dealt_damage(ad, info); + } + + if (has_method("_con_dealt_damage")) + call("_con_dealt_damage", info); + + //the current c health should probably be set here. + emit_signal("con_dealt_damage", this, info); +} + +void Entity::con_heal_dealt(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_heal_dealt(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_heal_dealt(ad, info); + } + + if (has_method("_con_heal_dealt")) + call("_con_heal_dealt", info); + + //the current c health should probably be set here. + emit_signal("con_heal_dealt", this, info); +} + +void Entity::con_dealt_heal(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (_c_character_class.is_valid()) { + _c_character_class->con_dealt_heal(info); + } + + for (int i = 0; i < _c_auras.size(); ++i) { + Ref ad = _c_auras.get(i); + + ad->get_aura()->con_dealt_heal(ad, info); + } + + if (has_method("_con_dealt_heal")) + call("_con_dealt_heal", info); + + //the current c health should probably be set here. + emit_signal("con_dealt_heal", this, info); +} + + //// Casting System //// void Entity::sstart_casting(Ref info) { @@ -1480,7 +1764,7 @@ void Entity::sstart_casting(Ref info) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast(info); + ad->get_aura()->son_before_cast(ad, info); } _s_spell_cast_info->set_is_casting(true); @@ -1494,7 +1778,7 @@ void Entity::sfail_cast() { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast(_s_spell_cast_info); + ad->get_aura()->son_before_cast(ad, _s_spell_cast_info); } emit_signal("scast_failed", _s_spell_cast_info); @@ -1506,7 +1790,7 @@ void Entity::sdelay_cast() { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast(_s_spell_cast_info); + ad->get_aura()->son_before_cast(ad, _s_spell_cast_info); } emit_signal("scast_delayed", _s_spell_cast_info); @@ -1519,7 +1803,7 @@ void Entity::sfinish_cast() { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_cast_finished(_s_spell_cast_info); + ad->get_aura()->son_cast_finished(ad, _s_spell_cast_info); } _s_spell_cast_info->get_spell()->sfinish_cast(_s_spell_cast_info); @@ -1535,7 +1819,7 @@ void Entity::sinterrupt_cast() { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); - ad->get_aura()->son_before_cast(_s_spell_cast_info); + ad->get_aura()->son_before_cast(ad, _s_spell_cast_info); } emit_signal("scast_interrupted", _s_spell_cast_info); @@ -1595,35 +1879,49 @@ void Entity::adds_cooldown(int spell_id, float value) { cd->set_remaining(value); emit_signal("scooldown_added", cd); - addc_cooldown(spell_id, value); + + SEND_RPC(rpc("addc_cooldown", spell_id, value), addc_cooldown(spell_id, value)); + return; } Ref cd; cd.instance(); + + cd->set_spell_id(spell_id); + cd->set_remaining(value); _s_cooldown_map.set(spell_id, cd); _s_cooldowns.push_back(cd); + son_cooldown_added(cd); + emit_signal("scooldown_added", cd); SEND_RPC(rpc("addc_cooldown", spell_id, value), addc_cooldown(spell_id, value)); } void Entity::removes_cooldown(int spell_id) { + Ref cd; + if (_s_cooldown_map.has(spell_id)) { _s_cooldown_map.erase(spell_id); } - + for (int i = 0; i < _s_cooldowns.size(); ++i) { if (_s_cooldowns.get(i)->get_spell_id() == spell_id) { + cd = _s_cooldowns.get(i); + _s_cooldowns.remove(i); - return; + + break; } } + + son_cooldown_removed(cd); emit_signal("scooldown_removed", spell_id); - SEND_RPC(rpc("removes_cooldown", spell_id), removes_cooldown(spell_id)); + SEND_RPC(rpc("removec_cooldown", spell_id), removec_cooldown(spell_id)); } Ref Entity::gets_cooldown(int spell_id) { if (!_s_cooldown_map.has(spell_id)) { @@ -1657,22 +1955,32 @@ void Entity::addc_cooldown(int spell_id, float value) { Ref cd; cd.instance(); + cd->set_spell_id(spell_id); + cd->set_remaining(value); + _c_cooldown_map.set(spell_id, cd); _c_cooldowns.push_back(cd); + + con_cooldown_added(cd); emit_signal("ccooldown_added", cd); } void Entity::removec_cooldown(int spell_id) { + Ref cd; + if (_c_cooldown_map.has(spell_id)) { _c_cooldown_map.erase(spell_id); } for (int i = 0; i < _c_cooldowns.size(); ++i) { if (_c_cooldowns.get(i)->get_spell_id() == spell_id) { + cd = _c_cooldowns.get(i); _c_cooldowns.remove(i); - return; + break; } } + + con_cooldown_removed(cd); emit_signal("ccooldown_removed", spell_id); } @@ -1693,65 +2001,72 @@ int Entity::getc_cooldown_count() { } //Category Cooldowns -Vector > *Entity::gets_category_cooldowns() { - return &_s_category_cooldowns; +Vector > Entity::gets_category_cooldowns() { + return _s_category_cooldowns; } -Vector > *Entity::getc_category_cooldowns() { - return &_c_category_cooldowns; +Vector > Entity::getc_category_cooldowns() { + return _c_category_cooldowns; } -HashMap > *Entity::gets_category_cooldown_map() { - return &_s_category_cooldown_map; -} -HashMap > *Entity::getc_category_cooldown_map() { - return &_c_category_cooldown_map; -} - -bool Entity::hass_category_cooldown(int spell_id) { - return _s_category_cooldown_map.has(spell_id); +bool Entity::hass_category_cooldown(int category_id) { + return (category_id & _s_active_category_cooldowns) > 0; } void Entity::adds_category_cooldown(int category_id, float value) { - if (_s_category_cooldown_map.has(category_id)) { - Ref cc = _s_category_cooldown_map.get(category_id); + if ((category_id & _s_active_category_cooldowns)) { + for (int i = 0; i < _s_category_cooldowns.size(); ++i) { + Ref cc = _s_category_cooldowns.get(i); - cc->set_remaining(value); + if (cc->get_category_id() == category_id) { + cc->set_remaining(value); - emit_signal("scategory_cooldown_added", cc); - return; + emit_signal("scategory_cooldown_added", cc); + return; + } + } } Ref cc; cc.instance(); + + cc->set_category_id(category_id); + cc->set_remaining(value); - _s_category_cooldown_map.set(category_id, cc); _s_category_cooldowns.push_back(cc); + _s_active_category_cooldowns |= category_id; + emit_signal("scategory_cooldown_added", cc); - SEND_RPC(rpc("adds_category_cooldown", category_id, value), adds_category_cooldown(category_id, value)); + SEND_RPC(rpc("addc_category_cooldown", category_id, value), addc_category_cooldown(category_id, value)); } void Entity::removes_category_cooldown(int category_id) { - if (_s_category_cooldown_map.has(category_id)) { - _s_category_cooldown_map.erase(category_id); - } - for (int i = 0; i < _s_category_cooldowns.size(); ++i) { if (_s_category_cooldowns.get(i)->get_category_id() == category_id) { _s_category_cooldowns.remove(i); - return; + break; } } + + _s_active_category_cooldowns ^= category_id; emit_signal("scategory_cooldown_removed", category_id); - SEND_RPC(rpc("removes_category_cooldown", category_id), removes_category_cooldown(category_id)); + SEND_RPC(rpc("removec_category_cooldown", category_id), removec_category_cooldown(category_id)); } Ref Entity::gets_category_cooldown(int category_id) { - if (!_s_category_cooldown_map.has(category_id)) { - return Ref(); - } + ERR_FAIL_COND_V(!(category_id & _s_active_category_cooldowns), Ref()); + + Ref cc; + + for (int i = 0; i < _s_category_cooldowns.size(); ++i) { + cc = _s_category_cooldowns.get(i); - return _s_category_cooldown_map.get(category_id); + if (cc->get_category_id() == category_id) { + return cc; + } + } + + return cc; } Ref Entity::gets_category_cooldown_index(int index) { ERR_FAIL_INDEX_V(index, _s_category_cooldowns.size(), Ref()); @@ -1763,46 +2078,60 @@ int Entity::gets_category_cooldown_count() { } bool Entity::hasc_category_cooldown(int category_id) { - return _c_category_cooldown_map.has(category_id); + return (category_id & _c_active_category_cooldowns) > 0; } void Entity::addc_category_cooldown(int category_id, float value) { - if (_c_category_cooldown_map.has(category_id)) { - Ref cc = _c_category_cooldown_map.get(category_id); + if (category_id & _c_active_category_cooldowns) { + for (int i = 0; i < _c_category_cooldowns.size(); ++i) { + Ref cc = _c_category_cooldowns.get(i); - cc->set_remaining(value); + if (cc->get_category_id() == category_id) { + cc->set_remaining(value); - emit_signal("ccategory_cooldown_added", cc); - return; + emit_signal("ccategory_cooldown_added", cc); + return; + } + } } - + Ref cc; cc.instance(); + + cc->set_category_id(category_id); + cc->set_remaining(value); - _c_category_cooldown_map.set(category_id, cc); _c_category_cooldowns.push_back(cc); + _c_active_category_cooldowns |= category_id; + emit_signal("ccategory_cooldown_added", cc); } void Entity::removec_category_cooldown(int category_id) { - if (_c_category_cooldown_map.has(category_id)) { - _c_category_cooldown_map.erase(category_id); - } - for (int i = 0; i < _c_category_cooldowns.size(); ++i) { if (_c_category_cooldowns.get(i)->get_category_id() == category_id) { _c_category_cooldowns.remove(i); return; } } + + _c_active_category_cooldowns ^= category_id; emit_signal("ccategory_cooldown_removed", category_id); } Ref Entity::getc_category_cooldown(int category_id) { - if (!_c_category_cooldown_map.has(category_id)) { - return Ref(); - } + ERR_FAIL_COND_V(!(category_id & _c_active_category_cooldowns), Ref()); + + Ref cc; + + for (int i = 0; i < _c_category_cooldowns.size(); ++i) { + cc = _c_category_cooldowns.get(i); - return _c_category_cooldown_map.get(category_id); + if (cc->get_category_id() == category_id) { + return cc; + } + } + + return cc; } Ref Entity::getc_category_cooldown_index(int index) { ERR_FAIL_INDEX_V(index, _c_category_cooldowns.size(), Ref()); @@ -2300,14 +2629,6 @@ void Entity::update(float delta) { } } -String Entity::request_spell_name(int spellId) { - return ""; -} - -String Entity::request_spell_description(int spellId, int level) { - return ""; -} - String Entity::random_name() { /*/ String text = new String(l1->GetData(UnityEngine::Random::Range(0, l1->Length))); @@ -2348,39 +2669,7 @@ void Entity::_notification(int p_what) { } } -void Entity::_bind_methods() { - BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); - - BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - - BIND_VMETHOD(MethodInfo("_son_before_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_son_after_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - - BIND_VMETHOD(MethodInfo("_son_death")); - - BIND_VMETHOD(MethodInfo("_con_aura_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - - BIND_VMETHOD(MethodInfo("_con_death")); - - BIND_VMETHOD(MethodInfo("_moved")); - +void Entity::_bind_methods() { //Signals ADD_SIGNAL(MethodInfo("starget_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); ADD_SIGNAL(MethodInfo("ctarget_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); @@ -2389,11 +2678,12 @@ void Entity::_bind_methods() { ADD_SIGNAL(MethodInfo("con_damage_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); ADD_SIGNAL(MethodInfo("con_damage_dealt", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + ADD_SIGNAL(MethodInfo("con_dealt_damage", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); ADD_SIGNAL(MethodInfo("son_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); ADD_SIGNAL(MethodInfo("con_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); - ADD_SIGNAL(MethodInfo("con_heal_dealt", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + ADD_SIGNAL(MethodInfo("con_dealt_heal", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); ADD_SIGNAL(MethodInfo("scharacter_class_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); ADD_SIGNAL(MethodInfo("ccharacter_class_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); @@ -2431,6 +2721,30 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("cdie"), &Entity::cdie); //EventHandlers + BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_son_cast_finished_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + + BIND_VMETHOD(MethodInfo("_son_hit", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_damage", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_receive", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_damage", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_son_damage_dealt", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_heal", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_receive", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_dealt_heal", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_son_heal_dealt", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + + BIND_VMETHOD(MethodInfo("_son_before_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_son_after_aura_applied", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + BIND_VMETHOD(MethodInfo("_son_death")); + 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); @@ -2455,12 +2769,49 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("son_death"), &Entity::son_death); //Clientside EventHandlers + BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_state_changed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_cast_finished", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + BIND_VMETHOD(MethodInfo("_con_spell_cast_success", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); + + BIND_VMETHOD(MethodInfo("_con_death")); + + BIND_VMETHOD(MethodInfo("con_cooldown_added", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("con_cooldown_removed", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + BIND_VMETHOD(MethodInfo("con_category_cooldown_added", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + BIND_VMETHOD(MethodInfo("con_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + + BIND_VMETHOD(MethodInfo("_con_aura_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + BIND_VMETHOD(MethodInfo("_con_damage_dealt", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_con_dealt_damage", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo"))); + BIND_VMETHOD(MethodInfo("_con_heal_dealt", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + BIND_VMETHOD(MethodInfo("_con_dealt_heal", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo"))); + ClassDB::bind_method(D_METHOD("con_cast_failed", "info"), &Entity::con_cast_failed); ClassDB::bind_method(D_METHOD("con_cast_started", "info"), &Entity::con_cast_started); ClassDB::bind_method(D_METHOD("con_cast_state_changed", "info"), &Entity::con_cast_state_changed); ClassDB::bind_method(D_METHOD("con_cast_finished", "info"), &Entity::con_cast_finished); ClassDB::bind_method(D_METHOD("con_spell_cast_success", "info"), &Entity::con_spell_cast_success); - ClassDB::bind_method(D_METHOD("con_death"), &Entity::con_death); + + ClassDB::bind_method(D_METHOD("con_death"), &Entity::con_death); + + ClassDB::bind_method(D_METHOD("con_cooldown_added", "cooldown"), &Entity::con_cooldown_added); + ClassDB::bind_method(D_METHOD("con_cooldown_removed", "cooldown"), &Entity::con_cooldown_removed); + ClassDB::bind_method(D_METHOD("con_category_cooldown_added", "category_cooldown"), &Entity::con_category_cooldown_added); + ClassDB::bind_method(D_METHOD("con_category_cooldown_removed", "category_cooldown"), &Entity::con_category_cooldown_removed); + + ClassDB::bind_method(D_METHOD("con_aura_added", "data"), &Entity::con_aura_added); + ClassDB::bind_method(D_METHOD("con_aura_removed", "data"), &Entity::con_aura_removed); + ClassDB::bind_method(D_METHOD("con_aura_refresh", "data"), &Entity::con_aura_refresh); + + ClassDB::bind_method(D_METHOD("con_damage_dealt", "info"), &Entity::con_damage_dealt); + ClassDB::bind_method(D_METHOD("con_dealt_damage", "info"), &Entity::con_dealt_damage); + ClassDB::bind_method(D_METHOD("con_heal_dealt", "info"), &Entity::con_heal_dealt); + ClassDB::bind_method(D_METHOD("con_dealt_heal", "info"), &Entity::con_dealt_heal); //Modifiers/Requesters ClassDB::bind_method(D_METHOD("sapply_passives_damage_receive", "data"), &Entity::sapply_passives_damage_receive); @@ -2503,12 +2854,8 @@ void Entity::_bind_methods() { //Hooks ClassDB::bind_method(D_METHOD("moved"), &Entity::moved); - - //Clientside EventHandlers - ClassDB::bind_method(D_METHOD("creceive_damage_taken", "data"), &Entity::creceive_damage_taken); - ClassDB::bind_method(D_METHOD("creceiveon_damage_dealt", "data"), &Entity::creceiveon_damage_dealt); - ClassDB::bind_method(D_METHOD("creceive_heal_taken", "data"), &Entity::creceive_heal_taken); - ClassDB::bind_method(D_METHOD("creceiveon_heal_dealt", "data"), &Entity::creceiveon_heal_dealt); + + BIND_VMETHOD(MethodInfo("_moved")); //Properties ClassDB::bind_method(D_METHOD("get_character_skeleton_path"), &Entity::get_character_skeleton_path); @@ -2650,6 +2997,8 @@ void Entity::_bind_methods() { //Cooldowns ADD_SIGNAL(MethodInfo("scooldown_added", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + ADD_SIGNAL(MethodInfo("scooldown_removed", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "Cooldown"))); + ADD_SIGNAL(MethodInfo("ccooldown_added", PropertyInfo(Variant::INT, "spell_id"))); ADD_SIGNAL(MethodInfo("ccooldown_removed", PropertyInfo(Variant::INT, "spell_id"))); ClassDB::bind_method(D_METHOD("hass_cooldown", "spell_id"), &Entity::hass_cooldown); @@ -2668,7 +3017,9 @@ void Entity::_bind_methods() { //Category Cooldowns ADD_SIGNAL(MethodInfo("scategory_cooldown_added", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); - ADD_SIGNAL(MethodInfo("ccategory_cooldown_removed", PropertyInfo(Variant::INT, "category_id"))); + ADD_SIGNAL(MethodInfo("scategory_cooldown_removed", PropertyInfo(Variant::OBJECT, "cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown"))); + ADD_SIGNAL(MethodInfo("ccategory_cooldown_added", PropertyInfo(Variant::INT, "category_id"))); + ADD_SIGNAL(MethodInfo("ccategory_cooldown_removed", PropertyInfo(Variant::INT, "category_id"))); ClassDB::bind_method(D_METHOD("hass_category_cooldown", "category_id"), &Entity::hass_category_cooldown); ClassDB::bind_method(D_METHOD("adds_category_cooldown", "category_id", "value"), &Entity::adds_category_cooldown); @@ -2716,3 +3067,4 @@ void Entity::_bind_methods() { BIND_ENUM_CONSTANT(BACKPACK_SIZE); BIND_ENUM_CONSTANT(MAX_BAG_SLOTS); } + diff --git a/entities/entity.h b/entities/entity.h index c07b3b8..39fed67 100644 --- a/entities/entity.h +++ b/entities/entity.h @@ -300,16 +300,16 @@ public: void son_before_aura_applied(Ref data); void son_after_aura_applied(Ref data); - void son_hit(Ref data); - void son_before_damage(Ref data); - void son_damage_receive(Ref data); - void son_dealt_damage(Ref data); - void son_damage_dealt(Ref data); + void son_hit(Ref info); + void son_before_damage(Ref info); + void son_damage_receive(Ref info); + void son_dealt_damage(Ref info); + void son_damage_dealt(Ref info); - void son_before_heal(Ref data); - void son_heal_receive(Ref data); - void son_dealt_heal(Ref data); - void son_heal_dealt(Ref data); + void son_before_heal(Ref info); + void son_heal_receive(Ref info); + void son_dealt_heal(Ref info); + void son_heal_dealt(Ref info); void son_before_cast(Ref info); void son_before_cast_target(Ref info); @@ -320,37 +320,53 @@ public: void son_death(); + void son_cooldown_added(Ref cooldown); + void son_cooldown_removed(Ref cooldown); + + void son_category_cooldown_added(Ref category_cooldown); + void son_category_cooldown_removed(Ref category_cooldown); + //Clientside EventHandlers void con_cast_failed(Ref info); void con_cast_started(Ref info); void con_cast_state_changed(Ref info); void con_cast_finished(Ref info); void con_spell_cast_success(Ref info); + void con_death(); + + void con_cooldown_added(Ref cooldown); + void con_cooldown_removed(Ref cooldown); + void con_category_cooldown_added(Ref category_cooldown); + void con_category_cooldown_removed(Ref category_cooldown); - //Clientside Event Handlers void con_aura_added(Ref data); void con_aura_removed(Ref data); void con_aura_refresh(Ref data); + + void con_damage_dealt(Ref info); + void con_dealt_damage(Ref info); + void con_heal_dealt(Ref info); + void con_dealt_heal(Ref info); //Modifiers/Requesters - void sapply_passives_damage_receive(Ref data); - void sapply_passives_damage_deal(Ref data); + void sapply_passives_damage_receive(Ref info); + void sapply_passives_damage_deal(Ref info); - void sapply_passives_heal_receive(Ref data); - void sapply_passives_heal_deal(Ref data); + void sapply_passives_heal_receive(Ref info); + void sapply_passives_heal_deal(Ref info); //Spell operations void scast_spell(int spell_id); void crequest_spell_cast(int spell_id); //Damage Operations - void stake_damage(Ref data); - void sdeal_damage_to(Ref data); + void stake_damage(Ref info); + void sdeal_damage_to(Ref info); //Heal Operations - void stake_heal(Ref data); - void sdeal_heal_to(Ref data); + void stake_heal(Ref info); + void sdeal_heal_to(Ref info); //Aura Manipulation void sadd_aura(Ref aura); @@ -380,25 +396,14 @@ public: //Update void update_auras(float delta); - - //Clientside hooks - void creceive_damage_taken(Ref data); - void creceiveon_damage_dealt(Ref data); - void creceive_heal_taken(Ref data); - void creceiveon_heal_dealt(Ref data); - //Old, hook loading update when needed - void setup_on_player_moves(Entity *bopmccc, Vector *sspells); //load -> remove, just store spellIds - //Old stuff, remove or update void resurrect(); void creceive_resurrect(); - void creceive_died(); void creceive_mana_changed(int amount); bool gets_is_dead(); bool getc_is_dead(); - //// Casting System //// Ref gets_spell_cast_info(); @@ -441,12 +446,9 @@ public: int getc_cooldown_count(); //Category Cooldowns - Vector > *gets_category_cooldowns(); - Vector > *getc_category_cooldowns(); - - HashMap > * gets_category_cooldown_map(); - HashMap > * getc_category_cooldown_map(); - + Vector > gets_category_cooldowns(); + Vector > getc_category_cooldowns(); + bool hass_category_cooldown(int category_id); void adds_category_cooldown(int category_id, float value); void removes_category_cooldown(int category_id); @@ -519,9 +521,6 @@ public: String random_name(); - String request_spell_name(int spellId); - String request_spell_description(int spellId, int level); - protected: static void _bind_methods(); virtual void _notification(int p_what); @@ -650,9 +649,9 @@ private: Vector > _s_category_cooldowns; Vector > _c_category_cooldowns; - - HashMap > _s_category_cooldown_map; - HashMap > _c_category_cooldown_map; + + int _s_active_category_cooldowns; + int _c_active_category_cooldowns; //// targetComponent //// @@ -674,4 +673,3 @@ private: VARIANT_ENUM_CAST(Entity::InventorySizes); #endif - diff --git a/entity_enums.cpp b/entity_enums.cpp index a441646..dda3f7c 100644 --- a/entity_enums.cpp +++ b/entity_enums.cpp @@ -1,8 +1,8 @@ #include "entity_enums.h" -const String EntityEnums::BINDING_STRING_PLAYER_RESOURCE_TYPES = "None, Rage, Mana, Energy, Time Anomaly"; -const String EntityEnums::BINDING_STRING_ENTITY_TYPES = "None, Player, AI, Mob"; -const String EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES = "None, Stun, Root, Frozen, Silenced, Disoriented, Feared, Burning, Cold, Cursed, Pacified"; -const String EntityEnums::BINDING_STRING_CHARCATER_SKELETON_POINTS = "Root, Pelvis, Spine, Spine 1, Spine 2, Neck, Head, Left Clavicle, Left upper Arm, Left Forearm, Left Hand, Left Thumb Base, Left Thumb End, Left Fingers Base, Left Fingers End, Right Clavicle, Right upper Arm, Right Forearm, Right Hand, Right Thumb Base, Right Thumb End, Right Fingers Base, Right Fingers End, Left Thigh, Left Calf, Left Foot, Right Thigh, Right Calf, Right Foot"; +const String EntityEnums::BINDING_STRING_PLAYER_RESOURCE_TYPES = "None,Rage,Mana,Energy,Time Anomaly"; +const String EntityEnums::BINDING_STRING_ENTITY_TYPES = "None,Player,AI,Mob"; +const String EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES = "None,Stun,Root,Frozen,Silenced,Disoriented,Feared,Burning,Cold,Cursed,Pacified"; +const String EntityEnums::BINDING_STRING_CHARCATER_SKELETON_POINTS = "Root,Pelvis,Spine,Spine 1,Spine 2,Neck,Head,Left Clavicle,Left upper Arm,Left Forearm,Left Hand,Left Thumb Base,Left Thumb End,Left Fingers Base,Left Fingers End,Right Clavicle,Right upper Arm,Right Forearm,Right Hand,Right Thumb Base,Right Thumb End,Right Fingers Base,Right Fingers End,Left Thigh,Left Calf,Left Foot,Right Thigh,Right Calf,Right Foot"; const String EntityEnums::BINDING_STRING_AI_STATES = "Off,Rest,Patrol,Follow Path,Regenerate,Attack"; diff --git a/infos/aura_infos.cpp b/infos/aura_infos.cpp index 553b5f9..9ac5f90 100644 --- a/infos/aura_infos.cpp +++ b/infos/aura_infos.cpp @@ -6,7 +6,11 @@ Entity *AuraApplyInfo::get_caster() const { return _caster; } -void AuraApplyInfo::set_caster(Node *caster) { +void AuraApplyInfo::set_caster(Entity *value) { + _caster = value; +} + +void AuraApplyInfo::set_caster_bind(Node *caster) { if (!caster) { return; } @@ -21,10 +25,14 @@ void AuraApplyInfo::set_caster(Node *caster) { } Entity *AuraApplyInfo::get_target() const { - return _caster; + return _target; } -void AuraApplyInfo::set_target(Node *caster) { +void AuraApplyInfo::set_target(Entity *value) { + _target = value; +} + +void AuraApplyInfo::set_target_bind(Node *caster) { if (!caster) { return; } @@ -35,7 +43,7 @@ void AuraApplyInfo::set_target(Node *caster) { return; } - _caster = e; + _target = e; } @@ -78,11 +86,11 @@ AuraApplyInfo::AuraApplyInfo(Entity *caster, Entity *target, float spell_scale) void AuraApplyInfo::_bind_methods() { ClassDB::bind_method(D_METHOD("get_caster"), &AuraApplyInfo::get_caster); - ClassDB::bind_method(D_METHOD("set_caster", "caster"), &AuraApplyInfo::set_caster); + ClassDB::bind_method(D_METHOD("set_caster", "caster"), &AuraApplyInfo::set_caster_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "caster", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_caster", "get_caster"); ClassDB::bind_method(D_METHOD("get_target"), &AuraApplyInfo::get_target); - ClassDB::bind_method(D_METHOD("set_target", "target"), &AuraApplyInfo::set_target); + ClassDB::bind_method(D_METHOD("set_target", "target"), &AuraApplyInfo::set_target_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "target", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_target", "get_target"); ClassDB::bind_method(D_METHOD("get_spell_scale"), &AuraApplyInfo::get_spell_scale); diff --git a/infos/aura_infos.h b/infos/aura_infos.h index d71aa78..8b3a005 100644 --- a/infos/aura_infos.h +++ b/infos/aura_infos.h @@ -12,11 +12,12 @@ class AuraApplyInfo : public Reference { public: Entity *get_caster() const; - void set_caster(Node *caster); + void set_caster(Entity *caster); + void set_caster_bind(Node *caster); Entity *get_target() const; - void set_target(Node *caster); - + void set_target(Entity *caster); + void set_target_bind(Node *caster); float get_spell_scale() const; void set_spell_scale(float value); diff --git a/infos/spell_cast_info.cpp b/infos/spell_cast_info.cpp index 6b17ebe..b985a7c 100644 --- a/infos/spell_cast_info.cpp +++ b/infos/spell_cast_info.cpp @@ -8,7 +8,11 @@ Entity *SpellCastInfo::get_caster() const { return _caster; } -void SpellCastInfo::set_caster(Node *caster) { +void SpellCastInfo::set_caster(Entity *value) { + _caster = value; +} + +void SpellCastInfo::set_caster_bind(Node *caster) { if (!caster) { return; } @@ -26,7 +30,11 @@ Entity *SpellCastInfo::get_target() const { return _target; } -void SpellCastInfo::set_target(Node *target) { +void SpellCastInfo::set_target(Entity *value) { + _target = value; +} + +void SpellCastInfo::set_target_bind(Node *target) { if (!target) { return; } @@ -130,11 +138,11 @@ SpellCastInfo::~SpellCastInfo() { void SpellCastInfo::_bind_methods() { ClassDB::bind_method(D_METHOD("get_caster"), &SpellCastInfo::get_caster); - ClassDB::bind_method(D_METHOD("set_caster", "caster"), &SpellCastInfo::set_caster); + ClassDB::bind_method(D_METHOD("set_caster", "caster"), &SpellCastInfo::set_caster_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "caster", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_caster", "get_caster"); ClassDB::bind_method(D_METHOD("get_target"), &SpellCastInfo::get_target); - ClassDB::bind_method(D_METHOD("set_target", "caster"), &SpellCastInfo::set_target); + ClassDB::bind_method(D_METHOD("set_target", "caster"), &SpellCastInfo::set_target_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "target", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_target", "get_target"); ClassDB::bind_method(D_METHOD("get_has_cast_time"), &SpellCastInfo::get_has_cast_time); diff --git a/infos/spell_cast_info.h b/infos/spell_cast_info.h index 423fe56..9641ac4 100644 --- a/infos/spell_cast_info.h +++ b/infos/spell_cast_info.h @@ -12,10 +12,12 @@ class SpellCastInfo : public Reference { public: Entity *get_caster() const; - void set_caster(Node *caster); + void set_caster(Entity *caster); + void set_caster_bind(Node *caster); Entity *get_target() const; - void set_target(Node *caster); + void set_target(Entity *caster); + void set_target_bind(Node *caster); bool get_has_cast_time() const; void set_has_cast_time(bool value); diff --git a/item_enums.cpp b/item_enums.cpp index f51850c..a02d183 100644 --- a/item_enums.cpp +++ b/item_enums.cpp @@ -1,7 +1,7 @@ #include "item_enums.h" -const String ItemEnums::BINDING_STRING_RARITY = "None, Common, Uncommon, Superior, Heroic, Mythic, Artifact, Class Neck"; -const String ItemEnums::BINDING_STRING_ITEM_TYPE = "None, Weapon, Craft, Currency, Item"; -const String ItemEnums::BINDING_STRING_ITEM_SUB_TYPE = "None, Two Hand, One Hand, Left Hand, Right Hand"; -const String ItemEnums::BINDING_STRING_ITEM_SUB_SUB_TYPE = "None, Sword, Bow, Axe"; +const String ItemEnums::BINDING_STRING_RARITY = "None,Common,Uncommon,Superior,Heroic,Mythic,Artifact,Class Neck"; +const String ItemEnums::BINDING_STRING_ITEM_TYPE = "None,Weapon,Craft,Currency,Item"; +const String ItemEnums::BINDING_STRING_ITEM_SUB_TYPE = "None,Two Hand,One Hand,Left Hand,Right Hand"; +const String ItemEnums::BINDING_STRING_ITEM_SUB_SUB_TYPE = "None,Sword,Bow,Axe"; diff --git a/pipelines/spell_damage_info.cpp b/pipelines/spell_damage_info.cpp index 7a19617..5be872b 100644 --- a/pipelines/spell_damage_info.cpp +++ b/pipelines/spell_damage_info.cpp @@ -40,7 +40,11 @@ Entity *SpellDamageInfo::get_dealer() { return _dealer; } -void SpellDamageInfo::set_dealer(Node *value) { +void SpellDamageInfo::set_dealer(Entity *value) { + _dealer = value; +} + +void SpellDamageInfo::set_dealer_bind(Node *value) { if (!value) { return; } @@ -58,7 +62,11 @@ Entity *SpellDamageInfo::get_receiver() { return _receiver; } -void SpellDamageInfo::set_receiver(Node *value) { +void SpellDamageInfo::set_receiver(Entity *value) { + _receiver = value; +} + +void SpellDamageInfo::set_receiver_bind(Node *value) { if (!value) { return; } @@ -161,11 +169,11 @@ void SpellDamageInfo::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::INT, "spell_type", PROPERTY_HINT_ENUM, "None, Melee, Magic"), "set_spell_type", "get_spell_type"); ClassDB::bind_method(D_METHOD("get_dealer"), &SpellDamageInfo::get_dealer); - ClassDB::bind_method(D_METHOD("set_dealer", "value"), &SpellDamageInfo::set_dealer); + ClassDB::bind_method(D_METHOD("set_dealer", "value"), &SpellDamageInfo::set_dealer_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "dealer", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_dealer", "get_dealer"); ClassDB::bind_method(D_METHOD("get_receiver"), &SpellDamageInfo::get_receiver); - ClassDB::bind_method(D_METHOD("set_receiver", "value"), &SpellDamageInfo::set_receiver); + ClassDB::bind_method(D_METHOD("set_receiver", "value"), &SpellDamageInfo::set_receiver_bind); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "receiver", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_receiver", "get_receiver"); ClassDB::bind_method(D_METHOD("get_damage_source"), &SpellDamageInfo::get_damage_source); diff --git a/pipelines/spell_damage_info.h b/pipelines/spell_damage_info.h index 083cbac..54ac95d 100644 --- a/pipelines/spell_damage_info.h +++ b/pipelines/spell_damage_info.h @@ -36,10 +36,12 @@ public: void set_spell_type(SpellEnums::SpellType value); Entity *get_dealer(); - void set_dealer(Node *value); + void set_dealer(Entity *value); + void set_dealer_bind(Node *value); Entity *get_receiver(); - void set_receiver(Node *value); + void set_receiver(Entity *value); + void set_receiver_bind(Node *value); Ref get_damage_source(); void set_damage_source(Ref value); diff --git a/spell_enums.cpp b/spell_enums.cpp index 6e54358..788f6dc 100644 --- a/spell_enums.cpp +++ b/spell_enums.cpp @@ -1,7 +1,7 @@ #include "spell_enums.h" -const String SpellEnums::BINDING_STRING_SPELL_TYPES = "None, Melee, Holy, Shadow, Nature, Fire, Frost, Lightning, Chaos"; -const String SpellEnums::BINDING_STRING_DIMINISHING_RETURN_CATEGORIES = "None, Root, Stun"; -const String SpellEnums::BINDING_STRING_TRIGGER_EVENTS = "None, S On Before Damage, S On Damage Receive, S On Hit, S On Damage Dealt, S Aura Remove, S Aura Dispell, S On Before Aura Applied, S On After Aura Applied, C On Aura Added, C On Aura Removed, C On Aura Refreshed"; -const String SpellEnums::BINDING_STRING_DAMAGE_TYPES = "None, Melee, Holy, Shadow, Nature, Fire, Frost, Lightning, Chaos"; -const String SpellEnums::BINDING_STRING_AURA_TYPES = "None, Magic, Poison, Physical, Curse, Bleed"; +const String SpellEnums::BINDING_STRING_SPELL_TYPES = "Melee,Holy,Shadow,Nature,Fire,Frost,Lightning,Chaos"; +const String SpellEnums::BINDING_STRING_DIMINISHING_RETURN_CATEGORIES = "None,Root,Stun"; +const String SpellEnums::BINDING_STRING_TRIGGER_EVENTS = "None,S On Before Damage,S On Damage Receive,S On Hit,S On Damage Dealt,S Aura Remove,S Aura Dispell,S On Before Aura Applied,S On After Aura Applied,C On Aura Added,C On Aura Removed,C On Aura Refreshed"; +const String SpellEnums::BINDING_STRING_DAMAGE_TYPES = "Melee,Holy,Shadow,Nature,Fire,Frost,Lightning,Chaos"; +const String SpellEnums::BINDING_STRING_AURA_TYPES = "None,Magic,Poison,Physical,Curse,Bleed"; diff --git a/utility/category_cooldown.cpp b/utility/category_cooldown.cpp index 9964b4b..60b1d39 100644 --- a/utility/category_cooldown.cpp +++ b/utility/category_cooldown.cpp @@ -1,27 +1,27 @@ #include "category_cooldown.h" -int CategoryCooldown::get_category_id() +int CategoryCooldown::get_category_id() const { return _category_id; } -void CategoryCooldown::set_category_id(int value) +void CategoryCooldown::set_category_id(const int value) { _category_id = value; } -int CategoryCooldown::get_remaining() +float CategoryCooldown::get_remaining() const { return _remaining; } -void CategoryCooldown::set_remaining(int value) +void CategoryCooldown::set_remaining(const float value) { _remaining = value; } -bool CategoryCooldown::update(float delta) { +bool CategoryCooldown::update(const float delta) { _remaining -= delta; if (_remaining <= 0) { @@ -41,7 +41,7 @@ void CategoryCooldown::_bind_methods() { ClassDB::bind_method(D_METHOD("get_remaining"), &CategoryCooldown::get_remaining); ClassDB::bind_method(D_METHOD("set_remaining", "value"), &CategoryCooldown::set_remaining); - ADD_PROPERTY(PropertyInfo(Variant::INT, "remaining"), "set_remaining", "get_remaining"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "remaining"), "set_remaining", "get_remaining"); ClassDB::bind_method(D_METHOD("update", "delta"), &CategoryCooldown::update); } diff --git a/utility/category_cooldown.h b/utility/category_cooldown.h index af689fe..f188efb 100644 --- a/utility/category_cooldown.h +++ b/utility/category_cooldown.h @@ -7,20 +7,20 @@ class CategoryCooldown : public Reference { GDCLASS(CategoryCooldown, Reference); public: - int get_category_id(); - void set_category_id(int value); + int get_category_id() const; + void set_category_id(const int value); - int get_remaining(); - void set_remaining(int value); + float get_remaining() const; + void set_remaining(const float value); - bool update(float delta); + bool update(const float delta); protected: static void _bind_methods(); private: int _category_id; - int _remaining; + float _remaining; }; #endif diff --git a/utility/cooldown.cpp b/utility/cooldown.cpp index 9553f05..0683a93 100644 --- a/utility/cooldown.cpp +++ b/utility/cooldown.cpp @@ -1,27 +1,27 @@ #include "cooldown.h" -int Cooldown::get_spell_id() -{ +int Cooldown::get_spell_id() const +{ return _spell_id; } -void Cooldown::set_spell_id(int value) +void Cooldown::set_spell_id(const int value) { _spell_id = value; } -int Cooldown::get_remaining() +float Cooldown::get_remaining() const { return _remaining; } -void Cooldown::set_remaining(int value) +void Cooldown::set_remaining(const float value) { _remaining = value; } -bool Cooldown::update(float delta) { +bool Cooldown::update(const float delta) { _remaining -= delta; if (_remaining <= 0) { @@ -41,7 +41,7 @@ void Cooldown::_bind_methods() { ClassDB::bind_method(D_METHOD("get_remaining"), &Cooldown::get_remaining); ClassDB::bind_method(D_METHOD("set_remaining", "value"), &Cooldown::set_remaining); - ADD_PROPERTY(PropertyInfo(Variant::INT, "remaining"), "set_remaining", "get_remaining"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "remaining"), "set_remaining", "get_remaining"); ClassDB::bind_method(D_METHOD("update", "delta"), &Cooldown::update); } diff --git a/utility/cooldown.h b/utility/cooldown.h index 1c98c9c..2f4e182 100644 --- a/utility/cooldown.h +++ b/utility/cooldown.h @@ -7,20 +7,20 @@ class Cooldown : public Reference { GDCLASS(Cooldown, Reference); public: - int get_spell_id(); - void set_spell_id(int value); + int get_spell_id() const; + void set_spell_id(const int value); - int get_remaining(); - void set_remaining(int value); + float get_remaining() const; + void set_remaining(const float value); - bool update(float delta); + bool update(const float delta); protected: static void _bind_methods(); private: int _spell_id; - int _remaining; + float _remaining; }; #endif