/* EQ2Emulator: Everquest II Server Emulator Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) This file is part of EQ2Emulator. EQ2Emulator is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. EQ2Emulator is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with EQ2Emulator. If not, see . */ #ifndef __EQ2_ENTITY__ #define __EQ2_ENTITY__ #include "Spawn.h" #include "../common/Mutex.h" #include "Skills.h" #include "MutexList.h" #include "MutexVector.h" #include #include #include #include #include namespace l = boost::lambda; class Entity; class NPC; class Trade; struct LuaSpell; struct GroupMemberInfo; struct BonusValues{ int32 spell_id; int8 tier; int16 type; sint32 value; int64 class_req; vector race_req; vector faction_req; LuaSpell* luaspell; }; struct MaintainedEffects{ char name[60]; //name of the spell int32 target; int8 target_type; int32 spell_id; int32 slot_pos; int16 icon; int16 icon_backdrop; int8 conc_used; int8 tier; float total_time; int32 expire_timestamp; LuaSpell* spell; }; struct SpellEffects{ int32 spell_id; Entity* caster; float total_time; int32 expire_timestamp; int16 icon; int16 icon_backdrop; int8 tier; LuaSpell* spell; }; struct DetrimentalEffects { int32 spell_id; Entity* caster; int32 expire_timestamp; int16 icon; int16 icon_backdrop; int8 tier; int8 det_type; bool incurable; LuaSpell* spell; int8 control_effect; float total_time; }; enum RACE_ALIGNMENT { ALIGNMENT_EVIL=0, ALIGNMENT_GOOD=1 // neutral? }; struct InfoStruct{ InfoStruct() { name_ = std::string(""); class1_ = 0; class2_ = 0; class3_ = 0; race_ = 0; gender_ = 0; level_ = 0; max_level_ = 0; effective_level_ = 0; tradeskill_level_ = 0; tradeskill_max_level_ = 0; cur_concentration_ = 0; max_concentration_ = 0; cur_attack_ = 0; attack_base_ = 0; cur_mitigation_ = 0; max_mitigation_ = 0; mitigation_base_ = 0; avoidance_display_ = 0; cur_avoidance_ = 0.0f; base_avoidance_pct_ = 0; avoidance_base_ = 0; max_avoidance_ = 0; parry_ = 0.0f; parry_base_ = 0.0f; deflection_ = 0; deflection_base_ = 0; block_ = 0; block_base_ = 0; str_ = 0.0f; sta_ = 0.0f; agi_ = 0.0f; wis_ = 0.0f; intel_ = 0.0f; str_base_ = 0.0f; sta_base_ = 0.0f; agi_base_ = 0.0f; wis_base_ = 0.0f; intel_base_ = 0.0f; heat_ = 0; cold_ = 0; magic_ = 0; mental_ = 0; divine_ = 0; disease_ = 0; poison_ = 0; disease_base_ = 0; cold_base_ = 0; divine_base_ = 0; magic_base_ = 0; mental_base_ = 0; heat_base_ = 0; poison_base_ = 0; elemental_base_ = 0; noxious_base_ = 0; arcane_base_ = 0; coin_copper_ = 0; coin_silver_ = 0; coin_gold_ = 0; coin_plat_ = 0; bank_coin_copper_ = 0; bank_coin_silver_ = 0; bank_coin_gold_ = 0; bank_coin_plat_ = 0; status_points_ = 0; deity_ = std::string(""); weight_ = 0; max_weight_ = 0; tradeskill_class1_ = 0; tradeskill_class2_ = 0; tradeskill_class3_ = 0; account_age_base_ = 0; memset(account_age_bonus_,0,19); absorb_ = 0; xp_ = 0; xp_needed_ = 0; xp_debt_ = 0.0f; xp_yellow_ = 0; xp_yellow_vitality_bar_ = 0; xp_blue_vitality_bar_ = 0; xp_blue_ = 0; ts_xp_ = 0; ts_xp_needed_ = 0; tradeskill_exp_yellow_ = 0; tradeskill_exp_blue_ = 0; flags_ = 0; flags2_ = 0; xp_vitality_ = 0; tradeskill_xp_vitality_ = 0; mitigation_skill1_ = 0; mitigation_skill2_ = 0; mitigation_skill3_ = 0; mitigation_pve_ = 0; mitigation_pvp_ = 0; ability_modifier_ = 0; critical_mitigation_ = 0; block_chance_ = 0; uncontested_parry_ = 0; uncontested_block_ = 0; uncontested_dodge_ = 0; uncontested_riposte_ = 0; crit_chance_ = 0; crit_bonus_ = 0; potency_ = 0; hate_mod_ = 0; reuse_speed_ = 0; casting_speed_ = 0; recovery_speed_ = 0; spell_reuse_speed_ = 0; spell_multi_attack_ = 0; dps_ = 0; dps_multiplier_ = 0; attackspeed_ = 0; haste_ = 0; multi_attack_ = 0; flurry_ = 0; melee_ae_ = 0; strikethrough_ = 0; accuracy_ = 0; offensivespeed_ = 0; rain_ = 0; wind_ = 0; alignment_ = 0; pet_id_ = 0; pet_name_ = std::string(""); pet_health_pct_ = 0.0f; pet_power_pct_ = 0.0f; pet_movement_ = 0; pet_behavior_ = 0; vision_ = 0; breathe_underwater_ = 0; biography_ = std::string(""); drunk_ = 0; power_regen_ = 0; hp_regen_ = 0; power_regen_override_ = 0; hp_regen_override_ = 0; water_type_ = 0; flying_type_ = 0; no_interrupt_ = 0; interaction_flag_ = 0; tag1_ = 0; mood_ = 0; range_last_attack_time_ = 0; primary_last_attack_time_ = 0; secondary_last_attack_time_ = 0; primary_attack_delay_ = 0; secondary_attack_delay_ = 0; ranged_attack_delay_ = 0; primary_weapon_type_ = 0; secondary_weapon_type_ = 0; ranged_weapon_type_ = 0; primary_weapon_damage_low_ = 0; primary_weapon_damage_high_ = 0; secondary_weapon_damage_low_ = 0; secondary_weapon_damage_high_ = 0; ranged_weapon_damage_low_ = 0; ranged_weapon_damage_high_ = 0; wield_type_ = 0; attack_type_ = 0; primary_weapon_delay_ = 0; secondary_weapon_delay_ = 0; ranged_weapon_delay_ = 0; override_primary_weapon_ = 0; override_secondary_weapon_ = 0; override_ranged_weapon_ = 0; friendly_target_npc_ = 0; last_claim_time_ = 0; engaged_encounter_ = 0; } void SetInfoStruct(InfoStruct* oldStruct) { if(!oldStruct) return; std::lock_guard lk(classMutex); name_ = std::string(oldStruct->get_name()); class1_ = oldStruct->get_class1(); class2_ = oldStruct->get_class2(); class3_ = oldStruct->get_class3(); race_ = oldStruct->get_race(); gender_ = oldStruct->get_gender(); level_ = oldStruct->get_level(); max_level_ = oldStruct->get_max_level(); effective_level_ = oldStruct->get_effective_level(); tradeskill_level_ = oldStruct->get_tradeskill_level(); tradeskill_max_level_ = oldStruct->get_tradeskill_max_level(); cur_concentration_ = oldStruct->get_cur_concentration(); max_concentration_ = oldStruct->get_max_concentration(); cur_attack_ = oldStruct->get_cur_attack(); attack_base_ = oldStruct->get_attack_base(); cur_mitigation_ = oldStruct->get_cur_mitigation(); max_mitigation_ = oldStruct->get_max_mitigation(); mitigation_base_ = oldStruct->get_mitigation_base(); avoidance_display_ = oldStruct->get_avoidance_display(); cur_avoidance_ = oldStruct->get_cur_avoidance(); base_avoidance_pct_ = oldStruct->get_base_avoidance_pct(); avoidance_base_ = oldStruct->get_avoidance_base(); max_avoidance_ = oldStruct->get_max_avoidance(); parry_ = oldStruct->get_parry(); parry_base_ = oldStruct->get_parry_base(); deflection_ = oldStruct->get_deflection(); deflection_base_ = oldStruct->get_deflection_base(); block_ = oldStruct->get_block(); block_base_ = oldStruct->get_block_base(); str_ = oldStruct->get_str(); sta_ = oldStruct->get_sta(); agi_ = oldStruct->get_agi(); wis_ = oldStruct->get_wis(); intel_ = oldStruct->get_intel(); str_base_ = oldStruct->get_str_base(); sta_base_ = oldStruct->get_sta_base(); agi_base_ = oldStruct->get_agi_base(); wis_base_ = oldStruct->get_wis_base(); intel_base_ = oldStruct->get_intel_base(); heat_ = oldStruct->get_heat(); cold_ = oldStruct->get_cold(); magic_ = oldStruct->get_magic(); mental_ = oldStruct->get_mental(); divine_ = oldStruct->get_divine(); disease_ = oldStruct->get_disease(); poison_ = oldStruct->get_poison(); disease_base_ = oldStruct->get_disease_base(); cold_base_ = oldStruct->get_cold_base(); divine_base_ = oldStruct->get_divine_base(); magic_base_ = oldStruct->get_magic_base(); mental_base_ = oldStruct->get_mental_base(); heat_base_ = oldStruct->get_heat_base(); poison_base_ = oldStruct->get_poison_base(); elemental_base_ = oldStruct->get_elemental_base(); noxious_base_ = oldStruct->get_noxious_base(); arcane_base_ = oldStruct->get_arcane_base(); coin_copper_ = oldStruct->get_coin_copper(); coin_silver_ = oldStruct->get_coin_silver(); coin_gold_ = oldStruct->get_coin_gold(); coin_plat_ = oldStruct->get_coin_plat(); bank_coin_copper_ = oldStruct->get_bank_coin_copper(); bank_coin_silver_ = oldStruct->get_bank_coin_silver(); bank_coin_gold_ = oldStruct->get_bank_coin_gold(); bank_coin_plat_ = oldStruct->get_bank_coin_plat(); status_points_ = oldStruct->get_status_points(); deity_ = std::string(""); weight_ = oldStruct->get_weight(); max_weight_ = oldStruct->get_max_weight(); tradeskill_class1_ = oldStruct->get_tradeskill_class1(); tradeskill_class2_ = oldStruct->get_tradeskill_class2(); tradeskill_class3_ = oldStruct->get_tradeskill_class3(); account_age_base_ = oldStruct->get_account_age_base(); memset(account_age_bonus_,0,19); absorb_ = oldStruct->get_absorb(); xp_ = oldStruct->get_xp(); xp_needed_ = oldStruct->get_xp_needed(); xp_debt_ = oldStruct->get_xp_debt(); xp_yellow_ = oldStruct->get_xp_yellow(); xp_yellow_vitality_bar_ = oldStruct->get_xp_yellow_vitality_bar(); xp_blue_vitality_bar_ = oldStruct->get_xp_blue_vitality_bar(); xp_blue_ = oldStruct->get_xp_blue(); ts_xp_ = oldStruct->get_ts_xp(); ts_xp_needed_ = oldStruct->get_ts_xp_needed(); tradeskill_exp_yellow_ = oldStruct->get_tradeskill_exp_yellow(); tradeskill_exp_blue_ = oldStruct->get_tradeskill_exp_blue(); flags_ = oldStruct->get_flags(); flags2_ = oldStruct->get_flags2(); xp_vitality_ = oldStruct->get_xp_vitality(); tradeskill_xp_vitality_ = oldStruct->get_tradeskill_xp_vitality(); mitigation_skill1_ = oldStruct->get_mitigation_skill1(); mitigation_skill2_ = oldStruct->get_mitigation_skill2(); mitigation_skill3_ = oldStruct->get_mitigation_skill3(); mitigation_pve_ = oldStruct->get_mitigation_pve(); mitigation_pvp_ = oldStruct->get_mitigation_pvp(); ability_modifier_ = oldStruct->get_ability_modifier(); critical_mitigation_ = oldStruct->get_critical_mitigation(); block_chance_ = oldStruct->get_block_chance(); uncontested_parry_ = oldStruct->get_uncontested_parry(); uncontested_block_ = oldStruct->get_uncontested_block(); uncontested_dodge_ = oldStruct->get_uncontested_dodge(); uncontested_riposte_ = oldStruct->get_uncontested_riposte(); crit_chance_ = oldStruct->get_crit_chance(); crit_bonus_ = oldStruct->get_crit_bonus(); potency_ = oldStruct->get_potency(); hate_mod_ = oldStruct->get_hate_mod(); reuse_speed_ = oldStruct->get_reuse_speed(); casting_speed_ = oldStruct->get_casting_speed(); recovery_speed_ = oldStruct->get_recovery_speed(); spell_reuse_speed_ = oldStruct->get_spell_reuse_speed(); spell_multi_attack_ = oldStruct->get_spell_multi_attack(); dps_ = oldStruct->get_dps(); dps_multiplier_ = oldStruct->get_dps_multiplier(); attackspeed_ = oldStruct->get_attackspeed(); haste_ = oldStruct->get_haste(); multi_attack_ = oldStruct->get_multi_attack(); flurry_ = oldStruct->get_flurry(); melee_ae_ = oldStruct->get_melee_ae(); strikethrough_ = oldStruct->get_strikethrough(); accuracy_ = oldStruct->get_accuracy(); offensivespeed_ = oldStruct->get_offensivespeed(); rain_ = oldStruct->get_rain(); wind_ = oldStruct->get_wind(); alignment_ = oldStruct->get_alignment(); pet_id_ = oldStruct->get_pet_id(); pet_name_ = std::string(oldStruct->get_pet_name()); pet_health_pct_ = oldStruct->get_pet_health_pct(); pet_power_pct_ = oldStruct->get_pet_power_pct(); pet_movement_ = oldStruct->get_pet_movement(); pet_behavior_ = oldStruct->get_pet_behavior(); vision_ = oldStruct->get_vision(); breathe_underwater_ = oldStruct->get_breathe_underwater(); biography_ = std::string(oldStruct->get_biography()); drunk_ = oldStruct->get_drunk(); power_regen_ = oldStruct->get_power_regen(); hp_regen_ = oldStruct->get_hp_regen(); power_regen_override_ = oldStruct->get_power_regen_override(); hp_regen_override_ = oldStruct->get_hp_regen_override(); water_type_ = oldStruct->get_water_type(); flying_type_ = oldStruct->get_flying_type(); no_interrupt_ = oldStruct->get_no_interrupt(); interaction_flag_ = oldStruct->get_interaction_flag(); tag1_ = oldStruct->get_tag1(); mood_ = oldStruct->get_mood(); range_last_attack_time_ = oldStruct->get_range_last_attack_time(); primary_last_attack_time_ = oldStruct->get_primary_last_attack_time();; secondary_last_attack_time_ = oldStruct->get_secondary_last_attack_time();; primary_attack_delay_ = oldStruct->get_primary_attack_delay(); secondary_attack_delay_ = oldStruct->get_secondary_attack_delay(); ranged_attack_delay_ = oldStruct->get_ranged_attack_delay(); primary_weapon_type_ = oldStruct->get_primary_weapon_type(); secondary_weapon_type_ = oldStruct->get_secondary_weapon_type(); ranged_weapon_type_ = oldStruct->get_ranged_weapon_type(); primary_weapon_damage_low_ = oldStruct->get_primary_weapon_damage_low(); primary_weapon_damage_high_ = oldStruct->get_primary_weapon_damage_high(); secondary_weapon_damage_low_ = oldStruct->get_secondary_weapon_damage_low(); secondary_weapon_damage_high_ = oldStruct->get_secondary_weapon_damage_high(); ranged_weapon_damage_low_ = oldStruct->get_ranged_weapon_damage_low(); ranged_weapon_damage_high_ = oldStruct->get_ranged_weapon_damage_high(); wield_type_ = oldStruct->get_wield_type(); attack_type_ = oldStruct->get_attack_type(); primary_weapon_delay_ = oldStruct->get_primary_weapon_delay(); secondary_weapon_delay_ = oldStruct->get_secondary_weapon_delay(); ranged_weapon_delay_ = oldStruct->get_ranged_weapon_delay(); override_primary_weapon_ = oldStruct->get_override_primary_weapon(); override_secondary_weapon_ = oldStruct->get_override_secondary_weapon(); override_ranged_weapon_ = oldStruct->get_override_ranged_weapon(); friendly_target_npc_ = oldStruct->get_friendly_target_npc(); last_claim_time_ = oldStruct->get_last_claim_time(); engaged_encounter_ = oldStruct->get_engaged_encounter(); } //mutable std::shared_mutex mutex_; std::string get_name() { std::lock_guard lk(classMutex); return name_; } int8 get_class1() { std::lock_guard lk(classMutex); return class1_; } int8 get_class2() { std::lock_guard lk(classMutex); return class2_; } int8 get_class3() { std::lock_guard lk(classMutex); return class3_; } int8 get_race() { std::lock_guard lk(classMutex); return race_; } int8 get_gender() { std::lock_guard lk(classMutex); return gender_; } int16 get_level() { std::lock_guard lk(classMutex); return level_; } int16 get_max_level() { std::lock_guard lk(classMutex); return max_level_; } int16 get_effective_level() { std::lock_guard lk(classMutex); return effective_level_; } int16 get_tradeskill_level() { std::lock_guard lk(classMutex); return tradeskill_level_; } int16 get_tradeskill_max_level() { std::lock_guard lk(classMutex); return tradeskill_max_level_; } int8 get_cur_concentration() { std::lock_guard lk(classMutex); return cur_concentration_; } int8 get_max_concentration() { std::lock_guard lk(classMutex); return max_concentration_; } int16 get_cur_attack() { std::lock_guard lk(classMutex); return cur_attack_; } int16 get_attack_base() { std::lock_guard lk(classMutex); return attack_base_; } int16 get_cur_mitigation() { std::lock_guard lk(classMutex); return cur_mitigation_; } int16 get_max_mitigation() { std::lock_guard lk(classMutex); return max_mitigation_; } int16 get_mitigation_base() { std::lock_guard lk(classMutex); return mitigation_base_; } int16 get_avoidance_display() { std::lock_guard lk(classMutex); return avoidance_display_; } float get_cur_avoidance() { std::lock_guard lk(classMutex); return cur_avoidance_; } int16 get_base_avoidance_pct() { std::lock_guard lk(classMutex); return base_avoidance_pct_; } int16 get_avoidance_base() { std::lock_guard lk(classMutex); return avoidance_base_; } float get_parry() { std::lock_guard lk(classMutex); return parry_; } float get_parry_base() { std::lock_guard lk(classMutex); return parry_base_; } int16 get_max_avoidance() { std::lock_guard lk(classMutex); return max_avoidance_; } float get_deflection() { std::lock_guard lk(classMutex); return deflection_; } int16 get_deflection_base() { std::lock_guard lk(classMutex); return deflection_base_; } float get_block() { std::lock_guard lk(classMutex); return block_; } int16 get_block_base() { std::lock_guard lk(classMutex); return block_base_; } float get_str() { std::lock_guard lk(classMutex); return str_; } float get_sta() { std::lock_guard lk(classMutex); return sta_; } float get_agi() { std::lock_guard lk(classMutex); return agi_; } float get_wis() { std::lock_guard lk(classMutex); return wis_; } float get_intel() { std::lock_guard lk(classMutex); return intel_; } float get_str_base() { std::lock_guard lk(classMutex); return str_base_; } float get_sta_base() { std::lock_guard lk(classMutex); return sta_base_; } float get_agi_base() { std::lock_guard lk(classMutex); return agi_base_; } float get_wis_base() { std::lock_guard lk(classMutex); return wis_base_; } float get_intel_base() { std::lock_guard lk(classMutex); return intel_base_; } int16 get_heat() { std::lock_guard lk(classMutex); return heat_; } int16 get_cold() { std::lock_guard lk(classMutex); return cold_; } int16 get_magic() { std::lock_guard lk(classMutex); return magic_; } int16 get_mental() { std::lock_guard lk(classMutex); return mental_; } int16 get_divine() { std::lock_guard lk(classMutex); return divine_; } int16 get_disease() { std::lock_guard lk(classMutex); return disease_; } int16 get_poison() { std::lock_guard lk(classMutex); return poison_; } int16 get_disease_base() { std::lock_guard lk(classMutex); return disease_base_; } int16 get_cold_base() { std::lock_guard lk(classMutex); return cold_base_; } int16 get_divine_base() { std::lock_guard lk(classMutex); return divine_base_; } int16 get_magic_base() { std::lock_guard lk(classMutex); return magic_base_; } int16 get_mental_base() { std::lock_guard lk(classMutex); return mental_base_; } int16 get_heat_base() { std::lock_guard lk(classMutex); return heat_base_; } int16 get_poison_base() { std::lock_guard lk(classMutex); return poison_base_; } int16 get_elemental_base() { std::lock_guard lk(classMutex); return elemental_base_; } int16 get_noxious_base() { std::lock_guard lk(classMutex); return noxious_base_; } int16 get_arcane_base() { std::lock_guard lk(classMutex); return arcane_base_; } int32 get_coin_copper() { std::lock_guard lk(classMutex); return coin_copper_; } int32 get_coin_silver() { std::lock_guard lk(classMutex); return coin_silver_; } int32 get_coin_gold() { std::lock_guard lk(classMutex); return coin_gold_; } int32 get_coin_plat() { std::lock_guard lk(classMutex); return coin_plat_; } int32 get_bank_coin_copper() { std::lock_guard lk(classMutex); return bank_coin_copper_; } int32 get_bank_coin_silver() { std::lock_guard lk(classMutex); return bank_coin_silver_; } int32 get_bank_coin_gold() { std::lock_guard lk(classMutex); return bank_coin_gold_; } int32 get_bank_coin_plat() { std::lock_guard lk(classMutex); return bank_coin_plat_; } int32 get_status_points() { std::lock_guard lk(classMutex); return status_points_; } std::string get_deity() { std::lock_guard lk(classMutex); return deity_; } int32 get_weight() { std::lock_guard lk(classMutex); return weight_; } int32 get_max_weight() { std::lock_guard lk(classMutex); return max_weight_; } //SpellEffects* & get_spell_effects() { std::lock_guard lk(classMutex); return spell_effects_; } //MaintainedEffects* & get_maintained_effects() { std::lock_guard lk(classMutex); return maintained_effects_; } int8 get_tradeskill_class1() { std::lock_guard lk(classMutex); return tradeskill_class1_; } int8 get_tradeskill_class2() { std::lock_guard lk(classMutex); return tradeskill_class2_; } int8 get_tradeskill_class3() { std::lock_guard lk(classMutex); return tradeskill_class3_; } int32 get_account_age_base() { std::lock_guard lk(classMutex); return account_age_base_; } int8 get_account_age_bonus(int8 field) { std::lock_guard lk(classMutex); return account_age_bonus_[field]; } int16 get_absorb() { std::lock_guard lk(classMutex); return absorb_; } int32 get_xp() { std::lock_guard lk(classMutex); return xp_; } int32 get_xp_needed() { std::lock_guard lk(classMutex); return xp_needed_; } float get_xp_debt() { std::lock_guard lk(classMutex); return xp_debt_; } int16 get_xp_yellow() { std::lock_guard lk(classMutex); return xp_yellow_; } int16 get_xp_yellow_vitality_bar() { std::lock_guard lk(classMutex); return xp_yellow_vitality_bar_; } int16 get_xp_blue_vitality_bar() { std::lock_guard lk(classMutex); return xp_blue_vitality_bar_; } int16 get_xp_blue() { std::lock_guard lk(classMutex); return xp_blue_; } int32 get_ts_xp() { std::lock_guard lk(classMutex); return ts_xp_; } int32 get_ts_xp_needed() { std::lock_guard lk(classMutex); return ts_xp_needed_; } int16 get_tradeskill_exp_yellow() { std::lock_guard lk(classMutex); return tradeskill_exp_yellow_; } int16 get_tradeskill_exp_blue() { std::lock_guard lk(classMutex); return tradeskill_exp_blue_; } int32 get_flags() { std::lock_guard lk(classMutex); return flags_; } int32 get_flags2() { std::lock_guard lk(classMutex); return flags2_; } float get_xp_vitality() { std::lock_guard lk(classMutex); return xp_vitality_; } float get_tradeskill_xp_vitality() { std::lock_guard lk(classMutex); return tradeskill_xp_vitality_; } int16 get_mitigation_skill1() { std::lock_guard lk(classMutex); return mitigation_skill1_; } int16 get_mitigation_skill2() { std::lock_guard lk(classMutex); return mitigation_skill2_; } int16 get_mitigation_skill3() { std::lock_guard lk(classMutex); return mitigation_skill3_; } int16 get_mitigation_pve() { std::lock_guard lk(classMutex); return mitigation_pve_; } int16 get_mitigation_pvp() { std::lock_guard lk(classMutex); return mitigation_pvp_; } float get_ability_modifier() { std::lock_guard lk(classMutex); return ability_modifier_; } float get_critical_mitigation() { std::lock_guard lk(classMutex); return critical_mitigation_; } float get_block_chance() { std::lock_guard lk(classMutex); return block_chance_; } float get_uncontested_parry() { std::lock_guard lk(classMutex); return uncontested_parry_; } float get_uncontested_block() { std::lock_guard lk(classMutex); return uncontested_block_; } float get_uncontested_dodge() { std::lock_guard lk(classMutex); return uncontested_dodge_; } float get_uncontested_riposte() { std::lock_guard lk(classMutex); return uncontested_riposte_; } float get_crit_chance() { std::lock_guard lk(classMutex); return crit_chance_; } float get_crit_bonus() { std::lock_guard lk(classMutex); return crit_bonus_; } float get_potency() { std::lock_guard lk(classMutex); return potency_; } float get_hate_mod() { std::lock_guard lk(classMutex); return hate_mod_; } float get_reuse_speed() { std::lock_guard lk(classMutex); return reuse_speed_; } float get_casting_speed() { std::lock_guard lk(classMutex); return casting_speed_; } float get_recovery_speed() { std::lock_guard lk(classMutex); return recovery_speed_; } float get_spell_reuse_speed() { std::lock_guard lk(classMutex); return spell_reuse_speed_; } float get_spell_multi_attack() { std::lock_guard lk(classMutex); return spell_multi_attack_; } float get_dps() { std::lock_guard lk(classMutex); return dps_; } float get_dps_multiplier() { std::lock_guard lk(classMutex); return dps_multiplier_; } float get_attackspeed() { std::lock_guard lk(classMutex); return attackspeed_; } float get_haste() { std::lock_guard lk(classMutex); return haste_; } float get_multi_attack() { std::lock_guard lk(classMutex); return multi_attack_; } float get_flurry() { std::lock_guard lk(classMutex); return flurry_; } float get_melee_ae() { std::lock_guard lk(classMutex); return melee_ae_; } float get_strikethrough() { std::lock_guard lk(classMutex); return strikethrough_; } float get_accuracy() { std::lock_guard lk(classMutex); return accuracy_; } float get_offensivespeed() { std::lock_guard lk(classMutex); return offensivespeed_; } float get_rain() { std::lock_guard lk(classMutex); return rain_; } float get_wind() { std::lock_guard lk(classMutex); return wind_; } sint8 get_alignment() { std::lock_guard lk(classMutex); return alignment_; } int32 get_pet_id() { std::lock_guard lk(classMutex); return pet_id_; } std::string get_pet_name() { std::lock_guard lk(classMutex); return pet_name_; } float get_pet_health_pct() { std::lock_guard lk(classMutex); return pet_health_pct_; } float get_pet_power_pct() { std::lock_guard lk(classMutex); return pet_power_pct_; } int8 get_pet_movement() { std::lock_guard lk(classMutex); return pet_movement_; } int8 get_pet_behavior() { std::lock_guard lk(classMutex); return pet_behavior_; } int32 get_vision() { std::lock_guard lk(classMutex); return vision_; } int8 get_breathe_underwater() { std::lock_guard lk(classMutex); return breathe_underwater_; } std::string get_biography() { std::lock_guard lk(classMutex); return biography_; } float get_drunk() { std::lock_guard lk(classMutex); return drunk_; } sint16 get_power_regen() { std::lock_guard lk(classMutex); return power_regen_; } sint16 get_hp_regen() { std::lock_guard lk(classMutex); return hp_regen_; } int8 get_power_regen_override() { std::lock_guard lk(classMutex); return power_regen_override_; } int8 get_hp_regen_override() { std::lock_guard lk(classMutex); return hp_regen_override_; } int8 get_water_type() { std::lock_guard lk(classMutex); return water_type_; } int8 get_flying_type() { std::lock_guard lk(classMutex); return flying_type_; } int8 get_no_interrupt() { std::lock_guard lk(classMutex); return no_interrupt_; } int8 get_interaction_flag() { std::lock_guard lk(classMutex); return interaction_flag_; } int8 get_tag1() { std::lock_guard lk(classMutex); return tag1_; } int16 get_mood() { std::lock_guard lk(classMutex); return mood_; } int32 get_range_last_attack_time() { std::lock_guard lk(classMutex); return range_last_attack_time_; } int32 get_primary_last_attack_time() { std::lock_guard lk(classMutex); return primary_last_attack_time_; } int32 get_secondary_last_attack_time() { std::lock_guard lk(classMutex); return secondary_last_attack_time_; } int16 get_primary_attack_delay() { std::lock_guard lk(classMutex); return primary_attack_delay_; } int16 get_secondary_attack_delay() { std::lock_guard lk(classMutex); return secondary_attack_delay_; } int16 get_ranged_attack_delay() { std::lock_guard lk(classMutex); return ranged_attack_delay_; } int8 get_primary_weapon_type() { std::lock_guard lk(classMutex); return primary_weapon_type_; } int8 get_secondary_weapon_type() { std::lock_guard lk(classMutex); return secondary_weapon_type_; } int8 get_ranged_weapon_type() { std::lock_guard lk(classMutex); return ranged_weapon_type_; } int32 get_primary_weapon_damage_low() { std::lock_guard lk(classMutex); return primary_weapon_damage_low_; } int32 get_primary_weapon_damage_high() { std::lock_guard lk(classMutex); return primary_weapon_damage_high_; } int32 get_secondary_weapon_damage_low() { std::lock_guard lk(classMutex); return secondary_weapon_damage_low_; } int32 get_secondary_weapon_damage_high() { std::lock_guard lk(classMutex); return secondary_weapon_damage_high_; } int32 get_ranged_weapon_damage_low() { std::lock_guard lk(classMutex); return ranged_weapon_damage_low_; } int32 get_ranged_weapon_damage_high() { std::lock_guard lk(classMutex); return ranged_weapon_damage_high_; } int8 get_wield_type() { std::lock_guard lk(classMutex); return wield_type_; } int8 get_attack_type() { std::lock_guard lk(classMutex); return attack_type_; } int16 get_primary_weapon_delay() { std::lock_guard lk(classMutex); return primary_weapon_delay_; } int16 get_secondary_weapon_delay() { std::lock_guard lk(classMutex); return secondary_weapon_delay_; } int16 get_ranged_weapon_delay() { std::lock_guard lk(classMutex); return ranged_weapon_delay_; } int8 get_override_primary_weapon() { std::lock_guard lk(classMutex); return override_primary_weapon_; } int8 get_override_secondary_weapon() { std::lock_guard lk(classMutex); return override_secondary_weapon_; } int8 get_override_ranged_weapon() { std::lock_guard lk(classMutex); return override_ranged_weapon_; } int8 get_friendly_target_npc() { std::lock_guard lk(classMutex); return friendly_target_npc_; } int32 get_last_claim_time() { std::lock_guard lk(classMutex); return last_claim_time_; } int8 get_engaged_encounter() { std::lock_guard lk(classMutex); return engaged_encounter_; } void set_name(std::string value) { std::lock_guard lk(classMutex); name_ = value; } void set_deity(std::string value) { std::lock_guard lk(classMutex); deity_ = value; } void set_class1(int8 value) { std::lock_guard lk(classMutex); class1_ = value; } void set_class2(int8 value) { std::lock_guard lk(classMutex); class2_ = value; } void set_class3(int8 value) { std::lock_guard lk(classMutex); class3_ = value; } void set_race(int8 value) { std::lock_guard lk(classMutex); race_ = value; } void set_gender(int8 value) { std::lock_guard lk(classMutex); gender_ = value; } void set_level(int16 value) { std::lock_guard lk(classMutex); level_ = value; } void set_max_level(int16 value) { std::lock_guard lk(classMutex); max_level_ = value; } void set_effective_level(int16 value) { std::lock_guard lk(classMutex); effective_level_ = value; } void set_cur_concentration(int8 value) { std::lock_guard lk(classMutex); cur_concentration_ = value; } void set_max_concentration(int8 value) { std::lock_guard lk(classMutex); max_concentration_ = value; } void add_cur_concentration(int8 value) { std::lock_guard lk(classMutex); cur_concentration_ += value; } void add_max_concentration(int8 value) { std::lock_guard lk(classMutex); max_concentration_ += value; } void set_cur_attack(int16 value) { std::lock_guard lk(classMutex); cur_attack_ = value; } void set_attack_base(int16 value) { std::lock_guard lk(classMutex); attack_base_ = value; } void set_cur_mitigation(int16 value) { std::lock_guard lk(classMutex); cur_mitigation_ = value; } void set_max_mitigation(int16 value) { std::lock_guard lk(classMutex); max_mitigation_ = value; } void set_mitigation_base(int16 value) { std::lock_guard lk(classMutex); mitigation_base_ = value; } void add_mitigation_base(int16 value) { std::lock_guard lk(classMutex); mitigation_base_ += value; } void set_avoidance_display(int16 value) { std::lock_guard lk(classMutex); avoidance_display_ = value; } void set_cur_avoidance(float value) { std::lock_guard lk(classMutex); cur_avoidance_ = value; } void set_base_avoidance_pct(int16 value) { std::lock_guard lk(classMutex); base_avoidance_pct_ = value; } void set_avoidance_base(int16 value) { std::lock_guard lk(classMutex); avoidance_base_ = value; } void set_max_avoidance(int16 value) { std::lock_guard lk(classMutex); max_avoidance_ = value; } void set_parry(float value) { std::lock_guard lk(classMutex); parry_ = value; } void set_parry_base(float value) { std::lock_guard lk(classMutex); parry_base_ = value; } void set_deflection(int16 value) { std::lock_guard lk(classMutex); deflection_ = value; } void set_deflection_base(float value) { std::lock_guard lk(classMutex); deflection_base_ = value; } void set_block(float value) { std::lock_guard lk(classMutex); block_ = value; } void set_block_base(int16 value) { std::lock_guard lk(classMutex); block_base_ = value; } void set_str(float value) { std::lock_guard lk(classMutex); str_ = value; } void set_sta(float value) { std::lock_guard lk(classMutex); sta_ = value; } void set_agi(float value) { std::lock_guard lk(classMutex); agi_ = value; } void set_wis(float value) { std::lock_guard lk(classMutex); wis_ = value; } void set_intel(float value) { std::lock_guard lk(classMutex); intel_ = value; } void add_str(float value) { std::lock_guard lk(classMutex); if(str_ + value < 0.0f) str_ = 0.0f; else str_ += value; } void add_sta(float value) { std::lock_guard lk(classMutex); if(sta_ + value < 0.0f) sta_ = 0.0f; else sta_ += value; } void add_agi(float value) { std::lock_guard lk(classMutex); if(agi_ + value < 0.0f) agi_ = 0.0f; else agi_ += value; } void add_wis(float value) { std::lock_guard lk(classMutex); if(wis_ + value < 0.0f) wis_ = 0.0f; else wis_ += value; } void add_intel(float value) { std::lock_guard lk(classMutex); if(intel_ + value < 0.0f) intel_ = 0.0f; else intel_ += value; } void set_str_base(float value) { std::lock_guard lk(classMutex); str_base_ = value; } void set_sta_base(float value) { std::lock_guard lk(classMutex); sta_base_ = value; } void set_agi_base(float value) { std::lock_guard lk(classMutex); agi_base_ = value; } void set_wis_base(float value) { std::lock_guard lk(classMutex); wis_base_ = value; } void set_intel_base(float value) { std::lock_guard lk(classMutex); intel_base_ = value; } void set_heat(int16 value) { std::lock_guard lk(classMutex); heat_ = value; } void set_cold(int16 value) { std::lock_guard lk(classMutex); cold_ = value; } void set_magic(int16 value) { std::lock_guard lk(classMutex); magic_ = value; } void set_mental(int16 value) { std::lock_guard lk(classMutex); mental_ = value; } void set_divine(int16 value) { std::lock_guard lk(classMutex); divine_ = value; } void set_disease(int16 value) { std::lock_guard lk(classMutex); disease_ = value; } void set_poison(int16 value) { std::lock_guard lk(classMutex); poison_ = value; } void add_heat(sint16 value) { std::lock_guard lk(classMutex); if((sint32)heat_ + value < 0) heat_ = 0; else heat_ += value; } void add_cold(sint16 value) { std::lock_guard lk(classMutex); if((sint32)cold_ + value < 0) cold_ = 0; else cold_ += value; } void add_magic(sint16 value) { std::lock_guard lk(classMutex); if((sint32)magic_ + value < 0) magic_ = 0; else magic_ += value; } void add_mental(sint16 value) { std::lock_guard lk(classMutex); if((sint32)mental_ + value < 0) mental_ = 0; else mental_ += value; } void add_divine(sint16 value) { std::lock_guard lk(classMutex); if((sint32)divine_ + value < 0) divine_ = 0; else divine_ += value; } void add_disease(sint16 value) { std::lock_guard lk(classMutex); if((sint32)disease_ + value < 0) disease_ = 0; else disease_ += value; } void add_poison(sint16 value) { std::lock_guard lk(classMutex); if((sint32)poison_ + value < 0) poison_ = 0; else poison_ += value; } void set_disease_base(int16 value) { std::lock_guard lk(classMutex); disease_base_ = value; } void set_cold_base(int16 value) { std::lock_guard lk(classMutex); cold_base_ = value; } void set_divine_base(int16 value) { std::lock_guard lk(classMutex); divine_base_ = value; } void set_magic_base(int16 value) { std::lock_guard lk(classMutex); magic_base_ = value; } void set_mental_base(int16 value) { std::lock_guard lk(classMutex); mental_base_ = value; } void set_heat_base(int16 value) { std::lock_guard lk(classMutex); heat_base_ = value; } void set_poison_base(int16 value) { std::lock_guard lk(classMutex); poison_base_ = value; } void set_elemental_base(int16 value) { std::lock_guard lk(classMutex); elemental_base_ = value; } void set_noxious_base(int16 value) { std::lock_guard lk(classMutex); noxious_base_ = value; } void set_arcane_base(int16 value) { std::lock_guard lk(classMutex); arcane_base_ = value; } void set_tradeskill_level(int16 value) { std::lock_guard lk(classMutex); tradeskill_level_ = value; } void set_tradeskill_max_level(int16 value) { std::lock_guard lk(classMutex); tradeskill_max_level_ = value; } void set_tradeskill_class1(int8 value) { std::lock_guard lk(classMutex); tradeskill_class1_ = value; } void set_tradeskill_class2(int8 value) { std::lock_guard lk(classMutex); tradeskill_class2_ = value; } void set_tradeskill_class3(int8 value) { std::lock_guard lk(classMutex); tradeskill_class3_ = value; } void set_account_age_base(int32 value) { std::lock_guard lk(classMutex); account_age_base_ = value; } void set_xp_vitality(float value) { std::lock_guard lk(classMutex); xp_vitality_ = value; } void add_xp_vitality(float value) { std::lock_guard lk(classMutex); xp_vitality_ += value; } void set_tradeskill_xp_vitality(float value) { std::lock_guard lk(classMutex); tradeskill_xp_vitality_ = value; } void set_absorb(int16 value) { std::lock_guard lk(classMutex); absorb_ = value; } void set_xp(int32 value) { std::lock_guard lk(classMutex); xp_ = value; } void set_xp_needed(int32 value) { std::lock_guard lk(classMutex); xp_needed_ = value; } void set_xp_debt(float value) { std::lock_guard lk(classMutex); xp_debt_ = value; } void set_xp_yellow(int16 value) { std::lock_guard lk(classMutex); xp_yellow_ = value; } void set_xp_blue(int16 value) { std::lock_guard lk(classMutex); xp_blue_ = value; } void set_xp_yellow_vitality_bar(int16 value) { std::lock_guard lk(classMutex); xp_yellow_vitality_bar_ = value; } void set_xp_blue_vitality_bar(int16 value) { std::lock_guard lk(classMutex); xp_blue_vitality_bar_ = value; } void set_ts_xp(int32 value) { std::lock_guard lk(classMutex); ts_xp_ = value; } void set_ts_xp_needed(int32 value) { std::lock_guard lk(classMutex); ts_xp_needed_ = value; } void set_tradeskill_exp_yellow(int16 value) { std::lock_guard lk(classMutex); tradeskill_exp_yellow_ = value; } void set_tradeskill_exp_blue(int16 value) { std::lock_guard lk(classMutex); tradeskill_exp_blue_ = value; } void set_flags(int32 value) { std::lock_guard lk(classMutex); flags_ = value; } void set_flags2(int32 value) { std::lock_guard lk(classMutex); flags2_ = value; } void set_coin_plat(int32 value) { std::lock_guard lk(classMutex); coin_plat_ = value; } void set_coin_gold(int32 value) { std::lock_guard lk(classMutex); coin_gold_ = value; } void set_coin_silver(int32 value) { std::lock_guard lk(classMutex); coin_silver_ = value; } void set_coin_copper(int32 value) { std::lock_guard lk(classMutex); coin_copper_ = value; } void add_coin_plat(int32 value) { std::lock_guard lk(classMutex); if((sint64)coin_plat_ + value < 0) coin_plat_ = 0; else coin_plat_ += value; } void add_coin_gold(int32 value) { std::lock_guard lk(classMutex); if((sint64)coin_gold_ + value < 0) coin_gold_ = 0; else coin_gold_ += value; } void add_coin_silver(int32 value) { std::lock_guard lk(classMutex); if((sint64)coin_silver_ + value < 0) coin_silver_ = 0; else coin_silver_ += value; } void add_coin_copper(int32 value) { std::lock_guard lk(classMutex); if((sint64)coin_copper_ + value < 0) coin_copper_ = 0; else coin_copper_ += value; } void set_bank_coin_plat(int32 value) { std::lock_guard lk(classMutex); bank_coin_plat_ = value; } void set_bank_coin_gold(int32 value) { std::lock_guard lk(classMutex); bank_coin_gold_ = value; } void set_bank_coin_silver(int32 value) { std::lock_guard lk(classMutex); bank_coin_silver_ = value; } void set_bank_coin_copper(int32 value) { std::lock_guard lk(classMutex); bank_coin_copper_ = value; } void add_bank_coin_plat(int32 value) { std::lock_guard lk(classMutex); if((sint64)bank_coin_plat_ + value < 0) bank_coin_plat_ = 0; else bank_coin_plat_ += value; } void add_bank_coin_gold(int32 value) { std::lock_guard lk(classMutex); if((sint64)bank_coin_gold_ + value < 0) bank_coin_gold_ = 0; else bank_coin_gold_ += value; } void add_bank_coin_silver(int32 value) { std::lock_guard lk(classMutex); if((sint64)bank_coin_silver_ + value < 0) bank_coin_silver_ = 0; else bank_coin_silver_ += value; } void add_bank_coin_copper(int32 value) { std::lock_guard lk(classMutex); if((sint64)bank_coin_copper_ + value < 0) bank_coin_copper_ = 0; else bank_coin_copper_ += value; } void set_status_points(int32 value) { std::lock_guard lk(classMutex); status_points_ = value; } void add_status_points(int32 value) { std::lock_guard lk(classMutex); if((sint64)status_points_ + value < 0) status_points_ = 0; else status_points_ += value; } bool subtract_status_points(int32 value) { std::lock_guard lk(classMutex); if(value > status_points_) return false; status_points_ -= value; return true; } void set_mitigation_skill1(int16 value) { std::lock_guard lk(classMutex); mitigation_skill1_ = value; } void set_mitigation_skill2(int16 value) { std::lock_guard lk(classMutex); mitigation_skill2_ = value; } void set_mitigation_skill3(int16 value) { std::lock_guard lk(classMutex); mitigation_skill3_ = value; } void set_mitigation_pve(int16 value) { std::lock_guard lk(classMutex); mitigation_pve_ = value; } void set_mitigation_pvp(int16 value) { std::lock_guard lk(classMutex); mitigation_pvp_ = value; } void add_mitigation_skill1(int16 value) { std::lock_guard lk(classMutex); if((sint32)mitigation_skill1_ + value < 0) mitigation_skill1_ = 0; else mitigation_skill1_ += value; } void add_mitigation_skill2(int16 value) { std::lock_guard lk(classMutex); if((sint32)mitigation_skill2_ + value < 0) mitigation_skill2_ = 0; else mitigation_skill2_ += value; } void add_mitigation_skill3(int16 value) { std::lock_guard lk(classMutex); if((sint32)mitigation_skill3_ + value < 0) mitigation_skill3_ = 0; else mitigation_skill3_ += value; } void set_ability_modifier(float value) { std::lock_guard lk(classMutex); ability_modifier_ = value; } void add_ability_modifier(float value) { std::lock_guard lk(classMutex); if(ability_modifier_ + value < 0.0f) ability_modifier_ = 0.0f; else ability_modifier_ += value; } void set_critical_mitigation(float value) { std::lock_guard lk(classMutex); critical_mitigation_ = value; } void add_critical_mitigation(float value) { std::lock_guard lk(classMutex); if(critical_mitigation_ + value < 0.0f) critical_mitigation_ = 0.0f; else critical_mitigation_ += value; } void set_block_chance(float value) { std::lock_guard lk(classMutex); block_chance_ = value; } void set_uncontested_parry(float value) { std::lock_guard lk(classMutex); uncontested_parry_ = value; } void set_uncontested_block(float value) { std::lock_guard lk(classMutex); uncontested_block_ = value; } void set_uncontested_dodge(float value) { std::lock_guard lk(classMutex); uncontested_dodge_ = value; } void set_uncontested_riposte(float value) { std::lock_guard lk(classMutex); uncontested_riposte_ = value; } void set_crit_chance(float value) { std::lock_guard lk(classMutex); crit_chance_ = value; } void set_crit_bonus(float value) { std::lock_guard lk(classMutex); crit_bonus_ = value; } void set_potency(float value) { std::lock_guard lk(classMutex); potency_ = value; } void set_hate_mod(float value) { std::lock_guard lk(classMutex); hate_mod_ = value; } void set_reuse_speed(float value) { std::lock_guard lk(classMutex); reuse_speed_ = value; } void set_casting_speed(float value) { std::lock_guard lk(classMutex); casting_speed_ = value; } void set_recovery_speed(float value) { std::lock_guard lk(classMutex); recovery_speed_ = value; } void set_spell_reuse_speed(float value) { std::lock_guard lk(classMutex); spell_reuse_speed_ = value; } void set_spell_multi_attack(float value) { std::lock_guard lk(classMutex); spell_multi_attack_ = value; } void set_dps(float value) { std::lock_guard lk(classMutex); dps_ = value; } void set_dps_multiplier(float value) { std::lock_guard lk(classMutex); dps_multiplier_ = value; } void set_attackspeed(float value) { std::lock_guard lk(classMutex); attackspeed_ = value; } void set_haste(float value) { std::lock_guard lk(classMutex); haste_ = value; } void set_multi_attack(float value) { std::lock_guard lk(classMutex); multi_attack_ = value; } void set_flurry(float value) { std::lock_guard lk(classMutex); flurry_ = value; } void set_melee_ae(float value) { std::lock_guard lk(classMutex); melee_ae_ = value; } void set_strikethrough(float value) { std::lock_guard lk(classMutex); strikethrough_ = value; } void set_accuracy(float value) { std::lock_guard lk(classMutex); accuracy_ = value; } void set_offensivespeed(float value) { std::lock_guard lk(classMutex); offensivespeed_ = value; } void set_rain(float value) { std::lock_guard lk(classMutex); rain_ = value; } void set_wind(float value) { std::lock_guard lk(classMutex); wind_ = value; } void add_block_chance(float value) { std::lock_guard lk(classMutex); if(block_chance_ + value < 0.0f) block_chance_ = 0.0f; else block_chance_ += value; } void add_uncontested_parry(float value) { std::lock_guard lk(classMutex); if(uncontested_parry_ + value < 0.0f) uncontested_parry_ = 0.0f; else uncontested_parry_ += value; } void add_uncontested_block(float value) { std::lock_guard lk(classMutex); if(uncontested_block_ + value < 0.0f) uncontested_block_ = 0.0f; else uncontested_block_ += value; } void add_uncontested_dodge(float value) { std::lock_guard lk(classMutex); if(uncontested_dodge_ + value < 0.0f) uncontested_dodge_ = 0.0f; else uncontested_dodge_ += value; } void add_uncontested_riposte(float value) { std::lock_guard lk(classMutex); if(uncontested_riposte_ + value < 0.0f) uncontested_riposte_ = 0.0f; else uncontested_riposte_ += value; } void add_crit_chance(float value) { std::lock_guard lk(classMutex); if(crit_chance_ + value < 0.0f) crit_chance_ = 0.0f; else crit_chance_ += value; } void add_crit_bonus(float value) { std::lock_guard lk(classMutex); if(crit_bonus_ + value < 0.0f) crit_bonus_ = 0.0f; else crit_bonus_ += value; } void add_potency(float value) { std::lock_guard lk(classMutex); if(potency_ + value < 0.0f) potency_ = 0.0f; else potency_ += value; } void add_hate_mod(float value) { std::lock_guard lk(classMutex); if(hate_mod_ + value < 0.0f) hate_mod_ = 0.0f; else hate_mod_ += value; } void add_reuse_speed(float value) { std::lock_guard lk(classMutex); if(reuse_speed_ + value < 0.0f) reuse_speed_ = 0.0f; else reuse_speed_ += value; } void add_casting_speed(float value) { std::lock_guard lk(classMutex); if(casting_speed_ + value < 0.0f) casting_speed_ = 0.0f; else casting_speed_ += value; } void add_recovery_speed(float value) { std::lock_guard lk(classMutex); if(recovery_speed_ + value < 0.0f) recovery_speed_ = 0.0f; else recovery_speed_ += value; } void add_spell_reuse_speed(float value) { std::lock_guard lk(classMutex); if(spell_reuse_speed_ + value < 0.0f) spell_reuse_speed_ = 0.0f; else spell_reuse_speed_ += value; } void add_spell_multi_attack(float value) { std::lock_guard lk(classMutex); if(spell_multi_attack_ + value < 0.0f) spell_multi_attack_ = 0.0f; else spell_multi_attack_ += value; } void add_dps(float value) { std::lock_guard lk(classMutex); if(dps_ + value < 0.0f) dps_ = 0.0f; else dps_ += value; } void add_dps_multiplier(float value) { std::lock_guard lk(classMutex); if(dps_multiplier_ + value < 0.0f) dps_multiplier_ = 0.0f; else dps_multiplier_ += value; } void add_attackspeed(float value) { std::lock_guard lk(classMutex); if(attackspeed_ + value < 0.0f) attackspeed_ = 0.0f; else attackspeed_ += value; } void add_haste(float value) { std::lock_guard lk(classMutex); if(haste_ + value < 0.0f) haste_ = 0.0f; else haste_ += value; } void add_multi_attack(float value) { std::lock_guard lk(classMutex); if(multi_attack_ + value < 0.0f) multi_attack_ = 0.0f; else multi_attack_ += value; } void add_flurry(float value) { std::lock_guard lk(classMutex); if(flurry_ + value < 0.0f) flurry_ = 0.0f; else flurry_ += value; } void add_melee_ae(float value) { std::lock_guard lk(classMutex); if(melee_ae_ + value < 0.0f) melee_ae_ = 0.0f; else melee_ae_ += value; } void add_strikethrough(float value) { std::lock_guard lk(classMutex); if(strikethrough_ + value < 0.0f) strikethrough_ = 0.0f; else strikethrough_ += value; } void add_accuracy(float value) { std::lock_guard lk(classMutex); if(accuracy_ + value < 0.0f) accuracy_ = 0.0f; else accuracy_ += value; } void add_offensivespeed(float value) { std::lock_guard lk(classMutex); if(offensivespeed_ + value < 0.0f) offensivespeed_ = 0.0f; else offensivespeed_ += value; } void add_rain(float value) { std::lock_guard lk(classMutex); if(rain_ + value < 0.0f) rain_ = 0.0f; else rain_ += value; } void add_wind(float value) { std::lock_guard lk(classMutex); if(wind_ + value < 0.0f) wind_ = 0.0f; else wind_ += value; } void set_alignment(int8 value) { std::lock_guard lk(classMutex); alignment_ = value; } void set_pet_id(int32 value) { std::lock_guard lk(classMutex); pet_id_ = value; } void set_pet_name(std::string value) { std::lock_guard lk(classMutex); pet_name_ = value; } void set_pet_movement(int8 value) { std::lock_guard lk(classMutex); pet_movement_ = value; } void set_pet_behavior(int8 value) { std::lock_guard lk(classMutex); pet_behavior_ = value; } void set_pet_health_pct(float value) { std::lock_guard lk(classMutex); pet_health_pct_ = value; } void set_pet_power_pct(float value) { std::lock_guard lk(classMutex); pet_power_pct_ = value; } void set_weight(int32 value) { std::lock_guard lk(classMutex); weight_ = value; } void set_max_weight(int32 value) { std::lock_guard lk(classMutex); max_weight_ = value; } void set_vision(int32 value) { std::lock_guard lk(classMutex); vision_ = value; } void set_breathe_underwater(int8 value) { std::lock_guard lk(classMutex); breathe_underwater_ = value; } void set_drunk(float value) { std::lock_guard lk(classMutex); drunk_ = value; } void set_biography(std::string value) { std::lock_guard lk(classMutex); biography_ = value; } void set_power_regen(sint16 value) { std::lock_guard lk(classMutex); power_regen_ = value; } void set_hp_regen(sint16 value) { std::lock_guard lk(classMutex); hp_regen_ = value; } void set_power_regen_override(int8 value) { std::lock_guard lk(classMutex); power_regen_override_ = value; } void set_hp_regen_override(int8 value) { std::lock_guard lk(classMutex); hp_regen_override_ = value; } void set_water_type(int8 value) { std::lock_guard lk(classMutex); water_type_ = value; } void set_flying_type(int8 value) { std::lock_guard lk(classMutex); flying_type_ = value; } void set_no_interrupt(int8 value) { std::lock_guard lk(classMutex); no_interrupt_ = value; } void set_interaction_flag(int8 value) { std::lock_guard lk(classMutex); interaction_flag_ = value; } void set_tag1(int8 value) { std::lock_guard lk(classMutex); tag1_ = value; } void set_mood(int16 value) { std::lock_guard lk(classMutex); mood_ = value; } void set_range_last_attack_time(int32 value) { std::lock_guard lk(classMutex); range_last_attack_time_ = value; } void set_primary_last_attack_time(int32 value) { std::lock_guard lk(classMutex); primary_last_attack_time_ = value; } void set_secondary_last_attack_time(int32 value) { std::lock_guard lk(classMutex); secondary_last_attack_time_ = value; } void set_primary_attack_delay(int16 value) { std::lock_guard lk(classMutex); primary_attack_delay_ = value; } void set_secondary_attack_delay(int16 value) { std::lock_guard lk(classMutex); secondary_attack_delay_ = value; } void set_ranged_attack_delay(int16 value) { std::lock_guard lk(classMutex); ranged_attack_delay_ = value; } void set_primary_weapon_type(int8 value) { std::lock_guard lk(classMutex); primary_weapon_type_ = value; } void set_secondary_weapon_type(int8 value) { std::lock_guard lk(classMutex); secondary_weapon_type_ = value; } void set_ranged_weapon_type(int8 value) { std::lock_guard lk(classMutex); ranged_weapon_type_ = value; } void set_primary_weapon_damage_low(int32 value) { std::lock_guard lk(classMutex); primary_weapon_damage_low_ = value; } void set_primary_weapon_damage_high(int32 value) { std::lock_guard lk(classMutex); primary_weapon_damage_high_ = value; } void set_secondary_weapon_damage_low(int32 value) { std::lock_guard lk(classMutex); secondary_weapon_damage_low_ = value; } void set_secondary_weapon_damage_high(int32 value) { std::lock_guard lk(classMutex); secondary_weapon_damage_high_ = value; } void set_ranged_weapon_damage_low(int32 value) { std::lock_guard lk(classMutex); ranged_weapon_damage_low_ = value; } void set_ranged_weapon_damage_high(int32 value) { std::lock_guard lk(classMutex); ranged_weapon_damage_high_ = value; } void set_wield_type(int8 value) { std::lock_guard lk(classMutex); wield_type_ = value; } void set_attack_type(int8 value) { std::lock_guard lk(classMutex); attack_type_ = value; } void set_primary_weapon_delay(int16 value) { std::lock_guard lk(classMutex); primary_weapon_delay_ = value; } void set_secondary_weapon_delay(int16 value) { std::lock_guard lk(classMutex); secondary_weapon_delay_ = value; } void set_ranged_weapon_delay(int16 value) { std::lock_guard lk(classMutex); ranged_weapon_delay_ = value; } void set_override_primary_weapon(int8 value) { std::lock_guard lk(classMutex); override_secondary_weapon_ = value; } void set_override_secondary_weapon(int8 value) { std::lock_guard lk(classMutex); override_secondary_weapon_ = value; } void set_override_ranged_weapon(int8 value) { std::lock_guard lk(classMutex); override_ranged_weapon_ = value; } void set_friendly_target_npc(int8 value) { std::lock_guard lk(classMutex); friendly_target_npc_ = value; } void set_last_claim_time(int32 value) { std::lock_guard lk(classMutex); last_claim_time_ = value; } void set_engaged_encounter(int8 value) { std::lock_guard lk(classMutex); engaged_encounter_ = value; } void ResetEffects(Spawn* spawn) { for(int i=0;i<45;i++){ if(i<30){ maintained_effects[i].spell_id = 0xFFFFFFFF; if (spawn->IsPlayer()) maintained_effects[i].icon = 0xFFFF; maintained_effects[i].spell = nullptr; } spell_effects[i].spell_id = 0xFFFFFFFF; spell_effects[i].spell = nullptr; } } // maintained via their own mutex SpellEffects spell_effects[45]; MaintainedEffects maintained_effects[30]; private: std::string name_; int8 class1_; int8 class2_; int8 class3_; int8 race_; int8 gender_; int16 level_; int16 max_level_; int16 effective_level_; int16 tradeskill_level_; int16 tradeskill_max_level_; int8 cur_concentration_; int8 max_concentration_; int16 cur_attack_; int16 attack_base_; int16 cur_mitigation_; int16 max_mitigation_; int16 mitigation_base_; int16 avoidance_display_; float cur_avoidance_; int16 base_avoidance_pct_; int16 avoidance_base_; int16 max_avoidance_; float parry_; float parry_base_; float deflection_; int16 deflection_base_; float block_; int16 block_base_; float riposte_; float riposte_base_; float str_; //int16 float sta_; //int16 float agi_;//int16 float wis_;//int16 float intel_;//int16 float str_base_;//int16 float sta_base_;//int16 float agi_base_;//int16 float wis_base_;//int16 float intel_base_;//int16 int16 heat_; int16 cold_; int16 magic_; int16 mental_; int16 divine_; int16 disease_; int16 poison_; int16 disease_base_; int16 cold_base_; int16 divine_base_; int16 magic_base_; int16 mental_base_; int16 heat_base_; int16 poison_base_; int16 elemental_base_; int16 noxious_base_; int16 arcane_base_; int32 coin_copper_; int32 coin_silver_; int32 coin_gold_; int32 coin_plat_; int32 bank_coin_copper_; int32 bank_coin_silver_; int32 bank_coin_gold_; int32 bank_coin_plat_; int32 status_points_; std::string deity_; int32 weight_; int32 max_weight_; int8 tradeskill_class1_; int8 tradeskill_class2_; int8 tradeskill_class3_; int32 account_age_base_; int8 account_age_bonus_[19]; int16 absorb_; int32 xp_; int32 xp_needed_; float xp_debt_; int16 xp_yellow_; int16 xp_yellow_vitality_bar_; int16 xp_blue_vitality_bar_; int16 xp_blue_; int32 ts_xp_; int32 ts_xp_needed_; int16 tradeskill_exp_yellow_; int16 tradeskill_exp_blue_; int32 flags_; int32 flags2_; float xp_vitality_; float tradeskill_xp_vitality_; int16 mitigation_skill1_; int16 mitigation_skill2_; int16 mitigation_skill3_; int16 mitigation_pve_; int16 mitigation_pvp_; float ability_modifier_; float critical_mitigation_; float block_chance_; float uncontested_parry_; float uncontested_block_; float uncontested_dodge_; float uncontested_riposte_; float crit_chance_; float crit_bonus_; float potency_; float hate_mod_; float reuse_speed_; float casting_speed_; float recovery_speed_; float spell_reuse_speed_; float spell_multi_attack_; float dps_; float dps_multiplier_; float attackspeed_; float haste_; float multi_attack_; float flurry_; float melee_ae_; float strikethrough_; float accuracy_; float offensivespeed_; float rain_; float wind_; sint8 alignment_; int32 pet_id_; std::string pet_name_; float pet_health_pct_; float pet_power_pct_; int8 pet_movement_; int8 pet_behavior_; int32 vision_; int8 breathe_underwater_; std::string biography_; float drunk_; sint16 power_regen_; sint16 hp_regen_; int8 power_regen_override_; int8 hp_regen_override_; int8 water_type_; int8 flying_type_; int8 no_interrupt_; int8 interaction_flag_; int8 tag1_; int16 mood_; int32 range_last_attack_time_; int32 primary_last_attack_time_; int32 secondary_last_attack_time_; int16 primary_attack_delay_; int16 secondary_attack_delay_; int16 ranged_attack_delay_; int8 primary_weapon_type_; int8 secondary_weapon_type_; int8 ranged_weapon_type_; int32 primary_weapon_damage_low_; int32 primary_weapon_damage_high_; int32 secondary_weapon_damage_low_; int32 secondary_weapon_damage_high_; int32 ranged_weapon_damage_low_; int32 ranged_weapon_damage_high_; int8 wield_type_; int8 attack_type_; int16 primary_weapon_delay_; int16 secondary_weapon_delay_; int16 ranged_weapon_delay_; int8 override_primary_weapon_; int8 override_secondary_weapon_; int8 override_ranged_weapon_; int8 friendly_target_npc_; int32 last_claim_time_; int8 engaged_encounter_; // when PacketStruct is fixed for C++17 this should become a shared_mutex and handle read/write lock std::mutex classMutex; }; struct WardInfo { LuaSpell* Spell; int32 BaseDamage; int32 DamageLeft; int8 WardType; int8 DamageType; bool keepWard; int32 DamageAbsorptionPercentage; int32 DamageAbsorptionMaxHealthPercent; int32 RedirectDamagePercent; int32 LastRedirectDamage; int32 LastAbsorbedDamage; int32 HitCount; int32 MaxHitCount; bool AbsorbAllDamage; // damage is always absorbed, usually spells based on hits, when we pass damage in AddWard as 0 this will be set to true bool RoundTriggered; }; #define WARD_TYPE_ALL 0 #define WARD_TYPE_PHYSICAL 1 #define WARD_TYPE_MAGICAL 2 struct Proc { LuaSpell* spell; Item* item; float chance; int32 spellid; }; #define PROC_TYPE_OFFENSIVE 1 #define PROC_TYPE_DEFENSIVE 2 #define PROC_TYPE_PHYSICAL_OFFENSIVE 3 #define PROC_TYPE_PHYSICAL_DEFENSIVE 4 #define PROC_TYPE_MAGICAL_OFFENSIVE 5 #define PROC_TYPE_MAGICAL_DEFENSIVE 6 #define PROC_TYPE_BLOCK 7 #define PROC_TYPE_PARRY 8 #define PROC_TYPE_RIPOSTE 9 #define PROC_TYPE_EVADE 10 #define PROC_TYPE_HEALING 11 #define PROC_TYPE_BENEFICIAL 12 #define PROC_TYPE_DEATH 13 #define PROC_TYPE_KILL 14 #define PROC_TYPE_DAMAGED 15 #define PROC_TYPE_DAMAGED_MELEE 16 #define PROC_TYPE_DAMAGED_MAGIC 17 #define PROC_TYPE_RANGED_ATTACK 18 #define PROC_TYPE_RANGED_DEFENSE 19 struct ThreatTransfer { int32 Target; float Amount; LuaSpell* Spell; }; #define DET_TYPE_TRAUMA 1 #define DET_TYPE_ARCANE 2 #define DET_TYPE_NOXIOUS 3 #define DET_TYPE_ELEMENTAL 4 #define DET_TYPE_CURSE 5 #define DISPELL_TYPE_CURE 0 #define DISPELL_TYPE_DISPELL 1 #define CONTROL_EFFECT_TYPE_MEZ 1 #define CONTROL_EFFECT_TYPE_STIFLE 2 #define CONTROL_EFFECT_TYPE_DAZE 3 #define CONTROL_EFFECT_TYPE_STUN 4 #define CONTROL_EFFECT_TYPE_ROOT 5 #define CONTROL_EFFECT_TYPE_FEAR 6 #define CONTROL_EFFECT_TYPE_WALKUNDERWATER 7 #define CONTROL_EFFECT_TYPE_JUMPUNDERWATER 8 #define CONTROL_EFFECT_TYPE_INVIS 9 #define CONTROL_EFFECT_TYPE_STEALTH 10 #define CONTROL_EFFECT_TYPE_SNARE 11 #define CONTROL_EFFECT_TYPE_FLIGHT 12 #define CONTROL_EFFECT_TYPE_GLIDE 13 #define CONTROL_EFFECT_TYPE_SAFEFALL 14 #define CONTROL_MAX_EFFECTS 15 // always +1 to highest control effect #define IMMUNITY_TYPE_MEZ 1 #define IMMUNITY_TYPE_STIFLE 2 #define IMMUNITY_TYPE_DAZE 3 #define IMMUNITY_TYPE_STUN 4 #define IMMUNITY_TYPE_ROOT 5 #define IMMUNITY_TYPE_FEAR 6 #define IMMUNITY_TYPE_AOE 7 #define IMMUNITY_TYPE_TAUNT 8 #define IMMUNITY_TYPE_RIPOSTE 9 //class Spell; //class ZoneServer; //The entity class is for NPCs and Players, spawns which are able to fight class Entity : public Spawn{ public: Entity(); virtual ~Entity(); void DeleteSpellEffects(bool removeClient = false); void RemoveSpells(); void MapInfoStruct(); virtual float GetDodgeChance(); virtual void AddMaintainedSpell(LuaSpell* spell); virtual void AddSpellEffect(LuaSpell* spell, int32 override_expire_time = 0); virtual void RemoveMaintainedSpell(LuaSpell* spell); virtual void RemoveSpellEffect(LuaSpell* spell); virtual void AddSkillBonus(int32 spell_id, int32 skill_id, float value); void AddDetrimentalSpell(LuaSpell* spell, int32 override_expire_timestamp = 0); DetrimentalEffects* GetDetrimentalEffect(int32 spell_id, Entity* caster); virtual MaintainedEffects* GetMaintainedSpell(int32 spell_id); void RemoveDetrimentalSpell(LuaSpell* spell); void SetDeity(int8 new_deity){ deity = new_deity; } int8 GetDeity(){ return deity; } EquipmentItemList* GetEquipmentList(); EquipmentItemList* GetAppearanceEquipmentList(); bool IsEntity(){ return true; } float CalculateSkillStatChance(char* skill, int16 item_stat, float max_cap = 0.0f, float modifier = 0.0f, bool add_to_skill = false); float CalculateSkillWithBonus(char* skillName, int16 item_stat, bool chance_skill_increase); float GetRuleSkillMaxBonus(); void CalculateBonuses(); void SetRegenValues(int16 effective_level); float CalculateBonusMod(); float CalculateDPSMultiplier(); float CalculateCastingSpeedMod(); InfoStruct* GetInfoStruct(); int16 GetStr(); int16 GetSta(); int16 GetInt(); int16 GetWis(); int16 GetAgi(); int16 GetPrimaryStat(); int16 GetHeatResistance(); int16 GetColdResistance(); int16 GetMagicResistance(); int16 GetMentalResistance(); int16 GetDivineResistance(); int16 GetDiseaseResistance(); int16 GetPoisonResistance(); int16 GetStrBase(); int16 GetStaBase(); int16 GetIntBase(); int16 GetWisBase(); int16 GetAgiBase(); int16 GetHeatResistanceBase(); int16 GetColdResistanceBase(); int16 GetMagicResistanceBase(); int16 GetMentalResistanceBase(); int16 GetDivineResistanceBase(); int16 GetDiseaseResistanceBase(); int16 GetPoisonResistanceBase(); int8 GetConcentrationCurrent(); int8 GetConcentrationMax(); sint8 GetAlignment(); void SetAlignment(sint8 new_value); bool HasMoved(bool include_heading); void SetHPRegen(int16 new_val); int16 GetHPRegen(); void DoRegenUpdate(); MaintainedEffects* GetFreeMaintainedSpellSlot(); SpellEffects* GetFreeSpellEffectSlot(); SpellEffects* GetSpellEffect(int32 id, Entity* caster = 0); SpellEffects* GetSpellEffectBySpellType(int8 spell_type); SpellEffects* GetSpellEffectWithLinkedTimer(int32 id, int32 linked_timer = 0, sint32 type_group_spell_id = 0, Entity* caster = 0); LuaSpell* HasLinkedTimerID(LuaSpell* spell, Spawn* target = nullptr, bool stackWithOtherPlayers = true); //flags int32 GetFlags() { return info_struct.get_flags(); } int32 GetFlags2() { return info_struct.get_flags2(); } bool query_flags(int flag) { if (flag > 63) return false; if (flag < 32) return ((info_struct.get_flags() & (1 << flag))?true:false); return ((info_struct.get_flags2() & (1 << (flag - 32)))?true:false); } float GetMaxSpeed(); void SetMaxSpeed(float val); //combat stuff: int32 GetRangeLastAttackTime(); void SetRangeLastAttackTime(int32 time); int16 GetRangeAttackDelay(); int16 GetRangeWeaponDelay(); void SetRangeWeaponDelay(int16 new_delay); void SetRangeAttackDelay(int16 new_delay); int32 GetPrimaryLastAttackTime(); int16 GetPrimaryAttackDelay(); void SetPrimaryAttackDelay(int16 new_delay); void SetPrimaryLastAttackTime(int32 new_time); void SetPrimaryWeaponDelay(int16 new_delay); int32 GetSecondaryLastAttackTime(); int16 GetSecondaryAttackDelay(); void SetSecondaryAttackDelay(int16 new_delay); void SetSecondaryLastAttackTime(int32 new_time); void SetSecondaryWeaponDelay(int16 new_delay); int32 GetPrimaryWeaponMinDamage(); int32 GetPrimaryWeaponMaxDamage(); int32 GetSecondaryWeaponMinDamage(); int32 GetSecondaryWeaponMaxDamage(); int32 GetRangedWeaponMinDamage(); int32 GetRangedWeaponMaxDamage(); int8 GetPrimaryWeaponType(); int8 GetSecondaryWeaponType(); int8 GetRangedWeaponType(); int8 GetWieldType(); int16 GetPrimaryWeaponDelay(); int16 GetSecondaryWeaponDelay(); bool IsDualWield(); bool BehindTarget(Spawn* target); bool FlankingTarget(Spawn* target); void ChangePrimaryWeapon(); void ChangeSecondaryWeapon(); void ChangeRangedWeapon(); void UpdateWeapons(); int32 GetStrengthDamage(); virtual Skill* GetSkillByName(const char* name, bool check_update = false); virtual Skill* GetSkillByID(int32 id, bool check_update = false); bool AttackAllowed(Entity* target, float distance = 0, bool range_attack = false); bool PrimaryWeaponReady(); bool SecondaryWeaponReady(); bool RangeWeaponReady(); void MeleeAttack(Spawn* victim, float distance, bool primary, bool multi_attack = false); void RangeAttack(Spawn* victim, float distance, Item* weapon, Item* ammo, bool multi_attack = false); bool SpellAttack(Spawn* victim, float distance, LuaSpell* luaspell, int8 damage_type, int32 low_damage, int32 high_damage, int8 crit_mod = 0, bool no_calcs = false); bool ProcAttack(Spawn* victim, int8 damage_type, int32 low_damage, int32 high_damage, string name, string success_msg, string effect_msg); bool SpellHeal(Spawn* target, float distance, LuaSpell* luaspell, string heal_type, int32 low_heal, int32 high_heal, int8 crit_mod = 0, bool no_calcs = false, string custom_spell_name=""); int8 DetermineHit(Spawn* victim, int8 type, int8 damage_type, float ToHitBonus, bool is_caster_spell, LuaSpell* lua_spell = nullptr); float GetDamageTypeResistPercentage(int8 damage_type); Skill* GetSkillByWeaponType(int8 type, int8 damage_type, bool update); bool DamageSpawn(Entity* victim, int8 type, int8 damage_type, int32 low_damage, int32 high_damage, const char* spell_name, int8 crit_mod = 0, bool is_tick = false, bool no_damage_calcs = false, bool ignore_attacker = false, LuaSpell* spell = 0); float CalculateMitigation(int8 type = DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE, int8 damage_type = 0, int16 attacker_level = 0, bool for_pvp = false); void AddHate(Entity* attacker, sint32 hate); bool CheckInterruptSpell(Entity* attacker); bool CheckFizzleSpell(LuaSpell* spell); void KillSpawn(Spawn* dead, int8 type = 0, int8 damage_type = 0, int16 kill_blow_type = 0); void HandleDeathExperienceDebt(Spawn* killer); void SetAttackDelay(bool primary = false, bool ranged = false); float CalculateAttackSpeedMod(); virtual void ProcessCombat(); bool EngagedInCombat(); virtual void InCombat(bool val); bool IsCasting(); void IsCasting(bool val); void SetMount(int16 mount_id, int8 red = 0xFF, int8 green = 0xFF, int8 blue = 0xFF, bool setUpdateFlags = true) { if (mount_id == 0) { EQ2_Color color; color.red = 0; color.green = 0; color.blue = 0; SetMountColor(&color); SetMountSaddleColor(&color); } else { EQ2_Color color; color.red = red; color.green = green; color.blue = blue; SetMountColor(&color); SetMountSaddleColor(&color); } SetInfo(&features.mount_model_type, mount_id, setUpdateFlags); } void SetEquipment(Item* item, int8 slot = 255); void SetEquipment(int8 slot, int16 type, int8 red, int8 green, int8 blue, int8 h_r, int8 h_g, int8 h_b){ std::lock_guard lk(MEquipment); if(slot >= NUM_SLOTS) return; SetInfo(&equipment.equip_id[slot], type); SetInfo(&equipment.color[slot].red, red); SetInfo(&equipment.color[slot].green, green); SetInfo(&equipment.color[slot].blue, blue); SetInfo(&equipment.highlight[slot].red, h_r); SetInfo(&equipment.highlight[slot].green, h_g); SetInfo(&equipment.highlight[slot].blue, h_b); } void SetHairType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_type, new_val, setUpdateFlags); } void SetHairColor1(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_color1, new_val, setUpdateFlags); } void SetHairColor2(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_color2, new_val, setUpdateFlags); } void SetSogaHairColor1(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_color1, new_val, setUpdateFlags); } void SetSogaHairColor2(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_color2, new_val, setUpdateFlags); } void SetHairHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_highlight_color, new_val, setUpdateFlags); } void SetSogaHairHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_highlight_color, new_val, setUpdateFlags); } void SetHairColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_type_color, new_val, setUpdateFlags); } void SetSogaHairColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_type_color, new_val, setUpdateFlags); } void SetHairTypeHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_type_highlight_color, new_val, setUpdateFlags); } void SetSogaHairTypeHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_type_highlight_color, new_val, setUpdateFlags); } void SetFacialHairType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_face_type, new_val, setUpdateFlags); } void SetFacialHairColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_face_color, new_val, setUpdateFlags); } void SetSogaFacialHairColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_face_color, new_val, setUpdateFlags); } void SetFacialHairHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.hair_face_highlight_color, new_val, setUpdateFlags); } void SetSogaFacialHairHighlightColor(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_face_highlight_color, new_val, setUpdateFlags); } void SetWingType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.wing_type, new_val, setUpdateFlags); } void SetWingColor1(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.wing_color1, new_val, setUpdateFlags); } void SetWingColor2(EQ2_Color new_val, bool setUpdateFlags = true){ SetInfo(&features.wing_color2, new_val, setUpdateFlags); } void SetChestType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.chest_type, new_val, setUpdateFlags); } void SetLegsType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.legs_type, new_val, setUpdateFlags); } void SetSogaHairType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_type, new_val, setUpdateFlags); } void SetSogaFacialHairType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_hair_face_type, new_val, setUpdateFlags); } void SetSogaChestType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_chest_type, new_val, setUpdateFlags); } void SetSogaLegType(int16 new_val, bool setUpdateFlags = true){ SetInfo(&features.soga_legs_type, new_val, setUpdateFlags); } void SetSkinColor(EQ2_Color color){ SetInfo(&features.skin_color, color); } void SetSogaSkinColor(EQ2_Color color){ SetInfo(&features.soga_skin_color, color); } void SetModelColor(EQ2_Color color){ SetInfo(&features.model_color, color); } void SetSogaModelColor(EQ2_Color color){ SetInfo(&features.soga_model_color, color); } void SetCombatVoice(int16 val, bool setUpdateFlags = true) { SetInfo(&features.combat_voice, val, setUpdateFlags); } void SetEmoteVoice(int16 val, bool setUpdateFlags = true) { SetInfo(&features.emote_voice, val, setUpdateFlags); } int16 GetCombatVoice(){ return features.combat_voice; } int16 GetEmoteVoice(){ return features.emote_voice; } int16 GetMount(){ return features.mount_model_type; } void SetMountSaddleColor(EQ2_Color* color){ SetInfo(&features.mount_saddle_color, *color); } void SetMountColor(EQ2_Color* color){ SetInfo(&features.mount_color, *color); } void SetEyeColor(EQ2_Color eye_color){ SetInfo(&features.eye_color, eye_color); } void SetSogaEyeColor(EQ2_Color eye_color){ SetInfo(&features.soga_eye_color, eye_color); } int16 GetHairType(){ return features.hair_type; } int16 GetFacialHairType(){ return features.hair_face_type; } int16 GetWingType(){ return features.wing_type; } int16 GetChestType(){ return features.chest_type; } int16 GetLegsType(){ return features.legs_type; } int16 GetSogaHairType(){ return features.soga_hair_type; } int16 GetSogaFacialHairType(){ return features.soga_hair_face_type; } int16 GetSogaChestType(){ return features.soga_chest_type; } int16 GetSogaLegType(){ return features.soga_legs_type; } EQ2_Color* GetSkinColor(){ return &features.skin_color; } EQ2_Color* GetModelColor(){ return &features.model_color; } EQ2_Color* GetSogaModelColor(){ return &features.soga_model_color; } EQ2_Color* GetEyeColor(){ return &features.eye_color; } EQ2_Color* GetMountSaddleColor(){ return &features.mount_saddle_color; } EQ2_Color* GetMountColor(){ return &features.mount_color; } // should only be accessed through MEquipment mutex EQ2_Equipment equipment; CharFeatures features; void AddSpellBonus(LuaSpell* spell, int16 type, float value, int64 class_req =0, vector race_req = vector(), vector faction_req = vector()); BonusValues* GetSpellBonus(int32 spell_id); vector* GetAllSpellBonuses(LuaSpell* spell); bool CheckSpellBonusRemoval(LuaSpell* spell, int16 type); void RemoveSpellBonus(const LuaSpell* spell, bool remove_all = false); void RemoveAllSpellBonuses(); void CalculateSpellBonuses(ItemStatsValues* stats); void AddMezSpell(LuaSpell* spell); void RemoveMezSpell(LuaSpell* spell); void RemoveAllMezSpells(); bool IsMezzed(); void AddStifleSpell(LuaSpell* spell); void RemoveStifleSpell(LuaSpell* spell); bool IsStifled(); void AddDazeSpell(LuaSpell* spell); void RemoveDazeSpell(LuaSpell* spell); bool IsDazed(); void AddStunSpell(LuaSpell* spell); void RemoveStunSpell(LuaSpell* spell); bool IsStunned(); bool IsMezzedOrStunned() {return IsMezzed() || IsStunned();} void AddRootSpell(LuaSpell* spell); void RemoveRootSpell(LuaSpell* spell); bool IsRooted(); void AddFearSpell(LuaSpell* spell); void RemoveFearSpell(LuaSpell* spell); bool IsFeared(); void AddSnareSpell(LuaSpell* spell); void RemoveSnareSpell(LuaSpell* spell); void SetSnareValue(LuaSpell* spell, float snare_val); bool IsSnared(); float GetHighestSnare(); bool HasControlEffect(int8 type); void HaltMovement(); void SetCombatPet(Entity* pet) { this->pet = pet; } void SetCharmedPet(Entity* pet) { charmedPet = pet; } void SetDeityPet(Entity* pet) { deityPet = pet; } void SetCosmeticPet(Entity* pet) { cosmeticPet = pet; } Entity* GetPet() { return pet; } Entity* GetCharmedPet() { return charmedPet; } Entity* GetDeityPet() { return deityPet; } Entity* GetCosmeticPet() { return cosmeticPet; } /// Check to see if the entity has a combat pet /// True if the entity has a combat pet bool HasPet() { return (pet || charmedPet) ? true : false; } void HideDeityPet(bool val); void HideCosmeticPet(bool val); void DismissPet(Entity* pet, bool from_death = false, bool spawnListLocked = false); void DismissAllPets(bool from_death = false, bool spawnListLocked = false); void SetOwner(Entity* owner) { if (owner) { this->owner = owner->GetID(); } else { owner = 0; } } Entity* GetOwner(); int8 GetPetType() { return m_petType; } void SetPetType(int8 val) { m_petType = val; } void SetPetSpellID(int32 val) { m_petSpellID = val; } int32 GetPetSpellID() { return m_petSpellID; } void SetPetSpellTier(int8 val) { m_petSpellTier = val; } int8 GetPetSpellTier() { return m_petSpellTier; } bool IsDismissing() { return m_petDismissing; } void SetDismissing(bool val) { m_petDismissing = val; } /// Creates a loot chest to drop in the world /// Pointer to the chest NPC* DropChest(); /// Add a ward to the entities ward list /// Spell id of the ward to add /// WardInfo* of the ward we are adding void AddWard(int32 spellID, WardInfo* ward); /// Gets ward info for the given spell id /// The spell id of the ward we want to get /// WardInfo for the given spell id WardInfo* GetWard(int32 spellID); /// Removes the ward with the given spell id /// The spell id of the ward to remove void RemoveWard(int32 spellID); /// Subtracts the given damage from the wards /// The damage to subtract from the wards /// The amount of damage left after wards int32 CheckWards(Entity* attacker, int32 damage, int8 damage_type); map stats; /// Adds a proc to the list of current procs /// The type of proc to add /// The percent chance the proc has to go off /// The item the proc is coming from if any /// The spell the proc is coming from if any void AddProc(int8 type, float chance, Item* item = 0, LuaSpell* spell = 0); /// Removes a proc from the list of current procs /// Item the proc is from /// Spell the proc is from void RemoveProc(Item* item = 0, LuaSpell* spell = 0); /// Cycles through the proc list and executes them if they can go off /// The proc type to check /// The target of the proc if it goes off void CheckProcs(int8 type, Spawn* target); /// Clears the entire proc list void ClearProcs(); float GetSpeed(); float GetAirSpeed(); float GetBaseSpeed() { return base_speed; } void SetSpeed(float val, bool override_ = false) { if ((base_speed == 0.0f && val > 0.0f) || override_) base_speed = val; speed = val; } void SetSpeedMultiplier(float val) { speed_multiplier = val; } void SetThreatTransfer(ThreatTransfer* transfer); ThreatTransfer* GetThreatTransfer() { return m_threatTransfer; } int8 GetTraumaCount(); int8 GetArcaneCount(); int8 GetNoxiousCount(); int8 GetElementalCount(); int8 GetCurseCount(); int8 GetDetTypeCount(int8 det_type); int8 GetDetCount(); bool HasCurableDetrimentType(int8 det_type); Mutex* GetDetrimentMutex(); Mutex* GetMaintainedMutex(); Mutex* GetSpellEffectMutex(); void ClearAllDetriments(); void CureDetrimentByType(int8 cure_count, int8 det_type, string cure_name, Entity* caster, int8 cure_level = 0); void CureDetrimentByControlEffect(int8 cure_count, int8 det_type, string cure_name, Entity* caster, int8 cure_level = 0); vector* GetDetrimentalSpellEffects(); void RemoveEffectsFromLuaSpell(LuaSpell* spell); virtual void RemoveSkillBonus(int32 spell_id); virtual bool CanSeeInvis(Entity* target); void CancelAllStealth(); bool IsStealthed(); bool IsInvis(); void AddInvisSpell(LuaSpell* spell); void AddStealthSpell(LuaSpell* spell); void RemoveStealthSpell(LuaSpell* spell); void RemoveInvisSpell(LuaSpell* spell); void AddWaterwalkSpell(LuaSpell* spell); void AddWaterjumpSpell(LuaSpell* spell); void RemoveWaterwalkSpell(LuaSpell* spell); void RemoveWaterjumpSpell(LuaSpell* spell); void AddAOEImmunity(LuaSpell* spell); bool IsAOEImmune(); void RemoveAOEImmunity(LuaSpell* spell); void AddStunImmunity(LuaSpell* spell); void RemoveStunImmunity(LuaSpell* spell); bool IsStunImmune(); void AddStifleImmunity(LuaSpell* spell); void RemoveStifleImmunity(LuaSpell* spell); bool IsStifleImmune(); void AddMezImmunity(LuaSpell* spell); void RemoveMezImmunity(LuaSpell* spell); bool IsMezImmune(); void AddRootImmunity(LuaSpell* spell); void RemoveRootImmunity(LuaSpell* spell); bool IsRootImmune(); void AddFearImmunity(LuaSpell* spell); void RemoveFearImmunity(LuaSpell* spell); bool IsFearImmune(); void AddDazeImmunity(LuaSpell* spell); void RemoveDazeImmunity(LuaSpell* spell); bool IsDazeImmune(); void AddImmunity(LuaSpell* spell, int16 type); void RemoveImmunity(LuaSpell* spell, int16 type); bool IsImmune(int16 type); void AddFlightSpell(LuaSpell* spell); void RemoveFlightSpell(LuaSpell* spell); void AddSafefallSpell(LuaSpell* spell); void RemoveSafefallSpell(LuaSpell* spell); void AddGlideSpell(LuaSpell* spell); void RemoveGlideSpell(LuaSpell* spell); GroupMemberInfo* GetGroupMemberInfo() { return group_member_info; } void SetGroupMemberInfo(GroupMemberInfo* info) { group_member_info = info; } void UpdateGroupMemberInfo(bool inGroupMgrLock=false, bool groupMembersLocked=false); void CustomizeAppearance(PacketStruct* packet); Trade* trade; // Keep track of entities that hate this spawn. set HatedBy; std::mutex MHatedBy; bool IsAggroed() { int32 size = 0; MHatedBy.lock(); size = HatedBy.size(); MHatedBy.unlock(); return size > 0; } Mutex MCommandMutex; bool HasSeeInvisSpell() { return hasSeeInvisSpell; } void SetSeeInvisSpell(bool val) { hasSeeInvisSpell = val; } bool HasSeeHideSpell() { return hasSeeHideSpell; } void SetSeeHideSpell(bool val) { hasSeeHideSpell = val; } void SetInfoStruct(InfoStruct* struct_) { info_struct.SetInfoStruct(struct_); } std::string GetInfoStructString(std::string field); int8 GetInfoStructInt8(std::string field); int16 GetInfoStructInt16(std::string field); int32 GetInfoStructInt32(std::string field); int64 GetInfoStructInt64(std::string field); sint8 GetInfoStructSInt8(std::string field); sint16 GetInfoStructSInt16(std::string field); sint32 GetInfoStructSInt32(std::string field); sint64 GetInfoStructSInt64(std::string field); int64 GetInfoStructUInt(std::string field); sint64 GetInfoStructSInt(std::string field); float GetInfoStructFloat(std::string field); bool SetInfoStructString(std::string field, std::string value); bool SetInfoStructUInt(std::string field, int64 value); bool SetInfoStructSInt(std::string field, sint64 value); bool SetInfoStructFloat(std::string field, float value); sint32 CalculateHateAmount(Spawn* target, sint32 amt); sint32 CalculateHealAmount(Spawn* target, sint32 amt, int8 crit_mod, bool* crit, bool skip_crit_mod = false); sint32 CalculateDamageAmount(Spawn* target, sint32 damage, int8 base_type, int8 damage_type, LuaSpell* spell); sint32 CalculateDamageAmount(Spawn* target, sint32 damage, int8 base_type, int8 damage_type, int8 spell_target_type); sint32 CalculateFormulaByStat(sint32 value, int16 stat); int32 CalculateFormulaByStat(int32 value, int16 stat); int32 CalculateFormulaBonus(int32 value, float percent_bonus); float GetStat(int32 item_stat) { float item_chance_or_skill = 0.0f; MStats.lock(); item_chance_or_skill = stats[item_stat]; MStats.unlock(); return item_chance_or_skill; } bool IsEngagedInEncounter(Spawn** res = nullptr); bool IsEngagedBySpawnID(int32 id); // when PacketStruct is fixed for C++17 this should become a shared_mutex and handle read/write lock std::mutex MEquipment; std::mutex MStats; Mutex MMaintainedSpells; Mutex MSpellEffects; protected: bool in_combat; int8 m_petType; int32 owner; // m_petSpellID holds the spell id used to create/control this pet int32 m_petSpellID; int8 m_petSpellTier; bool m_petDismissing; private: MutexList bonus_list; map*> control_effects; map*> immunities; float max_speed; int8 deity; sint16 regen_hp_rate; sint16 regen_power_rate; float last_x; float last_y; float last_z; float last_heading; bool casting; InfoStruct info_struct; map det_count_list; Mutex MDetriments; vector detrimental_spell_effects; // Pointers for the 4 types of pets (Summon, Charm, Deity, Cosmetic) Entity* pet; Entity* charmedPet; Entity* deityPet; Entity* cosmeticPet; // int32 = spell id, WardInfo* = pointer to ward info map m_wardList; // int8 = type, vector = list of pointers to proc info map > m_procList; Mutex MProcList; /// Actually calls the lua script to cast the proc /// Proc to be cast /// Type of proc going off /// Target of the proc bool CastProc(Proc* proc, int8 type, Spawn* target); float base_speed; float speed; float speed_multiplier; map snare_values; ThreatTransfer* m_threatTransfer; GroupMemberInfo* group_member_info; bool hasSeeInvisSpell; bool hasSeeHideSpell; // GETs map > get_float_funcs; map > get_int64_funcs; map > get_int32_funcs; map > get_int16_funcs; map > get_int8_funcs; map > get_sint64_funcs; map > get_sint32_funcs; map > get_sint16_funcs; map > get_sint8_funcs; map > get_string_funcs; // SETs map > set_float_funcs; map > set_int64_funcs; map > set_int32_funcs; map > set_int16_funcs; map > set_int8_funcs; map > set_sint64_funcs; map > set_sint32_funcs; map > set_sint16_funcs; map > set_sint8_funcs; map > set_string_funcs; }; #endif