From 4f3c21a0cff4338c9e59394d4786c5480000c8ff Mon Sep 17 00:00:00 2001 From: Relintai Date: Sun, 4 Aug 2019 19:13:00 +0200 Subject: [PATCH] Added the aura callbacks into the CharacterClass, and Entity, so they can be scripted via GDScript. Entity calls everything as needed. Also added death events, and callbacks. --- data/aura.cpp | 50 ++++--- data/aura.h | 11 +- data/character_class.cpp | 232 ++++++++++++++++++++++++++++++ data/character_class.h | 38 +++++ entities/entity.cpp | 294 ++++++++++++++++++++++++++++++++++++--- entities/entity.h | 17 ++- 6 files changed, 594 insertions(+), 48 deletions(-) diff --git a/data/aura.cpp b/data/aura.cpp index 2f3080e..6c81e88 100644 --- a/data/aura.cpp +++ b/data/aura.cpp @@ -600,25 +600,35 @@ void Aura::son_after_aura_applied(Ref data) { call("_son_after_aura_applied", data); } -void Aura::con_added(Ref data) { - ERR_FAIL_COND(!data.is_valid()); - - if (has_method("_con_added")) - call("_con_added", data); +void Aura::son_death(Ref data) { + if (has_method("_son_death")) + call("_son_death", data); } -void Aura::con_removed(Ref data) { +void Aura::con_aura_added(Ref data) { ERR_FAIL_COND(!data.is_valid()); - if (has_method("_con_removed")) - call("_con_removed", data); + if (has_method("_con_aura_added")) + call("_con_aura_added", data); } -void Aura::con_refresh(Ref data) { +void Aura::con_aura_removed(Ref data) { ERR_FAIL_COND(!data.is_valid()); - if (has_method("_con_refresh")) - call("_con_refresh", data); + if (has_method("_con_aura_removed")) + call("_con_aura_removed", data); +} + +void Aura::con_aura_refresh(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_refresh")) + call("_con_aura_refresh", data); +} + +void Aura::con_death(Ref data) { + if (has_method("_con_death")) + call("_con_death", data); } void Aura::setup_aura_data(Ref data, Ref info) { @@ -874,6 +884,8 @@ void Aura::_bind_methods() { ClassDB::bind_method(D_METHOD("son_before_aura_applied", "data"), &Aura::son_before_aura_applied); 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); 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"))); @@ -900,15 +912,19 @@ void Aura::_bind_methods() { 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, "AuraData"))); //Clientside Event Handlers - ClassDB::bind_method(D_METHOD("con_added", "info"), &Aura::con_added); - ClassDB::bind_method(D_METHOD("con_removed", "info"), &Aura::con_removed); - ClassDB::bind_method(D_METHOD("con_refresh", "info"), &Aura::con_refresh); + 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); - BIND_VMETHOD(MethodInfo("_con_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); - BIND_VMETHOD(MethodInfo("_con_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + 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"))); //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 5ab9b4e..4b5adde 100644 --- a/data/aura.h +++ b/data/aura.h @@ -231,12 +231,15 @@ public: void son_before_aura_applied(Ref data); void son_after_aura_applied(Ref data); + + void son_death(Ref data); //Clientside Event Handlers - void con_added(Ref data); - void con_removed(Ref data); - void con_refresh(Ref data); - + void con_aura_added(Ref data); + void con_aura_removed(Ref data); + void con_aura_refresh(Ref data); + void con_death(Ref data); + //Calculations / Queries void setup_aura_data(Ref data, Ref info); diff --git a/data/character_class.cpp b/data/character_class.cpp index 516e696..10cbad2 100644 --- a/data/character_class.cpp +++ b/data/character_class.cpp @@ -149,6 +149,177 @@ void CharacterClass::start_casting(int spell_id, Entity *caster, float spellScal } } + +void CharacterClass::son_before_cast(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_before_cast")) + call("_son_before_cast", info); +} + +void CharacterClass::son_before_cast_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_before_cast_target")) + call("_son_before_cast_target", info); +} + +void CharacterClass::son_cast_finished(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_cast_finished")) + call("_son_cast_finished", info); +} + +void CharacterClass::son_cast_started(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_cast_started")) + call("_son_cast_started", info); +} + +void CharacterClass::son_cast_failed(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_cast_failed")) + call("_son_cast_failed", info); +} + +void CharacterClass::son_cast_finished_target(Ref info) { + ERR_FAIL_COND(!info.is_valid()); + + if (has_method("_son_cast_finished_target")) + call("_son_cast_finished_target", info); +} + +void CharacterClass::son_hit(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_hit")) + call("_son_hit", data); +} + +void CharacterClass::son_before_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_before_damage")) + call("_son_before_damage", data); +} + +void CharacterClass::son_damage_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_damage_receive")) + call("_son_damage_receive", data); +} + +void CharacterClass::son_dealt_damage(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_dealt_damage")) + call("_son_dealt_damage", data); +} + +void CharacterClass::son_damage_dealt(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_damage_dealt")) + call("_son_damage_dealt", data); +} + +void CharacterClass::son_before_heal(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_before_heal")) + call("_son_before_heal", data); +} + +void CharacterClass::son_heal_receive(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_heal_receive")) + call("_son_heal_receive", data); +} + +void CharacterClass::son_dealt_heal(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_dealt_heal")) + call("_son_dealt_heal", data); +} + +void CharacterClass::son_heal_dealt(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_heal_dealt")) + call("_son_heal_dealt", data); +} + +void CharacterClass::son_before_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_before_aura_applied")) + call("_son_before_aura_applied", data); +} + +void CharacterClass::son_after_aura_applied(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_son_after_aura_applied")) + call("_son_after_aura_applied", data); +} + +void CharacterClass::son_death(Entity *entity) { + if (has_method("_son_death")) + call("_son_death", entity); +} + +void CharacterClass::son_death_bind(Node *entity) { + ERR_FAIL_COND(entity == NULL); + + Entity *e = Object::cast_to(entity); + + ERR_FAIL_COND(e == NULL); + + son_death(e); +} + +void CharacterClass::con_aura_added(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_added")) + call("_con_aura_added", data); +} + +void CharacterClass::con_aura_removed(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", data); +} + +void CharacterClass::con_aura_refresh(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_refresh")) + call("_con_aura_refresh", data); +} + +void CharacterClass::con_death(Entity *entity) { + 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::sai_follow(Entity *entity) { ERR_FAIL_COND(entity == NULL); @@ -236,11 +407,72 @@ 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); + ClassDB::bind_method(D_METHOD("son_cast_started", "info"), &CharacterClass::son_cast_started); + ClassDB::bind_method(D_METHOD("son_cast_failed", "info"), &CharacterClass::son_cast_failed); + ClassDB::bind_method(D_METHOD("son_cast_finished", "info"), &CharacterClass::son_cast_finished); + ClassDB::bind_method(D_METHOD("son_cast_finished_target", "info"), &CharacterClass::son_cast_finished_target); + + ClassDB::bind_method(D_METHOD("son_hit", "data"), &CharacterClass::son_hit); + + ClassDB::bind_method(D_METHOD("son_before_damage", "data"), &CharacterClass::son_before_damage); + ClassDB::bind_method(D_METHOD("son_damage_receive", "data"), &CharacterClass::son_damage_receive); + ClassDB::bind_method(D_METHOD("son_dealt_damage", "data"), &CharacterClass::son_dealt_damage); + ClassDB::bind_method(D_METHOD("son_damage_dealt", "data"), &CharacterClass::son_damage_dealt); + + ClassDB::bind_method(D_METHOD("son_before_heal", "data"), &CharacterClass::son_before_heal); + ClassDB::bind_method(D_METHOD("son_heal_receive", "data"), &CharacterClass::son_heal_receive); + ClassDB::bind_method(D_METHOD("son_dealt_heal", "data"), &CharacterClass::son_dealt_heal); + ClassDB::bind_method(D_METHOD("son_heal_dealt", "data"), &CharacterClass::son_heal_dealt); + + ClassDB::bind_method(D_METHOD("son_before_aura_applied", "data"), &CharacterClass::son_before_aura_applied); + 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); + + //Clientside Event Handlers + 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); + ClassDB::bind_method(D_METHOD("sai_follow", "entity"), &CharacterClass::sai_follow_bind); ClassDB::bind_method(D_METHOD("sai_rest", "entity"), &CharacterClass::sai_rest_bind); ClassDB::bind_method(D_METHOD("sai_regenerate", "entity"), &CharacterClass::sai_regenerate_bind); diff --git a/data/character_class.h b/data/character_class.h index 84269d8..cafc7c8 100644 --- a/data/character_class.h +++ b/data/character_class.h @@ -9,6 +9,11 @@ #include "../entity_enums.h" #include "character_spec.h" +#include "../entities/auras/aura_data.h" +#include "../pipelines/spell_damage_info.h" +#include "../pipelines/spell_heal_info.h" +#include "../infos/spell_cast_info.h" + class Aura; class Spell; class Entity; @@ -83,6 +88,39 @@ public: void start_casting(int spell_id, Entity *caster, float spellScale); + void son_before_cast(Ref info); + void son_before_cast_target(Ref info); + void son_cast_finished_target(Ref info); + void son_cast_finished(Ref info); + void son_cast_started(Ref info); + void son_cast_failed(Ref info); + + 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_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_aura_applied(Ref data); + void son_after_aura_applied(Ref data); + + void son_death(Entity *entity); + void son_death_bind(Node *entity); + + //Clientside Event Handlers + 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); + + // AI // void sai_follow(Entity *entity); void sai_rest(Entity *entity); void sai_regenerate(Entity *entity); diff --git a/entities/entity.cpp b/entities/entity.cpp index c088113..65369a6 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -562,6 +562,25 @@ void Entity::set_stat_enum(Stat::StatId stat_id, Ref entry) { _stats[stat_id] = Ref(entry); } + +void Entity::sdie() { + //serverside + + son_death(); + + //send an event to client + SEND_RPC(rpc("cdie"), cdie()); + + //signal + emit_signal("sdied", this); +} + +void Entity::cdie() { + con_death(); + + emit_signal("cdied", this); +} + //// Resources //// Ref Entity::gets_resource(int index) { @@ -634,7 +653,7 @@ void Entity::stake_damage(Ref data) { emit_signal("son_damage_received", this, data); if (get_health()->gets_current() <= 0) { - die(); + sdie(); } } @@ -697,19 +716,6 @@ void Entity::sdeal_heal_to(Ref data) { son_heal_dealt(data); } -void Entity::die() { - /* - if (!CxNet::IsServer) { - return; - } - sRezTimer = (float)5; - sIsDead = true; - if (SOnDeath != null) { - DELEGATE_INVOKE(SOnDeath); - } - SendDieMessage();*/ -} - void Entity::resurrect() { /* if (!CxNet::IsServer) { @@ -789,6 +795,13 @@ void Entity::creceive_mana_changed(int amount) { void Entity::son_before_aura_applied(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_after_aura_applied(data); + } + + if (has_method("_son_before_aura_applied")) + call("_son_before_aura_applied", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -799,6 +812,13 @@ void Entity::son_before_aura_applied(Ref data) { void Entity::son_after_aura_applied(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_after_aura_applied(data); + } + + if (has_method("_son_after_aura_applied")) + call("_son_after_aura_applied", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -835,6 +855,13 @@ void Entity::update_auras(float delta) { void Entity::son_before_cast(Ref info) { ERR_FAIL_COND(!info.is_valid()); + + if (_s_character_class.is_valid()) { + _s_character_class->son_before_cast(info); + } + + if (has_method("_son_before_cast")) + call("_son_before_cast", info); for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -846,6 +873,13 @@ void Entity::son_before_cast(Ref info) { void Entity::son_before_cast_target(Ref info) { ERR_FAIL_COND(!info.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_after_aura_applied(info); + } + + if (has_method("_son_before_cast_target")) + call("_son_before_cast_target", info); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -855,7 +889,14 @@ void Entity::son_before_cast_target(Ref info) { void Entity::son_hit(Ref data) { ERR_FAIL_COND(!data.is_valid()); - + + if (_s_character_class.is_valid()) { + _s_character_class->son_hit(data); + } + + if (has_method("_son_hit")) + call("_son_hit", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -866,6 +907,13 @@ void Entity::son_hit(Ref data) { void Entity::son_before_damage(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_before_damage(data); + } + + if (has_method("_son_before_damage")) + call("_son_before_damage", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -876,6 +924,13 @@ void Entity::son_before_damage(Ref data) { void Entity::son_damage_receive(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_damage_receive(data); + } + + if (has_method("_son_damage_receive")) + call("_son_damage_receive", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -886,6 +941,13 @@ void Entity::son_damage_receive(Ref data) { void Entity::son_dealt_damage(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_dealt_damage(data); + } + + if (has_method("_son_dealt_damage")) + call("_son_dealt_damage", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -896,6 +958,13 @@ void Entity::son_dealt_damage(Ref data) { void Entity::son_damage_dealt(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_damage_dealt(data); + } + + if (has_method("_son_damage_dealt")) + call("_son_damage_dealt", data); + //serverside for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -907,6 +976,13 @@ void Entity::son_damage_dealt(Ref data) { void Entity::son_before_heal(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_before_heal(data); + } + + if (has_method("_son_before_heal")) + call("_son_before_heal", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -917,6 +993,13 @@ void Entity::son_before_heal(Ref data) { void Entity::son_heal_receive(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_heal_receive(data); + } + + if (has_method("_son_heal_receive")) + call("_son_heal_receive", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -927,6 +1010,13 @@ void Entity::son_heal_receive(Ref data) { void Entity::son_dealt_heal(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_dealt_heal(data); + } + + if (has_method("_son_dealt_heal")) + call("_son_dealt_heal", data); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -937,6 +1027,13 @@ void Entity::son_dealt_heal(Ref data) { void Entity::son_heal_dealt(Ref data) { ERR_FAIL_COND(!data.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_heal_dealt(data); + } + + if (has_method("_son_heal_dealt")) + call("_son_heal_dealt", data); + //serverside for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -987,7 +1084,14 @@ void Entity::sapply_passives_heal_deal(Ref data) { void Entity::son_cast_finished(Ref info) { ERR_FAIL_COND(!info.is_valid()); - + + if (_s_character_class.is_valid()) { + _s_character_class->son_cast_finished(info); + } + + if (has_method("_son_cast_finished")) + call("_son_cast_finished", info); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -998,6 +1102,13 @@ void Entity::son_cast_finished(Ref info) { void Entity::son_cast_started(Ref info) { ERR_FAIL_COND(!info.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_cast_started(info); + } + + if (has_method("_son_cast_started")) + call("_son_cast_started", info); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -1008,6 +1119,13 @@ void Entity::son_cast_started(Ref info) { void Entity::son_cast_failed(Ref info) { ERR_FAIL_COND(!info.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_cast_failed(info); + } + + if (has_method("_son_cast_failed")) + call("_son_cast_failed", info); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -1018,6 +1136,13 @@ void Entity::son_cast_failed(Ref info) { void Entity::son_cast_finished_target(Ref info) { ERR_FAIL_COND(!info.is_valid()); + if (_s_character_class.is_valid()) { + _s_character_class->son_cast_finished_target(info); + } + + if (has_method("_son_cast_finished_target")) + call("_son_cast_finished_target", info); + for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -1025,6 +1150,22 @@ void Entity::son_cast_finished_target(Ref info) { } } +void Entity::son_death() { + if (_s_character_class.is_valid()) { + _s_character_class->son_death(this); + } + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->son_death(ad); + } + + if (has_method("_son_death")) + call("_son_death"); +} + + void Entity::sadd_aura(Ref aura) { ERR_FAIL_COND(!aura.is_valid()); @@ -1168,8 +1309,16 @@ void Entity::cremove_aura(Ref aura) { } } - if (removed) - emit_signal("caura_removed", a); + if (removed) { + if (_s_character_class.is_valid()) { + _s_character_class->con_aura_removed(aura); + } + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", aura); + + emit_signal("caura_removed", a); + } } void Entity::cremove_aura_exact(Ref aura) { @@ -1181,6 +1330,14 @@ void Entity::cremove_aura_exact(Ref aura) { break; } } + + if (_s_character_class.is_valid()) { + _s_character_class->con_aura_removed(aura); + } + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", aura); + emit_signal("caura_removed", aura); } @@ -1195,6 +1352,14 @@ void Entity::cremove_aura_dispelled(Ref aura) { } } + if (_s_character_class.is_valid()) { + _s_character_class->con_aura_removed(aura); + } + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", aura); + + emit_signal("caura_removed_dispelled", aura); } @@ -1217,6 +1382,13 @@ void Entity::cremove_aura_expired(Ref aura) { break; } } + + if (_s_character_class.is_valid()) { + _s_character_class->con_aura_removed(aura); + } + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", aura); emit_signal("caura_removed_expired", aura); } @@ -1242,6 +1414,8 @@ Ref Entity::cget_aura(int index) { } void Entity::moved() { + if (has_method("_moved")) + call("_moved"); } void Entity::con_cast_failed(Ref info) { @@ -1259,6 +1433,42 @@ void Entity::con_cast_finished(Ref info) { void Entity::con_spell_cast_success(Ref info) { } +void Entity::con_death() { + if (_s_character_class.is_valid()) { + _s_character_class->con_death(this); + } + + for (int i = 0; i < _s_auras.size(); ++i) { + Ref ad = _s_auras.get(i); + + ad->get_aura()->con_death(ad); + } + + if (has_method("_con_death")) + call("_con_death"); +} + +void Entity::con_aura_added(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_added")) + call("_con_aura_added", data); +} + +void Entity::con_aura_removed(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_removed")) + call("_con_aura_removed", data); +} + +void Entity::con_aura_refresh(Ref data) { + ERR_FAIL_COND(!data.is_valid()); + + if (has_method("_con_aura_refresh")) + call("_con_aura_refresh", data); +} + void Entity::setup_on_player_moves(Entity *bopmccc, Vector *sspells) { } @@ -1619,9 +1829,6 @@ void Entity::setc_spell_cast_info(Ref info) { _c_spell_cast_info = Ref(info); } -void Entity::son_death() { -} - void Entity::sremove_auras_with_group(int aura_group) { for (int i = 0; i < _s_auras.size(); ++i) { Ref ad = _s_auras.get(i); @@ -2142,6 +2349,38 @@ 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")); + //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"))); @@ -2159,6 +2398,9 @@ void Entity::_bind_methods() { 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"))); + ADD_SIGNAL(MethodInfo("sdied", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + ADD_SIGNAL(MethodInfo("cdied", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"))); + //SpellCastSignals ADD_SIGNAL(MethodInfo("scast_started", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); ADD_SIGNAL(MethodInfo("scast_failed", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"))); @@ -2184,6 +2426,9 @@ void Entity::_bind_methods() { ADD_SIGNAL(MethodInfo("caura_removed_dispelled", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); ADD_SIGNAL(MethodInfo("caura_removed_expired", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); //ADD_SIGNAL(MethodInfo("caura_refreshed", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"))); + + ClassDB::bind_method(D_METHOD("sdie"), &Entity::sdie); + ClassDB::bind_method(D_METHOD("cdie"), &Entity::cdie); //EventHandlers ClassDB::bind_method(D_METHOD("son_before_aura_applied", "data"), &Entity::son_before_aura_applied); @@ -2206,14 +2451,17 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("son_cast_finished", "info"), &Entity::son_cast_finished); ClassDB::bind_method(D_METHOD("son_cast_started", "info"), &Entity::son_cast_started); ClassDB::bind_method(D_METHOD("son_cast_failed", "info"), &Entity::son_cast_failed); - + + ClassDB::bind_method(D_METHOD("son_death"), &Entity::son_death); + //Clientside EventHandlers 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); + //Modifiers/Requesters ClassDB::bind_method(D_METHOD("sapply_passives_damage_receive", "data"), &Entity::sapply_passives_damage_receive); ClassDB::bind_method(D_METHOD("sapply_passives_damage_deal", "data"), &Entity::sapply_passives_damage_deal); diff --git a/entities/entity.h b/entities/entity.h index 6894f7b..c07b3b8 100644 --- a/entities/entity.h +++ b/entities/entity.h @@ -260,6 +260,9 @@ public: Ref get_stat_enum(Stat::StatId stat_id); void set_stat_enum(Stat::StatId stat_id, Ref entry); + + void sdie(); + void cdie(); //// Resources //// @@ -314,6 +317,8 @@ public: void son_cast_finished(Ref info); void son_cast_started(Ref info); void son_cast_failed(Ref info); + + void son_death(); //Clientside EventHandlers void con_cast_failed(Ref info); @@ -321,6 +326,12 @@ public: void con_cast_state_changed(Ref info); void con_cast_finished(Ref info); void con_spell_cast_success(Ref info); + void con_death(); + + //Clientside Event Handlers + void con_aura_added(Ref data); + void con_aura_removed(Ref data); + void con_aura_refresh(Ref data); //Modifiers/Requesters void sapply_passives_damage_receive(Ref data); @@ -375,12 +386,11 @@ public: 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 die(); void resurrect(); void creceive_resurrect(); void creceive_died(); @@ -388,8 +398,6 @@ public: bool gets_is_dead(); bool getc_is_dead(); - void son_death(); - //// Casting System //// @@ -666,3 +674,4 @@ private: VARIANT_ENUM_CAST(Entity::InventorySizes); #endif +