mirror of
https://github.com/Relintai/entity_spell_system.git
synced 2025-02-22 17:18:12 +01:00
697 lines
18 KiB
C++
697 lines
18 KiB
C++
#include "stat.h"
|
|
|
|
#include "../entity.h"
|
|
#include "stat_data_entry.h"
|
|
|
|
const String Stat::STAT_BINDING_STRING = "Health,Speed,Mana,GCD,Haste,Agility,Strength,Stamina,Intellect,Luck,Haste Rating,Resilience,Armor,Attack Power,Spell Power,Melee Crit,Melee Crit bonus,Spell Crit,Spell Crit Bonus,Block,Parry,Damage Reduction,Melee Damage Reduction,Spell Damage Reduction,Damage Taken,Heal Taken,Melee Damage,Spell Damage,Holy Resist,Shadow Resist,Nature Resist,Fire Resist,Frost Resist,Lightning Resist,Chaos Resist,Silence Resist,Fear Resist,Stun Resist,Energy,Rage,XP Rate,None";
|
|
const String Stat::MAIN_STAT_BINDING_STRING = "Agility,Strength,Stamina,Intellect,Luck";
|
|
|
|
const String Stat::MODIFIER_APPLY_TYPE_BINDING_STRING = "Standard,Only min modifier,Only Max modifier";
|
|
|
|
String Stat::stat_id_name(int stat_id) {
|
|
switch (stat_id) {
|
|
case STAT_ID_HEALTH:
|
|
return "health";
|
|
case STAT_ID_SPEED:
|
|
return "speed";
|
|
case STAT_ID_MANA:
|
|
return "mana";
|
|
case STAT_ID_GLOBAL_COOLDOWN:
|
|
return "gcd";
|
|
case STAT_ID_HASTE:
|
|
return "haste";
|
|
|
|
case STAT_ID_AGILITY:
|
|
return "agility";
|
|
case STAT_ID_STRENGTH:
|
|
return "strength";
|
|
case STAT_ID_STAMINA:
|
|
return "stamina";
|
|
case STAT_ID_INTELLECT:
|
|
return "intellect";
|
|
case STAT_ID_LUCK:
|
|
return "luck";
|
|
|
|
case STAT_ID_HASTE_RATING:
|
|
return "haste_rating";
|
|
case STAT_ID_RESLILIENCE:
|
|
return "resilience";
|
|
case STAT_ID_ARMOR:
|
|
return "armor";
|
|
|
|
case STAT_ID_ATTACK_POWER:
|
|
return "attack_power";
|
|
case STAT_ID_SPELL_POWER:
|
|
return "spell_power";
|
|
|
|
case STAT_ID_MELEE_CRIT:
|
|
return "melee_crit";
|
|
case STAT_ID_MELEE_CRIT_BONUS:
|
|
return "melee_crit_bonus";
|
|
case STAT_ID_SPELL_CRIT:
|
|
return "spell_crit";
|
|
case STAT_ID_SPELL_CRIT_BONUS:
|
|
return "spell_crit_bonus";
|
|
|
|
case STAT_ID_BLOCK:
|
|
return "block";
|
|
case STAT_ID_PARRY:
|
|
return "parry";
|
|
case STAT_ID_DAMAGE_REDUCTION:
|
|
return "damage_reduction";
|
|
case STAT_ID_MELEE_DAMAGE_REDUCTION:
|
|
return "melee_damage_reduction";
|
|
case STAT_ID_SPELL_DAMAGE_REDUCTION:
|
|
return "spell_damage_reduction";
|
|
case STAT_ID_DAMAGE_TAKEN:
|
|
return "damage_taken";
|
|
case STAT_ID_HEAL_TAKEN:
|
|
return "heal_taken";
|
|
|
|
case STAT_ID_MELEE_DAMAGE:
|
|
return "melee_damage";
|
|
case STAT_ID_SPELL_DAMAGE:
|
|
return "spell_damage";
|
|
|
|
case STAT_ID_HOLY_RESIST:
|
|
return "holy_resist";
|
|
case STAT_ID_SHADOW_RESIST:
|
|
return "shadow_resist";
|
|
case STAT_ID_NATURE_RESIST:
|
|
return "nature_resist";
|
|
case STAT_ID_FIRE_RESIST:
|
|
return "fire_resist";
|
|
case STAT_ID_FROST_RESIST:
|
|
return "frost_resist";
|
|
case STAT_ID_LIGHTNING_RESIST:
|
|
return "lightning_resist";
|
|
case STAT_ID_CHAOS_RESIST:
|
|
return "chaos_resist";
|
|
case STAT_ID_SILENCE_RESIST:
|
|
return "silence_resist";
|
|
case STAT_ID_FEAR_RESIST:
|
|
return "fear_resist";
|
|
case STAT_ID_STUN_RESIST:
|
|
return "stun_resist";
|
|
|
|
case STAT_ID_ENERGY:
|
|
return "energy";
|
|
case STAT_ID_RAGE:
|
|
return "rage";
|
|
|
|
case STAT_ID_XP_RATE:
|
|
return "xp_rate";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
Stat::StatId Stat::get_id() {
|
|
return _id;
|
|
}
|
|
void Stat::set_id(Stat::StatId id) {
|
|
_id = id;
|
|
}
|
|
|
|
Ref<StatDataEntry> Stat::get_stat_data_entry() {
|
|
return _stat_data_entry;
|
|
}
|
|
void Stat::set_stat_data_entry(Ref<StatDataEntry> entry) {
|
|
_stat_data_entry = entry;
|
|
}
|
|
|
|
Entity *Stat::get_owner() {
|
|
return _owner;
|
|
}
|
|
void Stat::set_owner(Entity *value) {
|
|
_owner = value;
|
|
}
|
|
void Stat::set_owner_bind(Node *value) {
|
|
if (!value) {
|
|
return;
|
|
}
|
|
|
|
Entity *e = cast_to<Entity>(value);
|
|
|
|
if (!e) {
|
|
return;
|
|
}
|
|
|
|
_owner = e;
|
|
}
|
|
|
|
Stat::StatModifierApplyType Stat::get_stat_modifier_type() {
|
|
return _modifier_apply_type;
|
|
}
|
|
void Stat::set_stat_modifier_type(Stat::StatModifierApplyType value) {
|
|
_modifier_apply_type = value;
|
|
}
|
|
|
|
bool Stat::get_public() {
|
|
return _public;
|
|
}
|
|
void Stat::set_public(bool value) {
|
|
_public = value;
|
|
}
|
|
|
|
bool Stat::get_locked() {
|
|
return _locked;
|
|
}
|
|
void Stat::set_locked(bool value) {
|
|
_locked = value;
|
|
}
|
|
|
|
bool Stat::get_dirty() {
|
|
return _dirty;
|
|
}
|
|
void Stat::set_dirty(bool value) {
|
|
_dirty = value;
|
|
}
|
|
|
|
bool Stat::get_dirty_mods() {
|
|
return _dirty_mods;
|
|
}
|
|
void Stat::set_dirty_mods(bool value) {
|
|
_dirty_mods = value;
|
|
}
|
|
|
|
float Stat::get_base() {
|
|
return _base;
|
|
}
|
|
float Stat::get_bonus() {
|
|
return _bonus;
|
|
}
|
|
float Stat::get_percent() {
|
|
return _percent;
|
|
}
|
|
|
|
float Stat::gets_current() {
|
|
return _s_current;
|
|
}
|
|
void Stat::sets_current(float value) {
|
|
if (_locked) {
|
|
return;
|
|
}
|
|
|
|
_s_current = value;
|
|
|
|
_dirty = true;
|
|
}
|
|
|
|
float Stat::gets_max() {
|
|
return _s_max;
|
|
}
|
|
void Stat::sets_max(float value) {
|
|
_s_max = value;
|
|
|
|
_dirty = true;
|
|
}
|
|
|
|
float Stat::getc_current() {
|
|
return _c_current;
|
|
}
|
|
void Stat::setc_current(float value) {
|
|
ERR_FAIL_COND(_owner == NULL);
|
|
|
|
_c_current = value;
|
|
|
|
_owner->onc_stat_changed(Ref<Stat>(this));
|
|
|
|
emit_signal("c_changed", Ref<Stat>(this));
|
|
}
|
|
|
|
float Stat::getc_max() {
|
|
return _c_max;
|
|
}
|
|
void Stat::setc_max(float value) {
|
|
ERR_FAIL_COND(_owner == NULL);
|
|
|
|
_s_current = value;
|
|
|
|
_owner->onc_stat_changed(Ref<Stat>(this));
|
|
|
|
emit_signal("c_changed", Ref<Stat>(this));
|
|
}
|
|
|
|
void Stat::setc_values(int ccurrent, int cmax) {
|
|
ERR_FAIL_COND(_owner == NULL);
|
|
|
|
_c_current = ccurrent;
|
|
_c_max = cmax;
|
|
|
|
_owner->onc_stat_changed(Ref<Stat>(this));
|
|
emit_signal("c_changed", Ref<Stat>(this));
|
|
}
|
|
|
|
_FORCE_INLINE_ Vector<Ref<StatModifier> > *Stat::get_modifiers() {
|
|
return &_modifiers;
|
|
}
|
|
|
|
int Stat::get_modifier_count() {
|
|
return _modifiers.size();
|
|
}
|
|
|
|
void Stat::clear_modifiers() {
|
|
_modifiers.clear();
|
|
|
|
_dirty = true;
|
|
_dirty_mods = true;
|
|
}
|
|
|
|
Ref<StatModifier> Stat::get_modifier(int index) {
|
|
return _modifiers.get(index);
|
|
}
|
|
|
|
Ref<StatModifier> Stat::add_modifier(int id, float base_mod, float bonus_mod, float percent_mod) {
|
|
Ref<StatModifier> stat_modifier = Ref<StatModifier>(memnew(StatModifier(id, base_mod, bonus_mod, percent_mod, this)));
|
|
|
|
_modifiers.push_back(stat_modifier);
|
|
|
|
_dirty = true;
|
|
_dirty_mods = true;
|
|
|
|
return stat_modifier;
|
|
}
|
|
|
|
Ref<StatModifier> Stat::get_or_add_modifier(int id) {
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
if (_modifiers.get(i)->get_id() == id) {
|
|
return _modifiers.get(i);
|
|
}
|
|
}
|
|
|
|
Ref<StatModifier> stat_modifier = Ref<StatModifier>(memnew(StatModifier(id, 0, 0, 0, this)));
|
|
|
|
_modifiers.push_back(stat_modifier);
|
|
|
|
return stat_modifier;
|
|
}
|
|
|
|
void Stat::remove_modifier(int id) {
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
if (_modifiers.get(i)->get_id() == id) {
|
|
Ref<StatModifier> modifier = _modifiers.get(i);
|
|
_modifiers.remove(i);
|
|
|
|
_dirty_mods = true;
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Stat::remove_modifier_index(int index) {
|
|
_modifiers.remove(index);
|
|
}
|
|
|
|
void Stat::apply_modifiers() {
|
|
ERR_FAIL_COND(_owner == NULL);
|
|
ERR_FAIL_COND(!_stat_data_entry.is_valid());
|
|
|
|
reset_values();
|
|
|
|
if (_modifier_apply_type == MODIFIER_APPLY_TYPE_STANDARD) {
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
Ref<StatModifier> mod = _modifiers.get(i);
|
|
|
|
_base += mod->get_base_mod();
|
|
_bonus += mod->get_bonus_mod();
|
|
_percent += mod->get_percent_mod();
|
|
}
|
|
} else {
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
Ref<StatModifier> modifier = _modifiers.get(i);
|
|
|
|
_base += modifier->get_base_mod();
|
|
_bonus += modifier->get_bonus_mod();
|
|
|
|
if (modifier->get_percent_mod() >= 0) {
|
|
_percent += modifier->get_percent_mod();
|
|
}
|
|
}
|
|
|
|
float p = 0;
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
Ref<StatModifier> modifier = _modifiers.get(i);
|
|
|
|
if (modifier->get_percent_mod() < p)
|
|
p = modifier->get_percent_mod();
|
|
}
|
|
|
|
_percent += p;
|
|
}
|
|
|
|
refresh_currmax();
|
|
_dirty_mods = false;
|
|
|
|
for (int i = 0; i < _stat_data_entry->get_mod_stat_count(); ++i) {
|
|
Ref<Stat> stat = _owner->get_stat_enum(_stat_data_entry->get_mod_stat_id(i));
|
|
Ref<Curve> curve = _stat_data_entry->get_mod_stat_curve(i);
|
|
|
|
ERR_FAIL_COND(!stat.is_valid());
|
|
ERR_FAIL_COND(!curve.is_valid());
|
|
|
|
Ref<StatModifier> sm = stat->get_or_add_modifier(-(static_cast<int>(_id) + 1));
|
|
|
|
sm->set_base_mod(_s_current * curve->interpolate(_s_current));
|
|
}
|
|
|
|
_owner->ons_stat_changed(Ref<Stat>(this));
|
|
emit_signal("s_changed", Ref<Stat>(this));
|
|
}
|
|
|
|
void Stat::reset_values() {
|
|
_percent = 0;
|
|
_bonus = 0;
|
|
_base = 0;
|
|
|
|
_dirty = true;
|
|
_dirty_mods = true;
|
|
}
|
|
|
|
void Stat::refresh_currmax() {
|
|
//According to people on stack overflow this should be fine, because 0.0 has a unique representation
|
|
float diff = _s_max == 0.0 ? 1.0 : _s_current / _s_max;
|
|
|
|
_s_max = (_base + _bonus) * (_percent / 100.0);
|
|
|
|
_s_current = _s_max * diff;
|
|
|
|
_dirty = true;
|
|
}
|
|
|
|
bool Stat::iss_current_zero() {
|
|
return (fabs(_s_current) < .000001);
|
|
}
|
|
|
|
bool Stat::isc_current_zero() {
|
|
return (fabs(_c_current) < .000001);
|
|
}
|
|
|
|
void Stat::set_to_max() {
|
|
ERR_FAIL_COND(_owner == NULL);
|
|
|
|
_s_current = _s_max;
|
|
|
|
_dirty = true;
|
|
|
|
_owner->ons_stat_changed(Ref<Stat>(this));
|
|
emit_signal("s_changed", Ref<Stat>(this));
|
|
}
|
|
|
|
void Stat::modifier_changed(Ref<StatModifier> modifier) {
|
|
_dirty_mods = true;
|
|
}
|
|
|
|
Dictionary Stat::to_dict() {
|
|
return call("_to_dict");
|
|
}
|
|
void Stat::from_dict(const Dictionary &dict) {
|
|
call("_from_dict", dict);
|
|
}
|
|
|
|
Dictionary Stat::_to_dict() {
|
|
Dictionary dict;
|
|
|
|
dict["id"] = _id;
|
|
dict["modifier_apply_type"] = _modifier_apply_type;
|
|
|
|
dict["public"] = _public;
|
|
dict["locked"] = _locked;
|
|
dict["dirty"] = _dirty;
|
|
dict["dirty_mods"] = _dirty_mods;
|
|
|
|
dict["base"] = _base;
|
|
dict["bonus"] = _bonus;
|
|
dict["percent"] = _percent;
|
|
|
|
dict["current"] = _s_current;
|
|
dict["max"] = _s_max;
|
|
|
|
Dictionary modifiers;
|
|
|
|
for (int i = 0; i < _modifiers.size(); ++i) {
|
|
modifiers[String::num(i)] = _modifiers.get(i)->to_dict();
|
|
}
|
|
|
|
dict["modifiers"] = modifiers;
|
|
|
|
return dict;
|
|
}
|
|
void Stat::_from_dict(const Dictionary &dict) {
|
|
ERR_FAIL_COND(dict.empty());
|
|
|
|
_id = (Stat::StatId)((int)dict.get("id", 0));
|
|
_modifier_apply_type = (StatModifierApplyType)((int)dict.get("modifier_apply_type", 0));
|
|
|
|
_public = dict.get("public", false);
|
|
_locked = dict.get("locked", false);
|
|
_dirty = dict.get("dirty", false);
|
|
_dirty_mods = dict.get("dirty_mods", false);
|
|
|
|
_base = dict.get("base", 0);
|
|
_bonus = dict.get("bonus", 0);
|
|
_percent = dict.get("percent", 1);
|
|
|
|
_s_current = dict.get("current", 0);
|
|
_s_max = dict.get("max", 0);
|
|
|
|
_c_current = _s_current;
|
|
_c_max = _s_max;
|
|
|
|
_modifiers.clear();
|
|
|
|
Dictionary modifiers = dict.get("modifiers", Dictionary());
|
|
|
|
for (int i = 0; i < modifiers.size(); ++i) {
|
|
Ref<StatModifier> sm;
|
|
sm.instance();
|
|
|
|
sm->from_dict(modifiers.get(String::num(i), Dictionary()));
|
|
sm->set_owner(this);
|
|
|
|
_modifiers.push_back(sm);
|
|
}
|
|
}
|
|
|
|
Stat::Stat() {
|
|
_id = Stat::STAT_ID_NONE;
|
|
_owner = NULL;
|
|
|
|
_modifier_apply_type = MODIFIER_APPLY_TYPE_STANDARD;
|
|
|
|
_public = false;
|
|
_dirty_mods = false;
|
|
|
|
_locked = false;
|
|
_dirty = true;
|
|
|
|
_base = 0;
|
|
_bonus = 0;
|
|
_percent = 0;
|
|
|
|
_s_current = 0;
|
|
_s_max = 0;
|
|
|
|
_c_current = 0;
|
|
_c_max = 0;
|
|
}
|
|
|
|
Stat::Stat(Stat::StatId id, Entity *owner) {
|
|
_id = id;
|
|
_owner = owner;
|
|
|
|
_modifier_apply_type = MODIFIER_APPLY_TYPE_STANDARD;
|
|
|
|
_public = false;
|
|
_dirty_mods = false;
|
|
|
|
_locked = false;
|
|
_dirty = true;
|
|
|
|
_base = 0;
|
|
_bonus = 0;
|
|
_percent = 0;
|
|
|
|
_s_current = 0;
|
|
_s_max = 0;
|
|
|
|
_c_current = 0;
|
|
_c_max = 0;
|
|
}
|
|
|
|
Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type, Entity *owner) {
|
|
_id = id;
|
|
_owner = owner;
|
|
|
|
_modifier_apply_type = modifier_apply_type;
|
|
|
|
_public = false;
|
|
_dirty_mods = false;
|
|
|
|
_locked = false;
|
|
_dirty = true;
|
|
|
|
_base = 0;
|
|
_bonus = 0;
|
|
_percent = 0;
|
|
|
|
_s_current = 0;
|
|
_s_max = 0;
|
|
|
|
_c_current = 0;
|
|
_c_max = 0;
|
|
}
|
|
|
|
Stat::~Stat() {
|
|
_modifiers.clear();
|
|
_owner = NULL;
|
|
_stat_data_entry.unref();
|
|
}
|
|
|
|
void Stat::_bind_methods() {
|
|
ADD_SIGNAL(MethodInfo("s_changed", PropertyInfo(Variant::OBJECT, "stat", PROPERTY_HINT_RESOURCE_TYPE, "Stat")));
|
|
ADD_SIGNAL(MethodInfo("c_changed", PropertyInfo(Variant::OBJECT, "stat", PROPERTY_HINT_RESOURCE_TYPE, "Stat")));
|
|
|
|
ClassDB::bind_method(D_METHOD("get_id"), &Stat::get_id);
|
|
ClassDB::bind_method(D_METHOD("set_id", "id"), &Stat::set_id);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "id", PROPERTY_HINT_ENUM, STAT_BINDING_STRING), "set_id", "get_id");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_stat_data_entry"), &Stat::get_stat_data_entry);
|
|
ClassDB::bind_method(D_METHOD("set_stat_data_entry", "value"), &Stat::set_stat_data_entry);
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "stat_data_entry", PROPERTY_HINT_RESOURCE_TYPE, "StatDataEntry"), "set_stat_data_entry", "get_stat_data_entry");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_owner"), &Stat::get_owner);
|
|
ClassDB::bind_method(D_METHOD("set_owner", "value"), &Stat::set_owner_bind);
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "owner", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "set_owner", "get_owner");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_stat_modifier_type"), &Stat::get_stat_modifier_type);
|
|
ClassDB::bind_method(D_METHOD("set_stat_modifier_type", "value"), &Stat::set_stat_modifier_type);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "stat_type", PROPERTY_HINT_ENUM, "Standard, Min Modifier, Max modifier"), "set_stat_modifier_type", "get_stat_modifier_type");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_public"), &Stat::get_public);
|
|
ClassDB::bind_method(D_METHOD("set_public", "value"), &Stat::set_public);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "public"), "set_public", "get_public");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_locked"), &Stat::get_locked);
|
|
ClassDB::bind_method(D_METHOD("set_locked", "value"), &Stat::set_locked);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "locked"), "set_locked", "get_locked");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_dirty"), &Stat::get_dirty);
|
|
ClassDB::bind_method(D_METHOD("set_dirty", "value"), &Stat::set_dirty);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_dirty"), "set_dirty", "get_dirty");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_dirty_mods"), &Stat::get_dirty_mods);
|
|
ClassDB::bind_method(D_METHOD("set_dirty_mods", "value"), &Stat::set_dirty_mods);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dirty_mods"), "set_dirty_mods", "get_dirty_mods");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_base"), &Stat::get_base);
|
|
ClassDB::bind_method(D_METHOD("get_bonus"), &Stat::get_bonus);
|
|
ClassDB::bind_method(D_METHOD("get_percent"), &Stat::get_percent);
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_current"), &Stat::gets_current);
|
|
ClassDB::bind_method(D_METHOD("sets_current", "value"), &Stat::sets_current);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "scurrent"), "sets_current", "gets_current");
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_max"), &Stat::gets_max);
|
|
ClassDB::bind_method(D_METHOD("sets_max"), &Stat::sets_max);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "smax"), "sets_max", "gets_max");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_max"), &Stat::getc_max);
|
|
ClassDB::bind_method(D_METHOD("setc_max"), &Stat::setc_max);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "cmax"), "setc_max", "getc_max");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_current"), &Stat::getc_current);
|
|
ClassDB::bind_method(D_METHOD("setc_current", "value"), &Stat::setc_current);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "ccurrent"), "setc_current", "getc_current");
|
|
|
|
ClassDB::bind_method(D_METHOD("setc_values", "ccurrent", "cmax"), &Stat::setc_values);
|
|
|
|
ClassDB::bind_method(D_METHOD("add_modifier", "id", "base_mod", "bonus_mod", "percent_mod"), &Stat::add_modifier);
|
|
ClassDB::bind_method(D_METHOD("get_or_add_modifier", "id"), &Stat::get_or_add_modifier);
|
|
ClassDB::bind_method(D_METHOD("remove_modifier", "id"), &Stat::remove_modifier);
|
|
ClassDB::bind_method(D_METHOD("remove_modifier_index", "index"), &Stat::remove_modifier_index);
|
|
ClassDB::bind_method(D_METHOD("get_modifier_count"), &Stat::get_modifier_count);
|
|
ClassDB::bind_method(D_METHOD("clear_modifiers"), &Stat::clear_modifiers);
|
|
ClassDB::bind_method(D_METHOD("get_modifier", "index"), &Stat::get_modifier);
|
|
|
|
ClassDB::bind_method(D_METHOD("apply_modifiers"), &Stat::apply_modifiers);
|
|
|
|
ClassDB::bind_method(D_METHOD("reset_values"), &Stat::reset_values);
|
|
ClassDB::bind_method(D_METHOD("refresh_currmax"), &Stat::refresh_currmax);
|
|
ClassDB::bind_method(D_METHOD("iss_current_zero"), &Stat::iss_current_zero);
|
|
ClassDB::bind_method(D_METHOD("isc_current_zero"), &Stat::isc_current_zero);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_to_max"), &Stat::set_to_max);
|
|
|
|
ClassDB::bind_method(D_METHOD("modifier_changed", "modifier"), &Stat::modifier_changed);
|
|
|
|
//Serialization
|
|
BIND_VMETHOD(MethodInfo("_from_dict", PropertyInfo(Variant::DICTIONARY, "dict")));
|
|
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::DICTIONARY, "dict"), "_to_dict"));
|
|
|
|
ClassDB::bind_method(D_METHOD("from_dict", "dict"), &Stat::from_dict);
|
|
ClassDB::bind_method(D_METHOD("to_dict"), &Stat::to_dict);
|
|
|
|
ClassDB::bind_method(D_METHOD("_from_dict", "dict"), &Stat::_from_dict);
|
|
ClassDB::bind_method(D_METHOD("_to_dict"), &Stat::_to_dict);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_HEALTH);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPEED);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_MANA);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_GLOBAL_COOLDOWN);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_HASTE);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_AGILITY);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_STRENGTH);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_STAMINA);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_INTELLECT);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_LUCK);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_HASTE_RATING);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_RESLILIENCE);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_ARMOR);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_ATTACK_POWER);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPELL_POWER);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_MELEE_CRIT);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_MELEE_CRIT_BONUS);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPELL_CRIT);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPELL_CRIT_BONUS);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_BLOCK);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_PARRY);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_DAMAGE_REDUCTION);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_MELEE_DAMAGE_REDUCTION);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPELL_DAMAGE_REDUCTION);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_DAMAGE_TAKEN);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_MELEE_DAMAGE);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SPELL_DAMAGE);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_HOLY_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SHADOW_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_NATURE_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_FIRE_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_FROST_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_LIGHTNING_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_CHAOS_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_SILENCE_RESIST);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_FEAR_RESIST);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_TOTAL_STATS);
|
|
BIND_ENUM_CONSTANT(Stat::STAT_ID_NONE);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::MODIFIER_APPLY_TYPE_STANDARD);
|
|
BIND_ENUM_CONSTANT(Stat::MODIFIER_APPLY_TYPE_ONLY_MIN_MODIFIER);
|
|
BIND_ENUM_CONSTANT(Stat::MODIFIER_APPLY_TYPE_ONLY_MAX_MODIFIER);
|
|
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_AGILITY);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_STRENGTH);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_STAMINA);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_INTELLECT);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_LUCK);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_COUNT);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_MIN);
|
|
BIND_ENUM_CONSTANT(Stat::MAIN_STAT_ID_MAX);
|
|
}
|