From f036bf449b4ae7d79432f617f63434e455572856 Mon Sep 17 00:00:00 2001 From: Relintai Date: Fri, 13 Sep 2019 01:23:28 +0200 Subject: [PATCH] Added Spell learning, and Skill support into Entity. And added an XP Rate stat. Also the levelup, and xp gain signals are now actually called. --- entities/entity.cpp | 208 ++++++++++++++++++++++++++++++- entities/entity.h | 40 ++++++ entities/skills/entity_skill.cpp | 10 ++ entities/stats/stat.h | 4 +- entities/stats/stat_data.cpp | 2 + 5 files changed, 261 insertions(+), 3 deletions(-) diff --git a/entities/entity.cpp b/entities/entity.cpp index e88725e..b42216c 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -448,6 +448,9 @@ Entity::~Entity() { _s_data.clear(); _c_data.clear(); + + _s_spells.clear(); + _c_spells.clear(); } void Entity::initialize(Ref info) { @@ -1504,6 +1507,8 @@ void Entity::son_xp_gained(int value) { ad->get_aura()->son_xp_gained(ad, value); } + + emit_signal("son_xp_gained", this, value); } void Entity::son_level_up(int value) { @@ -1519,6 +1524,8 @@ void Entity::son_level_up(int value) { ad->get_aura()->son_level_up(ad, _s_level); } + + emit_signal("son_level_up", this, value); } void Entity::sadd_aura(Ref aura) { @@ -2125,6 +2132,8 @@ void Entity::con_xp_gained(int value) { ad->get_aura()->con_xp_gained(ad, value); } + + emit_signal("con_level_up", this, value); } void Entity::con_level_up(int value) { @@ -2140,6 +2149,8 @@ void Entity::con_level_up(int value) { ad->get_aura()->con_level_up(ad, value); } + + emit_signal("con_level_up", this, value); } //// Casting System //// @@ -2573,6 +2584,161 @@ int Entity::getc_category_cooldown_count() { return _c_category_cooldowns.size(); } +//Known Spells +bool Entity::hass_spell(Ref spell) { + for (int i = 0; i < _s_spells.size(); ++i) { + if (_s_spells.get(i) == spell) { + return true; + } + } + + return false; +} +void Entity::adds_spell(Ref spell) { + if (hass_spell(spell)) + return; + + _s_spells.push_back(spell); + + emit_signal("sspell_added", this, spell); + + SEND_RPC(rpc("addc_spell", spell), addc_spell(spell)); +} +void Entity::removes_spell(Ref spell) { + for (int i = 0; i < _s_spells.size(); ++i) { + if (_s_spells.get(i) == spell) { + _s_spells.remove(i); + break; + } + } + + emit_signal("sspell_removed", this, spell); + + SEND_RPC(rpc("removec_spell", spell), removec_spell(spell)); +} +Ref Entity::gets_spell(int index) { + ERR_FAIL_INDEX_V(index, _s_spells.size(), Ref()); + + return _s_spells.get(index); +} +int Entity::gets_spell_count() { + return _s_spells.size(); +} + + +bool Entity::hasc_spell(Ref spell) { + for (int i = 0; i < _c_spells.size(); ++i) { + if (_c_spells.get(i) == spell) { + return true; + } + } + + return false; +} +void Entity::addc_spell(Ref spell) { + if (hasc_spell(spell)) + return; + + _c_spells.push_back(spell); + + emit_signal("cspell_added", this, spell); +} +void Entity::removec_spell(Ref spell) { + for (int i = 0; i < _c_spells.size(); ++i) { + if (_c_spells.get(i) == spell) { + _c_spells.remove(i); + break; + } + } + + emit_signal("cspell_removed", this, spell); +} +Ref Entity::getc_spell(int index) { + ERR_FAIL_INDEX_V(index, _c_spells.size(), Ref()); + + return _c_spells.get(index); +} +int Entity::getc_spell_count() { + return _c_spells.size(); +} + +//Skills +bool Entity::hass_skill(Ref skill) { + for (int i = 0; i < _s_skills.size(); ++i) { + if (_s_skills.get(i) == skill) { + return true; + } + } + + return false; +} +void Entity::adds_skill(Ref skill) { + if (hass_skill(skill)) + return; + + _s_skills.push_back(skill); + + emit_signal("sskill_added", this, skill); + + SEND_RPC(rpc("addc_skill", skill), addc_skill(skill)); +} +void Entity::removes_skill(Ref skill) { + for (int i = 0; i < _s_skills.size(); ++i) { + if (_s_skills.get(i) == skill) { + _s_skills.remove(i); + break; + } + } + + emit_signal("sskill_removed", this, skill); + + SEND_RPC(rpc("removec_skill", skill), removec_skill(skill)); +} +Ref Entity::gets_skill(int index) { + ERR_FAIL_INDEX_V(index, _s_skills.size(), Ref()); + + return _s_skills.get(index); +} +int Entity::gets_skill_count() { + return _s_skills.size(); +} + +bool Entity::hasc_skill(Ref skill) { + for (int i = 0; i < _c_skills.size(); ++i) { + if (_c_skills.get(i) == skill) { + return true; + } + } + + return false; +} +void Entity::addc_skill(Ref skill) { + if (hasc_skill(skill)) + return; + + _c_skills.push_back(skill); + + emit_signal("cskill_added", this, skill); +} +void Entity::removec_skill(Ref skill) { + for (int i = 0; i < _c_skills.size(); ++i) { + if (_c_skills.get(i) == skill) { + _c_skills.remove(i); + break; + } + } + + emit_signal("cskill_removed", this, skill); +} +Ref Entity::getc_skill(int index) { + ERR_FAIL_INDEX_V(index, _c_skills.size(), Ref()); + + return _c_skills.get(index); +} +int Entity::getc_skill_count() { + return _c_skills.size(); +} + //// Casting System //// bool Entity::sis_casting() { @@ -3058,6 +3224,19 @@ void Entity::_bind_methods() { ADD_SIGNAL(MethodInfo("con_xp_gained", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::INT, "value"))); ADD_SIGNAL(MethodInfo("con_level_up", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::INT, "value"))); + //Known Spells + ADD_SIGNAL(MethodInfo("sspell_added", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell"))); + ADD_SIGNAL(MethodInfo("sspell_removed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell"))); + ADD_SIGNAL(MethodInfo("cspell_added", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell"))); + ADD_SIGNAL(MethodInfo("cspell_removed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell"))); + + //Skills + ADD_SIGNAL(MethodInfo("sskill_added", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "skill", PROPERTY_HINT_RESOURCE_TYPE, "EntitySkill"))); + ADD_SIGNAL(MethodInfo("sskill_removed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "skill", PROPERTY_HINT_RESOURCE_TYPE, "EntitySkill"))); + + ADD_SIGNAL(MethodInfo("cskill_added", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "skill", PROPERTY_HINT_RESOURCE_TYPE, "EntitySkill"))); + ADD_SIGNAL(MethodInfo("cskill_removed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "skill", PROPERTY_HINT_RESOURCE_TYPE, "EntitySkill"))); + //setup BIND_VMETHOD(MethodInfo("_setup", PropertyInfo(Variant::OBJECT, "entity_data", PROPERTY_HINT_RESOURCE_TYPE, "EntityData"))); @@ -3135,7 +3314,6 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("son_xp_gained", "value"), &Entity::son_xp_gained); ClassDB::bind_method(D_METHOD("son_level_up", "value"), &Entity::son_level_up); - //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"))); @@ -3218,7 +3396,7 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("adds_xp", "value"), &Entity::adds_xp); ClassDB::bind_method(D_METHOD("addc_xp", "value"), &Entity::addc_xp); ClassDB::bind_method(D_METHOD("s_levelup", "value"), &Entity::s_levelup); - ClassDB::bind_method(D_METHOD("c_levelup", "value"), &Entity::c_levelup); + ClassDB::bind_method(D_METHOD("c_levelup", "value"), &Entity::c_levelup); //Aura Manipulation ClassDB::bind_method(D_METHOD("sadd_aura", "aura"), &Entity::sadd_aura); @@ -3468,6 +3646,32 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("getc_category_cooldown_index", "index"), &Entity::getc_category_cooldown_index); ClassDB::bind_method(D_METHOD("getc_category_cooldown_count"), &Entity::getc_category_cooldown_count); + //Known Spells + ClassDB::bind_method(D_METHOD("hass_spell", "spell"), &Entity::hass_spell); + ClassDB::bind_method(D_METHOD("adds_spell", "spell"), &Entity::adds_spell); + ClassDB::bind_method(D_METHOD("removes_spell", "spell"), &Entity::removes_spell); + ClassDB::bind_method(D_METHOD("gets_spell", "spell"), &Entity::gets_spell); + ClassDB::bind_method(D_METHOD("gets_spell_count"), &Entity::gets_spell_count); + + ClassDB::bind_method(D_METHOD("hasc_spell", "spell"), &Entity::hasc_spell); + ClassDB::bind_method(D_METHOD("addc_spell", "spell"), &Entity::addc_spell); + ClassDB::bind_method(D_METHOD("removec_spell", "spell"), &Entity::removec_spell); + ClassDB::bind_method(D_METHOD("getc_spell", "spell"), &Entity::getc_spell); + ClassDB::bind_method(D_METHOD("getc_spell_count"), &Entity::getc_spell_count); + + //Skills + ClassDB::bind_method(D_METHOD("hass_skill", "skill"), &Entity::hass_skill); + ClassDB::bind_method(D_METHOD("adds_skill", "skill"), &Entity::adds_skill); + ClassDB::bind_method(D_METHOD("removes_skill", "skill"), &Entity::removes_skill); + ClassDB::bind_method(D_METHOD("gets_skill", "skill"), &Entity::gets_skill); + ClassDB::bind_method(D_METHOD("gets_skill_count"), &Entity::gets_skill_count); + + ClassDB::bind_method(D_METHOD("hasc_skill", "skill"), &Entity::hasc_skill); + ClassDB::bind_method(D_METHOD("addc_skill", "skill"), &Entity::addc_skill); + ClassDB::bind_method(D_METHOD("removec_skill", "skill"), &Entity::removec_skill); + ClassDB::bind_method(D_METHOD("getc_skill", "skill"), &Entity::getc_skill); + ClassDB::bind_method(D_METHOD("getc_skill_count"), &Entity::getc_skill_count); + //skeleton ClassDB::bind_method(D_METHOD("get_character_skeleton"), &Entity::get_character_skeleton); diff --git a/entities/entity.h b/entities/entity.h index 0dee56b..3a533e4 100644 --- a/entities/entity.h +++ b/entities/entity.h @@ -39,6 +39,8 @@ #include "./data/entity_data_container.h" +#include "./skills/entity_skill.h" + class EntityData; class AuraData; class Spell; @@ -468,6 +470,32 @@ public: Ref getc_category_cooldown_index(int index); int getc_category_cooldown_count(); + //Known Spells + bool hass_spell(Ref spell); + void adds_spell(Ref spell); + void removes_spell(Ref spell); + Ref gets_spell(int index); + int gets_spell_count(); + + bool hasc_spell(Ref spell); + void addc_spell(Ref spell); + void removec_spell(Ref spell); + Ref getc_spell(int index); + int getc_spell_count(); + + //Skills + bool hass_skill(Ref skill); + void adds_skill(Ref skill); + void removes_skill(Ref skill); + Ref gets_skill(int skill); + int gets_skill_count(); + + bool hasc_skill(Ref skill); + void addc_skill(Ref skill); + void removec_skill(Ref skill); + Ref getc_skill(int index); + int getc_skill_count(); + //// TargetComponent //// void crequest_target_change(NodePath path); @@ -653,6 +681,18 @@ private: //// Data //// Vector > _s_data; Vector > _c_data; + + //// Known Spells //// + Vector > _s_spells; + Vector > _c_spells; + + //// Skills //// + Vector > _s_skills; + Vector > _c_skills; + + //// Stat Allocations //// + //int _unallocated_stats; + //int _stat_allocations[Stat::STAT_ID_TOTAL_STATS]; }; #endif diff --git a/entities/skills/entity_skill.cpp b/entities/skills/entity_skill.cpp index ba38afc..9982259 100644 --- a/entities/skills/entity_skill.cpp +++ b/entities/skills/entity_skill.cpp @@ -5,6 +5,8 @@ int EntitySkill::get_skill_id() { } void EntitySkill::set_skill_id(int value) { _skill_id = value; + + emit_signal("skill_changed", Ref(this)); } int EntitySkill::get_current() { @@ -12,6 +14,8 @@ int EntitySkill::get_current() { } void EntitySkill::set_current(int value) { _current = value; + + emit_signal("skill_changed", Ref(this)); } int EntitySkill::get_max() { @@ -19,6 +23,8 @@ int EntitySkill::get_max() { } void EntitySkill::set_max(int value) { _max = value; + + emit_signal("skill_changed", Ref(this)); } bool EntitySkill::get_disabled() { @@ -26,6 +32,8 @@ bool EntitySkill::get_disabled() { } void EntitySkill::set_disabled(bool value) { _disabled = value; + + emit_signal("skill_changed", Ref(this)); } EntitySkill::EntitySkill() { @@ -36,6 +44,8 @@ EntitySkill::EntitySkill() { } void EntitySkill::_bind_methods() { + ADD_SIGNAL(MethodInfo("skill_changed", PropertyInfo(Variant::OBJECT, "skill", PROPERTY_HINT_RESOURCE_TYPE, "EntitySkill"))); + ClassDB::bind_method(D_METHOD("get_skill_id"), &EntitySkill::get_skill_id); ClassDB::bind_method(D_METHOD("set_skill_id", "value"), &EntitySkill::set_skill_id); ADD_PROPERTY(PropertyInfo(Variant::INT, "skill_id"), "set_skill_id", "get_skill_id"); diff --git a/entities/stats/stat.h b/entities/stats/stat.h index 180f629..bcdc44a 100644 --- a/entities/stats/stat.h +++ b/entities/stats/stat.h @@ -63,7 +63,9 @@ public: STAT_ID_ENERGY = 38, STAT_ID_RAGE = 39, - STAT_ID_TOTAL_STATS = 40, + STAT_ID_XP_RATE = 40, + + STAT_ID_TOTAL_STATS = 41, STAT_ID_NONE = STAT_ID_TOTAL_STATS, }; diff --git a/entities/stats/stat_data.cpp b/entities/stats/stat_data.cpp index 82188fc..f72e9c3 100644 --- a/entities/stats/stat_data.cpp +++ b/entities/stats/stat_data.cpp @@ -69,6 +69,8 @@ StatData::StatData() { get_stat_data_enum(Stat::STAT_ID_BLOCK)->set_base(10); get_stat_data_enum(Stat::STAT_ID_PARRY)->set_base(15); get_stat_data_enum(Stat::STAT_ID_MELEE_DAMAGE_REDUCTION)->set_base(15); + + get_stat_data_enum(Stat::STAT_ID_XP_RATE)->set_base(1); } void StatData::_bind_methods() {