#include <Status.hpp>

Classes
struct	bonuses

class	StatusRegistry

Public Member Functions
	Status (std::weak_ptr< Unit > unit, unit_type type)

	~Status ()

bool	initialize (std::shared_ptr< Horizon::Zone::Units::Mob > creature, std::shared_ptr< const monster_config_data > md)

bool	initialize (std::shared_ptr< Horizon::Zone::Units::Player > player)

bool	initialize (std::shared_ptr< Horizon::Zone::Units::NPC > npc)

uint32_t	get_required_statpoints (uint16_t from, uint16_t to)

uint32_t	get_status_base (status_point_type type)

bool	increase_status_point (status_point_type type, uint16_t amount)
	Increases a status point to a certain limit and returns the current total of the stat. More...

bool	save (std::shared_ptr< Horizon::Zone::Units::Player > pl)

bool	load (std::shared_ptr< Horizon::Zone::Units::Player > pl)

void	on_equipment_changed (bool equipped, std::shared_ptr< const item_entry_data > item)

void	on_job_changed (uint32_t job_id)

std::shared_ptr< Strength >	strength ()
	Attributes. More...

void	set_strength (std::shared_ptr< Strength > str)

std::shared_ptr< Agility >	agility ()

void	set_agility (std::shared_ptr< Agility > agi)

std::shared_ptr< Vitality >	vitality ()

void	set_vitality (std::shared_ptr< Vitality > vit)

std::shared_ptr< Dexterity >	dexterity ()

void	set_dexterity (std::shared_ptr< Dexterity > dex)

std::shared_ptr< Intelligence >	intelligence ()

void	set_intelligence (std::shared_ptr< Intelligence > int_)

std::shared_ptr< Luck >	luck ()

void	set_luck (std::shared_ptr< Luck > luck)

std::shared_ptr< StrengthPointCost >	strength_cost ()

void	set_strength_cost (std::shared_ptr< StrengthPointCost > str)

std::shared_ptr< AgilityPointCost >	agility_cost ()

void	set_agility_cost (std::shared_ptr< AgilityPointCost > agi)

std::shared_ptr< VitalityPointCost >	vitality_cost ()

void	set_vitality_cost (std::shared_ptr< VitalityPointCost > vit)

std::shared_ptr< DexterityPointCost >	dexterity_cost ()

void	set_dexterity_cost (std::shared_ptr< DexterityPointCost > dex)

std::shared_ptr< IntelligencePointCost >	intelligence_cost ()

void	set_intelligence_cost (std::shared_ptr< IntelligencePointCost > int_)

std::shared_ptr< LuckPointCost >	luck_cost ()

void	set_luck_cost (std::shared_ptr< LuckPointCost > luck)

std::shared_ptr< StatusPoint >	status_point ()

void	set_status_point (std::shared_ptr< StatusPoint > st)

std::shared_ptr< SkillPoint >	skill_point ()

void	set_skill_point (std::shared_ptr< SkillPoint > sk)

std::shared_ptr< MaxHP >	max_hp ()

void	set_max_hp (std::shared_ptr< MaxHP > max_hp)

std::shared_ptr< MaxSP >	max_sp ()

void	set_max_sp (std::shared_ptr< MaxSP > max_sp)

std::shared_ptr< CurrentHP >	current_hp ()

void	set_current_hp (std::shared_ptr< CurrentHP > hp)

std::shared_ptr< CurrentSP >	current_sp ()

void	set_current_sp (std::shared_ptr< CurrentSP > sp)

std::shared_ptr< BaseLevel >	base_level ()

void	set_base_level (std::shared_ptr< BaseLevel > blvl)

std::shared_ptr< JobLevel >	job_level ()

void	set_job_level (std::shared_ptr< JobLevel > jlvl)

std::shared_ptr< BaseExperience >	base_experience ()

void	set_base_experience (std::shared_ptr< BaseExperience > bexp)

std::shared_ptr< JobExperience >	job_experience ()

void	set_job_experience (std::shared_ptr< JobExperience > jexp)

std::shared_ptr< NextBaseExperience >	next_base_experience ()

void	set_next_base_experience (std::shared_ptr< NextBaseExperience > nbexp)

std::shared_ptr< NextJobExperience >	next_job_experience ()

void	set_next_job_experience (std::shared_ptr< NextJobExperience > njexp)

std::shared_ptr< MovementSpeed >	movement_speed ()

void	set_movement_speed (std::shared_ptr< MovementSpeed > speed)

std::shared_ptr< MaxWeight >	max_weight ()

void	set_max_weight (std::shared_ptr< MaxWeight > mw)

std::shared_ptr< CurrentWeight >	current_weight ()

void	set_current_weight (std::shared_ptr< CurrentWeight > cw)

std::shared_ptr< AttackRange >	attack_range ()

void	set_attack_range (std::shared_ptr< AttackRange > m)

std::shared_ptr< StatusATK >	status_atk ()
	SubAttributes. More...

void	set_status_atk (std::shared_ptr< StatusATK > satk)

std::shared_ptr< EquipATK >	equip_atk ()

void	set_equip_atk (std::shared_ptr< EquipATK > eatk)

std::shared_ptr< StatusMATK >	status_matk ()

void	set_status_matk (std::shared_ptr< StatusMATK > smatk)

std::shared_ptr< EquipMATK >	equip_matk ()

void	set_equip_matk (std::shared_ptr< EquipMATK > ematk)

std::shared_ptr< SoftDEF >	soft_def ()

void	set_soft_def (std::shared_ptr< SoftDEF > sdef)

std::shared_ptr< HardDEF >	hard_def ()

void	set_hard_def (std::shared_ptr< HardDEF > hdef)

std::shared_ptr< SoftMDEF >	soft_mdef ()

void	set_soft_mdef (std::shared_ptr< SoftMDEF > smdef)

std::shared_ptr< HardMDEF >	hard_mdef ()

void	set_hard_mdef (std::shared_ptr< HardMDEF > hmdef)

std::shared_ptr< HIT >	hit ()

void	set_hit (std::shared_ptr< HIT > hit)

std::shared_ptr< CRIT >	crit ()

void	set_crit (std::shared_ptr< CRIT > crit)

std::shared_ptr< FLEE >	flee ()

void	set_flee (std::shared_ptr< FLEE > flee)

std::shared_ptr< AttackSpeed >	attack_speed ()

void	set_attack_speed (std::shared_ptr< AttackSpeed > aspd)

std::shared_ptr< HPRegeneration >	hp_regeneration ()

void	set_hp_regeneration (std::shared_ptr< HPRegeneration > hpr)

std::shared_ptr< SPRegeneration >	sp_regeneration ()

void	set_sp_regeneration (std::shared_ptr< SPRegeneration > spr)

std::shared_ptr< BaseAppearance >	base_appearance ()
	Appearance. More...

void	set_base_appearance (std::shared_ptr< BaseAppearance > ba)

std::shared_ptr< HairColor >	hair_color ()

void	set_hair_color (std::shared_ptr< HairColor > hc)

std::shared_ptr< ClothColor >	cloth_color ()

void	set_cloth_color (std::shared_ptr< ClothColor > cc)

std::shared_ptr< WeaponSprite >	weapon_sprite ()

void	set_weapon_sprite (std::shared_ptr< WeaponSprite > ws)

std::shared_ptr< ShieldSprite >	shield_sprite ()

void	set_shield_sprite (std::shared_ptr< ShieldSprite > ss)

std::shared_ptr< RobeSprite >	robe_sprite ()

void	set_robe_sprite (std::shared_ptr< RobeSprite > rs)

std::shared_ptr< HeadTopSprite >	head_top_sprite ()

void	set_head_top_sprite (std::shared_ptr< HeadTopSprite > hts)

std::shared_ptr< HeadMidSprite >	head_mid_sprite ()

void	set_head_mid_sprite (std::shared_ptr< HeadMidSprite > hms)

std::shared_ptr< HeadBottomSprite >	head_bottom_sprite ()

void	set_head_bottom_sprite (std::shared_ptr< HeadBottomSprite > hbs)

std::shared_ptr< HairStyle >	hair_style ()

void	set_hair_style (std::shared_ptr< HairStyle > hs)

std::shared_ptr< BodyStyle >	body_style ()

void	set_body_style (std::shared_ptr< BodyStyle > bs)

std::shared_ptr< Zeny >	zeny ()

void	set_zeny (std::shared_ptr< Zeny > z)

std::shared_ptr< Honor >	honor ()

void	set_honor (std::shared_ptr< Honor > h)

std::shared_ptr< Manner >	manner ()

void	set_manner (std::shared_ptr< Manner > m)

std::shared_ptr< Virtue >	virtue ()

void	set_virtue (std::shared_ptr< Virtue > v)

std::shared_ptr< AttackDelay >	attack_delay ()
	Combat Status. More...

void	set_attack_delay (std::shared_ptr< AttackDelay > a)

std::shared_ptr< DamageWalkDelay >	damage_walk_delay ()

void	set_damage_walk_delay (std::shared_ptr< DamageWalkDelay > m)

std::shared_ptr< BaseAttack >	base_attack ()

void	set_base_attack (std::shared_ptr< BaseAttack > b)

std::shared_ptr< WeaponAttackLeft >	weapon_attack_left ()

void	set_weapon_attack_left (std::shared_ptr< WeaponAttackLeft > w)

std::shared_ptr< WeaponAttackRight >	weapon_attack_right ()

void	set_weapon_attack_right (std::shared_ptr< WeaponAttackRight > w)

std::shared_ptr< WeaponAttackCombined >	weapon_attack_combined ()

void	set_weapon_attack_combined (std::shared_ptr< WeaponAttackCombined > w)

std::shared_ptr< UnitSize >	size ()

void	set_size (std::shared_ptr< UnitSize > s)

std::shared_ptr< MobWeaponAttack >	creature_weapon_attack ()

void	set_creature_weapon_attack (std::shared_ptr< MobWeaponAttack > m)

std::shared_ptr< MobWeaponAttack >	creature_weapon_attack_magic ()

void	set_creature_weapon_attack_magic (std::shared_ptr< MobWeaponAttack > m)

std::shared_ptr< MobAttackDamage >	creature_attack_damage ()

void	set_creature_attack_damage (std::shared_ptr< MobAttackDamage > m)

std::shared_ptr< MobMagicAttackDamage >	creature_magic_attack_damage ()

void	set_creature_magic_attack_damage (std::shared_ptr< MobMagicAttackDamage > m)

std::shared_ptr< MobViewRange >	creature_view_range ()

void	set_creature_view_range (std::shared_ptr< MobViewRange > m)

std::shared_ptr< MobChaseRange >	creature_chase_range ()

void	set_creature_chase_range (std::shared_ptr< MobChaseRange > m)

std::shared_ptr< MobPrimaryRace >	creature_primary_race ()

void	set_creature_primary_race (std::shared_ptr< MobPrimaryRace > m)

std::shared_ptr< MobSecondaryRace >	creature_secondary_race ()

void	set_creature_secondary_race (std::shared_ptr< MobSecondaryRace > m)

std::shared_ptr< MobElement >	creature_element ()

void	set_creature_element (std::shared_ptr< MobElement > m)

std::shared_ptr< MobElementLevel >	creature_element_level ()

void	set_creature_element_level (std::shared_ptr< MobElementLevel > m)

std::shared_ptr< MobMode >	creature_mode ()

void	set_creature_mode (std::shared_ptr< MobMode > m)

std::shared_ptr< StatusRegistry >	status_registry ()

bool	is_initialized ()

void	set_initialized (bool b)

void	add_attribute (std::shared_ptr< Attribute > attribute)

void	remove_attribute (std::shared_ptr< Attribute > attribute)

std::shared_ptr< Attribute >	get_attribute (status_point_type type)

void	add_appearance (std::shared_ptr< Appearance > appearance)

void	remove_appearance (std::shared_ptr< Appearance > appearance)

std::shared_ptr< Appearance >	get_appearance (unit_appearance_type type)

void	calculate (bool notify=true)

bool	recalculate (bool notify=true)

bool	update (uint64_t delta)

void	add_bonus (std::shared_ptr< Bonuses::Bonus > bonus)

void	remove_bonus (std::shared_ptr< Bonuses::Bonus > bonus)

std::shared_ptr< Bonuses::Bonus >	get_bonus (status_point_type type)

std::shared_ptr< Bonuses::BonusAllStatus >	bonus_all_status ()

void	set_bonus_all_status (std::shared_ptr< Bonuses::BonusAllStatus > b)

std::shared_ptr< Bonuses::BonusAttackElement >	bonus_attack_element ()

void	set_bonus_attack_element (std::shared_ptr< Bonuses::BonusAttackElement > b)

std::shared_ptr< Bonuses::BonusDefenseElement >	bonus_defense_element ()

void	set_bonus_defense_element (std::shared_ptr< Bonuses::BonusDefenseElement > b)

std::shared_ptr< Bonuses::BonusCastPercent >	bonus_cast_percent ()

void	set_bonus_cast_percent (std::shared_ptr< Bonuses::BonusCastPercent > b)

std::shared_ptr< Bonuses::BonusMaxHPPercent >	bonus_max_hp_percent ()

void	set_bonus_max_hp_percent (std::shared_ptr< Bonuses::BonusMaxHPPercent > b)

std::shared_ptr< Bonuses::BonusMaxSPPercent >	bonus_max_sp_percent ()

void	set_bonus_max_sp_percent (std::shared_ptr< Bonuses::BonusMaxSPPercent > b)

std::shared_ptr< Bonuses::BonusSPPercent >	bonus_sp_percent ()

void	set_bonus_sp_percent (std::shared_ptr< Bonuses::BonusSPPercent > b)

std::shared_ptr< Bonuses::BonusAttackRange >	bonus_attack_range ()

void	set_bonus_attack_range (std::shared_ptr< Bonuses::BonusAttackRange > b)

std::shared_ptr< Bonuses::BonusAttackRangePercent >	bonus_attack_range_percent ()

void	set_bonus_attack_range_percent (std::shared_ptr< Bonuses::BonusAttackRangePercent > b)

std::shared_ptr< Bonuses::BonusAddMovementSpeedPercent >	bonus_add_movement_speed_percent ()

void	set_bonus_add_movement_speed_percent (std::shared_ptr< Bonuses::BonusAddMovementSpeedPercent > b)

std::shared_ptr< Bonuses::BonusAttackSpeedPercent >	bonus_attack_speed_percent ()

void	set_bonus_attack_speed_percent (std::shared_ptr< Bonuses::BonusAttackSpeedPercent > b)

std::shared_ptr< Bonuses::BonusHPRecoveryPercent >	bonus_hp_recovery_percent ()

void	set_bonus_hp_recovery_percent (std::shared_ptr< Bonuses::BonusHPRecoveryPercent > b)

std::shared_ptr< Bonuses::BonusSPRecoveryPercent >	bonus_sp_recovery_percent ()

void	set_bonus_sp_recovery_percent (std::shared_ptr< Bonuses::BonusSPRecoveryPercent > b)

std::shared_ptr< Bonuses::BonusCriticalDefense >	bonus_critical_defense ()

void	set_bonus_critical_defense (std::shared_ptr< Bonuses::BonusCriticalDefense > b)

std::shared_ptr< Bonuses::BonusMeleeDefense >	bonus_melee_defense ()

void	set_bonus_melee_defense (std::shared_ptr< Bonuses::BonusMeleeDefense > b)

std::shared_ptr< Bonuses::BonusRangedDefense >	bonus_ranged_defense ()

void	set_bonus_ranged_defense (std::shared_ptr< Bonuses::BonusRangedDefense > b)

std::shared_ptr< Bonuses::BonusDoubleAttackPercent >	bonus_double_attack_percent ()

void	set_bonus_double_attack_percent (std::shared_ptr< Bonuses::BonusDoubleAttackPercent > b)

std::shared_ptr< Bonuses::BonusMagicAttackPercent >	bonus_magic_attack_percent ()

void	set_bonus_magic_attack_percent (std::shared_ptr< Bonuses::BonusMagicAttackPercent > b)

std::shared_ptr< Bonuses::BonusAttackPercent >	bonus_attack_percent ()

void	set_bonus_attack_percent (std::shared_ptr< Bonuses::BonusAttackPercent > b)

std::shared_ptr< Bonuses::BonusMagicDefensePercent >	bonus_magic_defense_percent ()

void	set_bonus_magic_defense_percent (std::shared_ptr< Bonuses::BonusMagicDefensePercent > b)

std::shared_ptr< Bonuses::BonusMiscDefensePercent >	bonus_misc_defense_percent ()

void	set_bonus_misc_defense_percent (std::shared_ptr< Bonuses::BonusMiscDefensePercent > b)

std::shared_ptr< Bonuses::BonusPerfectHitPercent >	bonus_perfect_hit_percent ()

void	set_bonus_perfect_hit_percent (std::shared_ptr< Bonuses::BonusPerfectHitPercent > b)

std::shared_ptr< Bonuses::BonusCriticalPercent >	bonus_critical_percent ()

void	set_bonus_critical_percent (std::shared_ptr< Bonuses::BonusCriticalPercent > b)

std::shared_ptr< Bonuses::BonusGetZenyNum >	bonus_get_zeny_num ()

void	set_bonus_get_zeny_num (std::shared_ptr< Bonuses::BonusGetZenyNum > b)

std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForElement >	bonus_attack_on_defense_ratio_for_element ()

void	set_bonus_attack_on_defense_ratio_for_element (std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForElement > b)

std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForRace >	bonus_attack_on_defense_ratio_for_race ()

void	set_bonus_attack_on_defense_ratio_for_race (std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForRace > b)

std::shared_ptr< Bonuses::BonusHitPercent >	bonus_hit_percent ()

void	set_bonus_hit_percent (std::shared_ptr< Bonuses::BonusHitPercent > b)

std::shared_ptr< Bonuses::BonusFleePercent >	bonus_flee_percent ()

void	set_bonus_flee_percent (std::shared_ptr< Bonuses::BonusFleePercent > b)

std::shared_ptr< Bonuses::BonusPerfectDodgePercent >	bonus_perfect_dodge_percent ()

void	set_bonus_perfect_dodge_percent (std::shared_ptr< Bonuses::BonusPerfectDodgePercent > b)

std::shared_ptr< Bonuses::BonusSoftDefensePercent >	bonus_soft_defense_percent ()

void	set_bonus_soft_defense_percent (std::shared_ptr< Bonuses::BonusSoftDefensePercent > b)

std::shared_ptr< Bonuses::BonusHardDefensePercent >	bonus_hard_defense_percent ()

void	set_bonus_hard_defense_percent (std::shared_ptr< Bonuses::BonusHardDefensePercent > b)

std::shared_ptr< Bonuses::BonusSoftMagicalDefensePercent >	bonus_soft_magical_defense_percent ()

void	set_bonus_soft_magical_defense_percent (std::shared_ptr< Bonuses::BonusSoftMagicalDefensePercent > b)

std::shared_ptr< Bonuses::BonusHardMagicalDefensePercent >	bonus_hard_magical_defense_percent ()

void	set_bonus_hard_magical_defense_percent (std::shared_ptr< Bonuses::BonusHardMagicalDefensePercent > b)

std::shared_ptr< Bonuses::BonusRestartWithFullRecovery >	bonus_restart_with_full_recovery ()

void	set_bonus_restart_with_full_recovery (std::shared_ptr< Bonuses::BonusRestartWithFullRecovery > b)

std::shared_ptr< Bonuses::BonusCastCancelImmunity >	bonus_cast_cancel_immunity ()

void	set_bonus_cast_cancel_immunity (std::shared_ptr< Bonuses::BonusCastCancelImmunity > b)

std::shared_ptr< Bonuses::BonusSizeModifierImmunity >	bonus_size_modifier_immunity ()

void	set_bonus_size_modifier_immunity (std::shared_ptr< Bonuses::BonusSizeModifierImmunity > b)

std::shared_ptr< Bonuses::BonusMagicDamageImmunity >	bonus_magic_damage_immunity ()

void	set_bonus_magic_damage_immunity (std::shared_ptr< Bonuses::BonusMagicDamageImmunity > b)

std::shared_ptr< Bonuses::BonusWeaponDamageImmunity >	bonus_weapon_damage_immunity ()

void	set_bonus_weapon_damage_immunity (std::shared_ptr< Bonuses::BonusWeaponDamageImmunity > b)

std::shared_ptr< Bonuses::BonusGemstoneImmunity >	bonus_gemstone_immunity ()

void	set_bonus_gemstone_immunity (std::shared_ptr< Bonuses::BonusGemstoneImmunity > b)

std::shared_ptr< Bonuses::BonusGearFuelImmunity >	bonus_gear_fuel_immunity ()

void	set_bonus_gear_fuel_immunity (std::shared_ptr< Bonuses::BonusGearFuelImmunity > b)

std::shared_ptr< Bonuses::BonusInfiniteEndure >	bonus_infinite_endure ()

void	set_bonus_infinite_endure (std::shared_ptr< Bonuses::BonusInfiniteEndure > b)

std::shared_ptr< Bonuses::BonusUnbreakableWeapon >	bonus_unbreakable_weapon ()

void	set_bonus_unbreakable_weapon (std::shared_ptr< Bonuses::BonusUnbreakableWeapon > b)

std::shared_ptr< Bonuses::BonusUnbreakableArmor >	bonus_unbreakable_armor ()

void	set_bonus_unbreakable_armor (std::shared_ptr< Bonuses::BonusUnbreakableArmor > b)

std::shared_ptr< Bonuses::BonusUnbreakableHelm >	bonus_unbreakable_helm ()

void	set_bonus_unbreakable_helm (std::shared_ptr< Bonuses::BonusUnbreakableHelm > b)

std::shared_ptr< Bonuses::BonusUnbreakableShield >	bonus_unbreakable_shield ()

void	set_bonus_unbreakable_shield (std::shared_ptr< Bonuses::BonusUnbreakableShield > b)

std::shared_ptr< Bonuses::BonusSPGainOnMobKill >	bonus_sp_gain_on_mob_kill ()

void	set_bonus_sp_gain_on_mob_kill (std::shared_ptr< Bonuses::BonusSPGainOnMobKill > b)

std::shared_ptr< Bonuses::BonusHPGainOnMobKill >	bonus_hp_gain_on_mob_kill ()

void	set_bonus_hp_gain_on_mob_kill (std::shared_ptr< Bonuses::BonusHPGainOnMobKill > b)

std::shared_ptr< Bonuses::BonusDamageSplashRange >	bonus_damage_splash_range ()

void	set_bonus_damage_splash_range (std::shared_ptr< Bonuses::BonusDamageSplashRange > b)

std::shared_ptr< Bonuses::BonusMeleeWeaponDamageReflectPercentOnSelf >	bonus_melee_weapon_damage_reflect_percent_on_self ()

void	set_bonus_melee_weapon_damage_reflect_percent_on_self (std::shared_ptr< Bonuses::BonusMeleeWeaponDamageReflectPercentOnSelf > b)

std::shared_ptr< Bonuses::BonusRangedWeaponDamageReflectPercentOnSelf >	bonus_ranged_weapon_damage_reflect_percent_on_self ()

void	set_bonus_ranged_weapon_damage_reflect_percent_on_self (std::shared_ptr< Bonuses::BonusRangedWeaponDamageReflectPercentOnSelf > b)

std::shared_ptr< Bonuses::BonusWeaponBreakPercent >	bonus_weapon_break_percent ()

void	set_bonus_weapon_break_percent (std::shared_ptr< Bonuses::BonusWeaponBreakPercent > b)

std::shared_ptr< Bonuses::BonusArmorBreakPercent >	bonus_armor_break_percent ()

void	set_bonus_armor_break_percent (std::shared_ptr< Bonuses::BonusArmorBreakPercent > b)

std::shared_ptr< Bonuses::BonusAddStealPercent >	bonus_add_steal_percent ()

void	set_bonus_add_steal_percent (std::shared_ptr< Bonuses::BonusAddStealPercent > b)

std::shared_ptr< Bonuses::BonusCriticalDamagePercent >	bonus_critical_damage_percent ()

void	set_bonus_critical_damage_percent (std::shared_ptr< Bonuses::BonusCriticalDamagePercent > b)

std::shared_ptr< Bonuses::BonusDisableHPRecovery >	bonus_disable_hp_recovery ()

void	set_bonus_disable_hp_recovery (std::shared_ptr< Bonuses::BonusDisableHPRecovery > b)

std::shared_ptr< Bonuses::BonusDisableSPRecovery >	bonus_disable_sp_recovery ()

void	set_bonus_disable_sp_recovery (std::shared_ptr< Bonuses::BonusDisableSPRecovery > b)

std::shared_ptr< Bonuses::BonusMagicDamageReflectPercentOnSelf >	bonus_magic_damage_reflect_percent_on_self ()

void	set_bonus_magic_damage_reflect_percent_on_self (std::shared_ptr< Bonuses::BonusMagicDamageReflectPercentOnSelf > b)

std::shared_ptr< Bonuses::BonusShortWeaponDamagePercent >	bonus_short_weapon_damage_percent ()

void	set_bonus_short_weapon_damage_percent (std::shared_ptr< Bonuses::BonusShortWeaponDamagePercent > b)

std::shared_ptr< Bonuses::BonusLongWeaponDamagePercent >	bonus_long_weapon_damage_percent ()

void	set_bonus_long_weapon_damage_percent (std::shared_ptr< Bonuses::BonusLongWeaponDamagePercent > b)

std::shared_ptr< Bonuses::BonusItemUsageImmunity >	bonus_item_usage_immunity ()

void	set_bonus_item_usage_immunity (std::shared_ptr< Bonuses::BonusItemUsageImmunity > b)

std::shared_ptr< Bonuses::BonusKnockBackImmunity >	bonus_knock_back_immunity ()

void	set_bonus_knock_back_immunity (std::shared_ptr< Bonuses::BonusKnockBackImmunity > b)

std::shared_ptr< Bonuses::BonusHPVanishPercent >	bonus_hp_vanish_percent ()

void	set_bonus_hp_vanish_percent (std::shared_ptr< Bonuses::BonusHPVanishPercent > b)

std::shared_ptr< Bonuses::BonusSPVanishPercent >	bonus_sp_vanish_percent ()

void	set_bonus_sp_vanish_percent (std::shared_ptr< Bonuses::BonusSPVanishPercent > b)

std::shared_ptr< Bonuses::BonusRaise >	bonus_raise ()

void	set_bonus_raise (std::shared_ptr< Bonuses::BonusRaise > b)

std::shared_ptr< Bonuses::BonusAddItemDropOnMonsterKill >	bonus_add_item_drop_on_monster_kill ()

void	set_bonus_add_item_drop_on_monster_kill (std::shared_ptr< Bonuses::BonusAddItemDropOnMonsterKill > b)

std::shared_ptr< Bonuses::BonusHPDrainOnMonsterKill >	bonus_hp_drain_on_monster_kill ()

void	set_bonus_hp_drain_on_monster_kill (std::shared_ptr< Bonuses::BonusHPDrainOnMonsterKill > b)

std::shared_ptr< Bonuses::BonusSPDrainOnMonsterKill >	bonus_sp_drain_on_monster_kill ()

void	set_bonus_sp_drain_on_monster_kill (std::shared_ptr< Bonuses::BonusSPDrainOnMonsterKill > b)

void	add_bonus (std::shared_ptr< Bonuses::IBonusArray > ba)

void	remove_bonus (std::shared_ptr< Bonuses::IBonusArray > ba)

std::shared_ptr< Bonuses::IBonusArray >	get_bonus_array (status_point_type type)

std::shared_ptr< Bonuses::BonusAddAttackPercentageToElement >	bonus_add_attack_percentage_to_element ()

void	set_bonus_add_attack_percentage_to_element (std::shared_ptr< Bonuses::BonusAddAttackPercentageToElement > b)

std::shared_ptr< Bonuses::BonusAddAttackPercentageToRace >	bonus_add_attack_percentage_to_race ()

void	set_bonus_add_attack_percentage_to_race (std::shared_ptr< Bonuses::BonusAddAttackPercentageToRace > b)

std::shared_ptr< Bonuses::BonusAddAttackPercentageToSize >	bonus_add_attack_percentage_to_size ()

void	set_bonus_add_attack_percentage_to_size (std::shared_ptr< Bonuses::BonusAddAttackPercentageToSize > b)

std::shared_ptr< Bonuses::BonusSubAttackPercentageFromElement >	bonus_sub_attack_percentage_from_element ()

void	set_bonus_sub_attack_percentage_from_element (std::shared_ptr< Bonuses::BonusSubAttackPercentageFromElement > b)

std::shared_ptr< Bonuses::BonusSubAttackPercentageFromRace >	bonus_sub_attack_percentage_from_race ()

void	set_bonus_sub_attack_percentage_from_race (std::shared_ptr< Bonuses::BonusSubAttackPercentageFromRace > b)

std::shared_ptr< Bonuses::BonusAddEffectOnDamage >	bonus_add_effect_on_damage ()

void	set_bonus_add_effect_on_damage (std::shared_ptr< Bonuses::BonusAddEffectOnDamage > b)

std::shared_ptr< Bonuses::BonusAddEffectWhenDamaged >	bonus_add_effect_when_damaged ()

void	set_bonus_add_effect_when_damaged (std::shared_ptr< Bonuses::BonusAddEffectWhenDamaged > b)

std::shared_ptr< Bonuses::BonusRessistEffect >	bonus_ressist_effect ()

void	set_bonus_ressist_effect (std::shared_ptr< Bonuses::BonusRessistEffect > b)

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToElement >	bonus_add_magic_attack_percentage_to_element ()

void	set_bonus_add_magic_attack_percentage_to_element (std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToElement > b)

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToRace >	bonus_add_magic_attack_to_Race ()

void	set_bonus_add_magic_attack_percentage_to_race (std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToRace > b)

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToSize >	bonus_add_magic_attack_percentage_to_size ()

void	set_bonus_add_magic_attack_percentage_to_size (std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToSize > b)

std::shared_ptr< Bonuses::BonusAddEffectOnMagicAttack >	bonus_add_effect_on_magic_attack ()

void	set_bonus_add_effect_on_magic_attack (std::shared_ptr< Bonuses::BonusAddEffectOnMagicAttack > b)

std::shared_ptr< Bonuses::BonusResistMagicAttackFromRace >	bonus_resist_magic_attack_from_race ()

void	set_bonus_resist_magic_attack_from_race (std::shared_ptr< Bonuses::BonusResistMagicAttackFromRace > b)

std::shared_ptr< Bonuses::BonusAddDamageToClass >	bonus_add_damage_to_class ()

void	set_bonus_add_damage_to_class (std::shared_ptr< Bonuses::BonusAddDamageToClass > b)

std::shared_ptr< Bonuses::BonusAddMagicDamageToClass >	bonus_add_magic_damage_to_class ()

void	set_bonus_add_magic_damage_to_class (std::shared_ptr< Bonuses::BonusAddMagicDamageToClass > b)

std::shared_ptr< Bonuses::BonusAddDefenseToClass >	bonus_add_defense_to_class ()

void	set_bonus_add_defense_to_class (std::shared_ptr< Bonuses::BonusAddDefenseToClass > b)

std::shared_ptr< Bonuses::BonusAddMagicalDefenseToClass >	bonus_add_magical_defense_to_class ()

void	set_bonus_add_magical_defense_to_class (std::shared_ptr< Bonuses::BonusAddMagicalDefenseToClass > b)

std::shared_ptr< Bonuses::BonusHPDrainPercent >	bonus_hp_drain_percent ()

void	set_bonus_hp_drain_percent (std::shared_ptr< Bonuses::BonusHPDrainPercent > b)

std::shared_ptr< Bonuses::BonusHPDrainValue >	bonus_hp_drain_value ()

void	set_bonus_hp_drain_value (std::shared_ptr< Bonuses::BonusHPDrainValue > b)

std::shared_ptr< Bonuses::BonusSPDrainPercent >	bonus_sp_drain_percent ()

void	set_bonus_sp_drain_percent (std::shared_ptr< Bonuses::BonusSPDrainPercent > b)

std::shared_ptr< Bonuses::BonusSPDrainValue >	bonus_sp_drain_value ()

void	set_bonus_sp_drain_value (std::shared_ptr< Bonuses::BonusSPDrainValue > b)

std::shared_ptr< Bonuses::BonusAddWeaponComaToElement >	bonus_add_weapon_coma_to_element ()

void	set_bonus_add_weapon_coma_to_element (std::shared_ptr< Bonuses::BonusAddWeaponComaToElement > b)

std::shared_ptr< Bonuses::BonusAddWeaponComaToRace >	bonus_add_weapon_coma_to_race ()

void	set_bonus_add_weapon_coma_to_race (std::shared_ptr< Bonuses::BonusAddWeaponComaToRace > b)

std::shared_ptr< Bonuses::BonusAddWeaponComaToSubElement >	bonus_add_weapon_coma_to_sub_element ()

void	set_bonus_add_weapon_coma_to_sub_element (std::shared_ptr< Bonuses::BonusAddWeaponComaToSubElement > b)

std::shared_ptr< Bonuses::BonusAddWeaponComaToSubRace >	bonus_add_weapon_coma_to_sub_race ()

void	set_bonus_add_weapon_coma_to_sub_race (std::shared_ptr< Bonuses::BonusAddWeaponComaToSubRace > b)

std::shared_ptr< Bonuses::BonusAddAttack >	bonus_add_attack ()

void	set_bonus_add_attack (std::shared_ptr< Bonuses::BonusAddAttack > b)

std::shared_ptr< Bonuses::BonusAddAttackPercent >	bonus_add_attack_percent ()

void	set_bonus_add_attack_percent (std::shared_ptr< Bonuses::BonusAddAttackPercent > b)

std::shared_ptr< Bonuses::BonusCriticalRace >	bonus_critical_race ()

void	set_bonus_critical_race (std::shared_ptr< Bonuses::BonusCriticalRace > b)

std::shared_ptr< Bonuses::BonusCriticalRacePercent >	bonus_critical_race_percent ()

void	set_bonus_critical_race_percent (std::shared_ptr< Bonuses::BonusCriticalRacePercent > b)

std::shared_ptr< Bonuses::BonusDamageReductionAgainstSize >	bonus_damage_reduction_against_size ()

void	set_bonus_damage_reduction_against_size (std::shared_ptr< Bonuses::BonusDamageReductionAgainstSize > b)

std::shared_ptr< Bonuses::BonusMagicDamageReductionAgainstSize >	bonus_magic_damage_reduction_against_size ()

void	set_bonus_magic_damage_reduction_against_size (std::shared_ptr< Bonuses::BonusMagicDamageReductionAgainstSize > b)

std::shared_ptr< Bonuses::BonusExpPercentPerRace >	bonus_exp_percent_per_race ()

void	set_bonus_exp_percent_per_race (std::shared_ptr< Bonuses::BonusExpPercentPerRace > b)

std::shared_ptr< Bonuses::BonusJobPercentPerRace >	bonus_job_percent_per_race ()

void	set_bonus_job_percent_per_race (std::shared_ptr< Bonuses::BonusJobPercentPerRace > b)

std::shared_ptr< Bonuses::BonusSkillAttack >	bonus_skill_attack ()

void	set_bonus_skill_attack (std::shared_ptr< Bonuses::BonusSkillAttack > b)

std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkillByPercent >	bonus_reduce_sp_consumption_of_skill_by_percent ()

void	set_bonus_reduce_sp_consumption_of_skill_by_percent (std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkillByPercent > b)

std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkill >	bonus_reduce_sp_consumption_of_skill ()

void	set_bonus_reduce_sp_consumption_of_skill (std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkill > b)

std::shared_ptr< Bonuses::BonusLearnedSkillHeal >	bonus_learned_skill_heal ()

void	set_bonus_learned_skill_heal (std::shared_ptr< Bonuses::BonusLearnedSkillHeal > b)

std::shared_ptr< Bonuses::BonusHealOfSkillCastedOnSelf >	bonus_heal_of_skill_casted_on_self ()

void	set_bonus_heal_of_skill_casted_on_self (std::shared_ptr< Bonuses::BonusHealOfSkillCastedOnSelf > b)

std::shared_ptr< Bonuses::BonusSkillKnockback >	bonus_skill_knockback ()

void	set_bonus_skill_knockback (std::shared_ptr< Bonuses::BonusSkillKnockback > b)

std::shared_ptr< Bonuses::BonusSkillCastPercent >	bonus_skill_cast_percent ()

void	set_bonus_skill_cast_percent (std::shared_ptr< Bonuses::BonusSkillCastPercent > b)

std::shared_ptr< Bonuses::BonusSkillCooldown >	bonus_skill_cooldown ()

void	set_bonus_skill_cooldown (std::shared_ptr< Bonuses::BonusSkillCooldown > b)

std::shared_ptr< Bonuses::BonusSkillFixCastPercent >	bonus_skill_fix_cast_percent ()

void	set_bonus_skill_fix_cast_percent (std::shared_ptr< Bonuses::BonusSkillFixCastPercent > b)

std::shared_ptr< Bonuses::BonusSkillVariableCastPercent >	bonus_skill_variable_cast_percent ()

void	set_bonus_skill_variable_cast_percent (std::shared_ptr< Bonuses::BonusSkillVariableCastPercent > b)

std::shared_ptr< Bonuses::BonusResistSkillDamagePercent >	bonus_resist_skill_damage_percent ()

void	set_bonus_resist_skill_damage_percent (std::shared_ptr< Bonuses::BonusResistSkillDamagePercent > b)

std::shared_ptr< Bonuses::BonusIgnoreDefenseFromElement >	bonus_ignore_defense_from_element ()

void	set_bonus_ignore_defense_from_element (std::shared_ptr< Bonuses::BonusIgnoreDefenseFromElement > b)

std::shared_ptr< Bonuses::BonusIgnoreDefenseFromRace >	bonus_ignore_defense_from_race ()

void	set_bonus_ignore_defense_from_race (std::shared_ptr< Bonuses::BonusIgnoreDefenseFromRace > b)

std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromElement >	bonus_ignore_magic_defense_from_element ()

void	set_bonus_ignore_magic_defense_from_element (std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromElement > b)

std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromRace >	bonus_ignore_magic_defense_from_race ()

void	set_bonus_ignore_magic_defense_from_race (std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromRace > b)

std::shared_ptr< Bonuses::BonusAddEleWeaponDamagePercent >	bonus_add_ele_weapon_damage_percent ()

void	set_bonus_add_ele_weapon_damage_percent (std::shared_ptr< Bonuses::BonusAddEleWeaponDamagePercent > b)

std::shared_ptr< Bonuses::BonusAddEleMagicDamagePercent >	bonus_add_ele_magic_damage_percent ()

void	set_bonus_add_ele_magic_damage_percent (std::shared_ptr< Bonuses::BonusAddEleMagicDamagePercent > b)

std::shared_ptr< Bonuses::BonusAutoSpellOnSkill >	bonus_auto_spell_on_skill ()

void	set_bonus_auto_spell_on_skill (std::shared_ptr< Bonuses::BonusAutoSpellOnSkill > b)

std::shared_ptr< Bonuses::BonusAutoSpellOnAttack >	bonus_auto_spell_on_attack ()

void	set_bonus_auto_spell_on_attack (std::shared_ptr< Bonuses::BonusAutoSpellOnAttack > b)

std::shared_ptr< Bonuses::BonusAutoSpellOnReceiveDamage >	bonus_auto_spell_on_receive_damage ()

void	set_bonus_auto_spell_on_receive_damage (std::shared_ptr< Bonuses::BonusAutoSpellOnReceiveDamage > b)

std::shared_ptr< Bonuses::BonusAutoSpellOnSelf >	bonus_auto_spell_on_self ()

void	set_bonus_auto_spell_on_self (std::shared_ptr< Bonuses::BonusAutoSpellOnSelf > b)

Protected Member Functions
std::shared_ptr< Unit >	unit ()

Protected Attributes
unit_type	_type { UNIT_PLAYER }

bool	_is_initialized { false }

Private Attributes
std::shared_ptr< StatusRegistry >	_status_registry { nullptr }

std::weak_ptr< Unit >	_unit

std::shared_ptr< Strength >	_str

std::shared_ptr< Agility >	_agi

std::shared_ptr< Vitality >	_vit

std::shared_ptr< Intelligence >	_int

std::shared_ptr< Dexterity >	_dex

std::shared_ptr< Luck >	_luk

std::shared_ptr< StrengthPointCost >	_str_cost

std::shared_ptr< AgilityPointCost >	_agi_cost

std::shared_ptr< VitalityPointCost >	_vit_cost

std::shared_ptr< IntelligencePointCost >	_int_cost

std::shared_ptr< DexterityPointCost >	_dex_cost

std::shared_ptr< LuckPointCost >	_luk_cost

std::shared_ptr< StatusPoint >	_status_point

std::shared_ptr< SkillPoint >	_skill_point

std::shared_ptr< MaxHP >	_max_hp

std::shared_ptr< MaxSP >	_max_sp

std::shared_ptr< CurrentHP >	_current_hp

std::shared_ptr< CurrentSP >	_current_sp

std::shared_ptr< BaseLevel >	_base_level

std::shared_ptr< JobLevel >	_job_level

std::shared_ptr< BaseExperience >	_base_exp

std::shared_ptr< JobExperience >	_job_exp

std::shared_ptr< NextBaseExperience >	_next_base_exp

std::shared_ptr< NextJobExperience >	_next_job_exp

std::shared_ptr< MovementSpeed >	_movement_speed

std::shared_ptr< MaxWeight >	_max_weight

std::shared_ptr< CurrentWeight >	_current_weight

std::shared_ptr< AttackRange >	_attack_range

std::shared_ptr< StatusATK >	_status_atk

std::shared_ptr< EquipATK >	_equip_atk

std::shared_ptr< StatusMATK >	_status_matk

std::shared_ptr< EquipMATK >	_equip_matk

std::shared_ptr< SoftDEF >	_soft_def

std::shared_ptr< HardDEF >	_hard_def

std::shared_ptr< SoftMDEF >	_soft_mdef

std::shared_ptr< HardMDEF >	_hard_mdef

std::shared_ptr< HIT >	_hit

std::shared_ptr< CRIT >	_crit

std::shared_ptr< FLEE >	_flee

std::shared_ptr< AttackSpeed >	_aspd

std::shared_ptr< HPRegeneration >	_hp_regeneration

std::shared_ptr< SPRegeneration >	_sp_regeneration

std::shared_ptr< BaseAppearance >	_base_appearance

std::shared_ptr< HairColor >	_hair_color

std::shared_ptr< ClothColor >	_cloth_color

std::shared_ptr< WeaponSprite >	_weapon_sprite

std::shared_ptr< ShieldSprite >	_shield_sprite

std::shared_ptr< RobeSprite >	_robe_sprite

std::shared_ptr< HeadTopSprite >	_head_top_sprite

std::shared_ptr< HeadMidSprite >	_head_mid_sprite

std::shared_ptr< HeadBottomSprite >	_head_bottom_sprite

std::shared_ptr< HairStyle >	_hair_style

std::shared_ptr< BodyStyle >	_body_style

std::shared_ptr< Zeny >	_zeny

std::shared_ptr< Honor >	_honor

std::shared_ptr< Manner >	_manner

std::shared_ptr< Virtue >	_virtue

std::shared_ptr< AttackDelay >	_attack_delay

std::shared_ptr< DamageWalkDelay >	_damage_walk_delay

std::shared_ptr< BaseAttack >	_base_attack

std::shared_ptr< WeaponAttackLeft >	_weapon_attack_left

std::shared_ptr< WeaponAttackRight >	_weapon_attack_right

std::shared_ptr< WeaponAttackCombined >	_weapon_attack_combined

std::shared_ptr< UnitSize >	_size

std::shared_ptr< MobWeaponAttack >	_creature_weapon_attack

std::shared_ptr< MobWeaponAttack >	_creature_weapon_attack_magic

std::shared_ptr< MobAttackDamage >	_creature_attack_damage

std::shared_ptr< MobMagicAttackDamage >	_creature_magic_attack_damage

std::shared_ptr< MobViewRange >	_creature_view_range

std::shared_ptr< MobChaseRange >	_creature_chase_range

std::shared_ptr< MobPrimaryRace >	_creature_primary_race

std::shared_ptr< MobSecondaryRace >	_creature_secondary_race

std::shared_ptr< MobElement >	_creature_element

std::shared_ptr< MobElementLevel >	_creature_element_level

std::shared_ptr< MobMode >	_creature_mode

std::vector< std::shared_ptr< Attribute > >	_attributes

std::vector< std::shared_ptr< Appearance > >	_appearances

std::vector< std::shared_ptr< Bonuses::Bonus > >	_bonuses

std::vector< std::shared_ptr< Bonuses::IBonusArray > >	_bonus_arrays

std::shared_ptr< bonuses >	_bonus

Constructor & Destructor Documentation

◆ Status()

Status::Status	(	std::weak_ptr< Unit >	unit,
		unit_type	type
	)

    : _unit(unit), _type(type)
{
    _status_registry = std::make_shared<StatusRegistry>();
}

References _status_registry.

◆ ~Status()

Status::~Status ( )

254{

255}

Member Function Documentation

◆ add_appearance()

void Horizon::Zone::Traits::Status::add_appearance ( std::shared_ptr< Appearance > appearance )

inline

764{ _appearances.push_back(appearance); }

Horizon::Zone::Traits::Status::_appearances

std::vector< std::shared_ptr< Appearance > > _appearances

Definition: Status.hpp:1875

References _appearances.

Referenced by set_base_appearance(), set_body_style(), set_cloth_color(), set_hair_color(), set_hair_style(), set_head_bottom_sprite(), set_head_mid_sprite(), set_head_top_sprite(), set_robe_sprite(), set_shield_sprite(), and set_weapon_sprite().

Here is the caller graph for this function:

◆ add_attribute()

void Horizon::Zone::Traits::Status::add_attribute ( std::shared_ptr< Attribute > attribute )

inline

748{ _attributes.push_back(attribute); }

Horizon::Zone::Traits::Status::_attributes

std::vector< std::shared_ptr< Attribute > > _attributes

Definition: Status.hpp:1874

References _attributes.

Referenced by set_agility(), set_agility_cost(), set_attack_delay(), set_attack_range(), set_attack_speed(), set_base_attack(), set_base_experience(), set_base_level(), set_creature_attack_damage(), set_creature_chase_range(), set_creature_element(), set_creature_element_level(), set_creature_magic_attack_damage(), set_creature_mode(), set_creature_primary_race(), set_creature_secondary_race(), set_creature_view_range(), set_creature_weapon_attack(), set_creature_weapon_attack_magic(), set_crit(), set_current_hp(), set_current_sp(), set_current_weight(), set_damage_walk_delay(), set_dexterity(), set_dexterity_cost(), set_equip_atk(), set_equip_matk(), set_flee(), set_hard_def(), set_hard_mdef(), set_hit(), set_honor(), set_hp_regeneration(), set_intelligence(), set_intelligence_cost(), set_job_experience(), set_job_level(), set_luck(), set_luck_cost(), set_manner(), set_max_hp(), set_max_sp(), set_max_weight(), set_movement_speed(), set_next_base_experience(), set_next_job_experience(), set_size(), set_skill_point(), set_soft_def(), set_soft_mdef(), set_sp_regeneration(), set_status_atk(), set_status_matk(), set_status_point(), set_strength(), set_strength_cost(), set_virtue(), set_vitality(), set_vitality_cost(), set_weapon_attack_combined(), set_weapon_attack_left(), set_weapon_attack_right(), and set_zeny().

◆ add_bonus() [1/2]

void Horizon::Zone::Traits::Status::add_bonus ( std::shared_ptr< Bonuses::Bonus > bonus )

inline

784{ _bonuses.push_back(bonus); }

Horizon::Zone::Traits::Status::_bonuses

std::vector< std::shared_ptr< Bonuses::Bonus > > _bonuses

Definition: Status.hpp:1876

References _bonuses.

◆ add_bonus() [2/2]

void Horizon::Zone::Traits::Status::add_bonus ( std::shared_ptr< Bonuses::IBonusArray > ba )

inline

1336{ _bonus_arrays.push_back(ba); }

Horizon::Zone::Traits::Status::_bonus_arrays

std::vector< std::shared_ptr< Bonuses::IBonusArray > > _bonus_arrays

Definition: Status.hpp:1877

References _bonus_arrays.

◆ agility()

std::shared_ptr< Agility > Horizon::Zone::Traits::Status::agility ( )

inline

196{ return _agi; }

Horizon::Zone::Traits::Status::_agi

std::shared_ptr< Agility > _agi

Definition: Status.hpp:1794

References _agi.

Referenced by get_status_base(), increase_status_point(), initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ agility_cost()

std::shared_ptr< AgilityPointCost > Horizon::Zone::Traits::Status::agility_cost ( )

inline

244{ return _agi_cost; }

Horizon::Zone::Traits::Status::_agi_cost

std::shared_ptr< AgilityPointCost > _agi_cost

Definition: Status.hpp:1800

References _agi_cost.

Referenced by increase_status_point(), and initialize().

Here is the caller graph for this function:

◆ attack_delay()

std::shared_ptr< AttackDelay > Horizon::Zone::Traits::Status::attack_delay ( )

inline

Combat Status.

598{ return _attack_delay; }

Horizon::Zone::Traits::Status::_attack_delay

std::shared_ptr< AttackDelay > _attack_delay

Definition: Status.hpp:1854

References _attack_delay.

Referenced by initialize().

Here is the caller graph for this function:

◆ attack_range()

std::shared_ptr< AttackRange > Horizon::Zone::Traits::Status::attack_range ( )

inline

404{ return _attack_range; }

Horizon::Zone::Traits::Status::_attack_range

std::shared_ptr< AttackRange > _attack_range

Definition: Status.hpp:1820

References _attack_range.

Referenced by on_equipment_changed().

Here is the caller graph for this function:

◆ attack_speed()

std::shared_ptr< AttackSpeed > Horizon::Zone::Traits::Status::attack_speed ( )

inline

503{ return _aspd; }

Horizon::Zone::Traits::Status::_aspd

std::shared_ptr< AttackSpeed > _aspd

Definition: Status.hpp:1833

References _aspd.

Referenced by initialize(), on_equipment_changed(), and on_job_changed().

Here is the caller graph for this function:

◆ base_appearance()

std::shared_ptr< BaseAppearance > Horizon::Zone::Traits::Status::base_appearance ( )

inline

Appearance.

530{ return _base_appearance; }

Horizon::Zone::Traits::Status::_base_appearance

std::shared_ptr< BaseAppearance > _base_appearance

Definition: Status.hpp:1837

References _base_appearance.

Referenced by on_job_changed().

Here is the caller graph for this function:

◆ base_attack()

std::shared_ptr< BaseAttack > Horizon::Zone::Traits::Status::base_attack ( )

inline

614{ return _base_attack; }

Horizon::Zone::Traits::Status::_base_attack

std::shared_ptr< BaseAttack > _base_attack

Definition: Status.hpp:1856

References _base_attack.

Referenced by initialize(), and on_equipment_changed().

Here is the caller graph for this function:

◆ base_experience()

std::shared_ptr< BaseExperience > Horizon::Zone::Traits::Status::base_experience ( )

inline

348{ return _base_exp; }

Horizon::Zone::Traits::Status::_base_exp

std::shared_ptr< BaseExperience > _base_exp

Definition: Status.hpp:1813

References _base_exp.

Referenced by initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ base_level()

std::shared_ptr< BaseLevel > Horizon::Zone::Traits::Status::base_level ( )

inline

332{ return _base_level; }

Horizon::Zone::Traits::Status::_base_level

std::shared_ptr< BaseLevel > _base_level

Definition: Status.hpp:1811

References _base_level.

Referenced by initialize(), load(), on_job_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ body_style()

std::shared_ptr< BodyStyle > Horizon::Zone::Traits::Status::body_style ( )

inline

560{ return _body_style; }

Horizon::Zone::Traits::Status::_body_style

std::shared_ptr< BodyStyle > _body_style

Definition: Status.hpp:1847

References _body_style.

Referenced by save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ bonus_add_attack()

std::shared_ptr< Bonuses::BonusAddAttack > Horizon::Zone::Traits::Status::bonus_add_attack ( )

inline

1552{ return _bonus->_add_attack; }

Horizon::Zone::Traits::Status::_bonus

std::shared_ptr< bonuses > _bonus

Definition: Status.hpp:2006

References _bonus.

◆ bonus_add_attack_percent()

std::shared_ptr< Bonuses::BonusAddAttackPercent > Horizon::Zone::Traits::Status::bonus_add_attack_percent ( )

inline

1560{ return _bonus->_add_attack_percent; }

References _bonus.

◆ bonus_add_attack_percentage_to_element()

std::shared_ptr< Bonuses::BonusAddAttackPercentageToElement > Horizon::Zone::Traits::Status::bonus_add_attack_percentage_to_element ( )

inline

1352{ return _bonus->_add_attack_percentage_to_element; }

References _bonus.

◆ bonus_add_attack_percentage_to_race()

std::shared_ptr< Bonuses::BonusAddAttackPercentageToRace > Horizon::Zone::Traits::Status::bonus_add_attack_percentage_to_race ( )

inline

1360{ return _bonus->_add_attack_percentage_to_race; }

References _bonus.

◆ bonus_add_attack_percentage_to_size()

std::shared_ptr< Bonuses::BonusAddAttackPercentageToSize > Horizon::Zone::Traits::Status::bonus_add_attack_percentage_to_size ( )

inline

1368{ return _bonus->_add_attack_percentage_to_size; }

References _bonus.

◆ bonus_add_damage_to_class()

std::shared_ptr< Bonuses::BonusAddDamageToClass > Horizon::Zone::Traits::Status::bonus_add_damage_to_class ( )

inline

1456{ return _bonus->_add_damage_to_class; }

References _bonus.

◆ bonus_add_defense_to_class()

std::shared_ptr< Bonuses::BonusAddDefenseToClass > Horizon::Zone::Traits::Status::bonus_add_defense_to_class ( )

inline

1472{ return _bonus->_add_defense_to_class; }

References _bonus.

◆ bonus_add_effect_on_damage()

std::shared_ptr< Bonuses::BonusAddEffectOnDamage > Horizon::Zone::Traits::Status::bonus_add_effect_on_damage ( )

inline

1392{ return _bonus->_add_effect_on_damage; }

References _bonus.

◆ bonus_add_effect_on_magic_attack()

std::shared_ptr< Bonuses::BonusAddEffectOnMagicAttack > Horizon::Zone::Traits::Status::bonus_add_effect_on_magic_attack ( )

inline

1440{ return _bonus->_add_effect_on_magic_attack; }

References _bonus.

◆ bonus_add_effect_when_damaged()

std::shared_ptr< Bonuses::BonusAddEffectWhenDamaged > Horizon::Zone::Traits::Status::bonus_add_effect_when_damaged ( )

inline

1400{ return _bonus->_add_effect_when_damaged; }

References _bonus.

◆ bonus_add_ele_magic_damage_percent()

std::shared_ptr< Bonuses::BonusAddEleMagicDamagePercent > Horizon::Zone::Traits::Status::bonus_add_ele_magic_damage_percent ( )

inline

1744{ return _bonus->_add_ele_magic_damage_percent; }

References _bonus.

◆ bonus_add_ele_weapon_damage_percent()

std::shared_ptr< Bonuses::BonusAddEleWeaponDamagePercent > Horizon::Zone::Traits::Status::bonus_add_ele_weapon_damage_percent ( )

inline

1736{ return _bonus->_add_ele_weapon_damage_percent; }

References _bonus.

◆ bonus_add_item_drop_on_monster_kill()

std::shared_ptr< Bonuses::BonusAddItemDropOnMonsterKill > Horizon::Zone::Traits::Status::bonus_add_item_drop_on_monster_kill ( )

inline

1312{ return _bonus->_add_item_drop_on_monster_kill; }

References _bonus.

◆ bonus_add_magic_attack_percentage_to_element()

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToElement > Horizon::Zone::Traits::Status::bonus_add_magic_attack_percentage_to_element ( )

inline

1416{ return _bonus->_add_magic_attack_percentage_to_element; }

References _bonus.

◆ bonus_add_magic_attack_percentage_to_size()

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToSize > Horizon::Zone::Traits::Status::bonus_add_magic_attack_percentage_to_size ( )

inline

1432{ return _bonus->_add_magic_attack_percentage_to_size; }

References _bonus.

◆ bonus_add_magic_attack_to_Race()

std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToRace > Horizon::Zone::Traits::Status::bonus_add_magic_attack_to_Race ( )

inline

1424{ return _bonus->_add_magic_attack_percentage_to_race; }

References _bonus.

◆ bonus_add_magic_damage_to_class()

std::shared_ptr< Bonuses::BonusAddMagicDamageToClass > Horizon::Zone::Traits::Status::bonus_add_magic_damage_to_class ( )

inline

1464{ return _bonus->_add_magic_damage_to_class; }

References _bonus.

◆ bonus_add_magical_defense_to_class()

std::shared_ptr< Bonuses::BonusAddMagicalDefenseToClass > Horizon::Zone::Traits::Status::bonus_add_magical_defense_to_class ( )

inline

1480{ return _bonus->_add_magical_defense_to_class; }

References _bonus.

◆ bonus_add_movement_speed_percent()

std::shared_ptr< Bonuses::BonusAddMovementSpeedPercent > Horizon::Zone::Traits::Status::bonus_add_movement_speed_percent ( )

inline

872{ return _bonus->_bonus_add_movement_speed_percent; }

References _bonus.

◆ bonus_add_steal_percent()

std::shared_ptr< Bonuses::BonusAddStealPercent > Horizon::Zone::Traits::Status::bonus_add_steal_percent ( )

inline

1216{ return _bonus->_add_steal_percent; }

References _bonus.

◆ bonus_add_weapon_coma_to_element()

std::shared_ptr< Bonuses::BonusAddWeaponComaToElement > Horizon::Zone::Traits::Status::bonus_add_weapon_coma_to_element ( )

inline

1520{ return _bonus->_add_weapon_coma_to_element; }

References _bonus.

◆ bonus_add_weapon_coma_to_race()

std::shared_ptr< Bonuses::BonusAddWeaponComaToRace > Horizon::Zone::Traits::Status::bonus_add_weapon_coma_to_race ( )

inline

1528{ return _bonus->_add_weapon_coma_to_race; }

References _bonus.

◆ bonus_add_weapon_coma_to_sub_element()

std::shared_ptr< Bonuses::BonusAddWeaponComaToSubElement > Horizon::Zone::Traits::Status::bonus_add_weapon_coma_to_sub_element ( )

inline

1536{ return _bonus->_add_weapon_coma_to_sub_element; }

References _bonus.

◆ bonus_add_weapon_coma_to_sub_race()

std::shared_ptr< Bonuses::BonusAddWeaponComaToSubRace > Horizon::Zone::Traits::Status::bonus_add_weapon_coma_to_sub_race ( )

inline

1544{ return _bonus->_add_weapon_coma_to_sub_race; }

References _bonus.

◆ bonus_all_status()

std::shared_ptr< Bonuses::BonusAllStatus > Horizon::Zone::Traits::Status::bonus_all_status ( )

inline

800{ return _bonus->_all_status; }

References _bonus.

◆ bonus_armor_break_percent()

std::shared_ptr< Bonuses::BonusArmorBreakPercent > Horizon::Zone::Traits::Status::bonus_armor_break_percent ( )

inline

1208{ return _bonus->_armor_break_percent; }

References _bonus.

◆ bonus_attack_element()

std::shared_ptr< Bonuses::BonusAttackElement > Horizon::Zone::Traits::Status::bonus_attack_element ( )

inline

808{ return _bonus->_attack_element; }

References _bonus.

◆ bonus_attack_on_defense_ratio_for_element()

std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForElement > Horizon::Zone::Traits::Status::bonus_attack_on_defense_ratio_for_element ( )

inline

992{ return _bonus->_attack_on_defense_ratio_for_element; }

References _bonus.

◆ bonus_attack_on_defense_ratio_for_race()

std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForRace > Horizon::Zone::Traits::Status::bonus_attack_on_defense_ratio_for_race ( )

inline

1000{ return _bonus->_attack_on_defense_ratio_for_race; }

References _bonus.

◆ bonus_attack_percent()

std::shared_ptr< Bonuses::BonusAttackPercent > Horizon::Zone::Traits::Status::bonus_attack_percent ( )

inline

944{ return _bonus->_attack_percent; }

References _bonus.

◆ bonus_attack_range()

std::shared_ptr< Bonuses::BonusAttackRange > Horizon::Zone::Traits::Status::bonus_attack_range ( )

inline

856{ return _bonus->_attack_range; }

References _bonus.

◆ bonus_attack_range_percent()

std::shared_ptr< Bonuses::BonusAttackRangePercent > Horizon::Zone::Traits::Status::bonus_attack_range_percent ( )

inline

864{ return _bonus->_attack_range_percent; }

References _bonus.

◆ bonus_attack_speed_percent()

std::shared_ptr< Bonuses::BonusAttackSpeedPercent > Horizon::Zone::Traits::Status::bonus_attack_speed_percent ( )

inline

880{ return _bonus->_attack_speed_percent; }

References _bonus.

◆ bonus_auto_spell_on_attack()

std::shared_ptr< Bonuses::BonusAutoSpellOnAttack > Horizon::Zone::Traits::Status::bonus_auto_spell_on_attack ( )

inline

1760{ return _bonus->_auto_spell_on_attack; }

References _bonus.

◆ bonus_auto_spell_on_receive_damage()

std::shared_ptr< Bonuses::BonusAutoSpellOnReceiveDamage > Horizon::Zone::Traits::Status::bonus_auto_spell_on_receive_damage ( )

inline

1768{ return _bonus->_auto_spell_on_receive_damage; }

References _bonus.

◆ bonus_auto_spell_on_self()

std::shared_ptr< Bonuses::BonusAutoSpellOnSelf > Horizon::Zone::Traits::Status::bonus_auto_spell_on_self ( )

inline

1776{ return _bonus->_auto_spell_on_self; }

References _bonus.

◆ bonus_auto_spell_on_skill()

std::shared_ptr< Bonuses::BonusAutoSpellOnSkill > Horizon::Zone::Traits::Status::bonus_auto_spell_on_skill ( )

inline

1752{ return _bonus->_auto_spell_on_skill; }

References _bonus.

◆ bonus_cast_cancel_immunity()

std::shared_ptr< Bonuses::BonusCastCancelImmunity > Horizon::Zone::Traits::Status::bonus_cast_cancel_immunity ( )

inline

1072{ return _bonus->_cast_cancel_immunity; }

References _bonus.

◆ bonus_cast_percent()

std::shared_ptr< Bonuses::BonusCastPercent > Horizon::Zone::Traits::Status::bonus_cast_percent ( )

inline

824{ return _bonus->_cast_percent; }

References _bonus.

◆ bonus_critical_damage_percent()

std::shared_ptr< Bonuses::BonusCriticalDamagePercent > Horizon::Zone::Traits::Status::bonus_critical_damage_percent ( )

inline

1224{ return _bonus->_critical_damage_percent; }

References _bonus.

◆ bonus_critical_defense()

std::shared_ptr< Bonuses::BonusCriticalDefense > Horizon::Zone::Traits::Status::bonus_critical_defense ( )

inline

904{ return _bonus->_critical_defense; }

References _bonus.

◆ bonus_critical_percent()

std::shared_ptr< Bonuses::BonusCriticalPercent > Horizon::Zone::Traits::Status::bonus_critical_percent ( )

inline

976{ return _bonus->_critical_percent; }

References _bonus.

◆ bonus_critical_race()

std::shared_ptr< Bonuses::BonusCriticalRace > Horizon::Zone::Traits::Status::bonus_critical_race ( )

inline

1568{ return _bonus->_critical_race; }

References _bonus.

◆ bonus_critical_race_percent()

std::shared_ptr< Bonuses::BonusCriticalRacePercent > Horizon::Zone::Traits::Status::bonus_critical_race_percent ( )

inline

1576{ return _bonus->_critical_race_percent; }

References _bonus.

◆ bonus_damage_reduction_against_size()

std::shared_ptr< Bonuses::BonusDamageReductionAgainstSize > Horizon::Zone::Traits::Status::bonus_damage_reduction_against_size ( )

inline

1584{ return _bonus->_damage_reduction_against_size; }

References _bonus.

◆ bonus_damage_splash_range()

std::shared_ptr< Bonuses::BonusDamageSplashRange > Horizon::Zone::Traits::Status::bonus_damage_splash_range ( )

inline

1176{ return _bonus->_damage_splash_range; }

References _bonus.

◆ bonus_defense_element()

std::shared_ptr< Bonuses::BonusDefenseElement > Horizon::Zone::Traits::Status::bonus_defense_element ( )

inline

816{ return _bonus->_defense_element; }

References _bonus.

◆ bonus_disable_hp_recovery()

std::shared_ptr< Bonuses::BonusDisableHPRecovery > Horizon::Zone::Traits::Status::bonus_disable_hp_recovery ( )

inline

1232{ return _bonus->_disable_hp_recovery; }

References _bonus.

◆ bonus_disable_sp_recovery()

std::shared_ptr< Bonuses::BonusDisableSPRecovery > Horizon::Zone::Traits::Status::bonus_disable_sp_recovery ( )

inline

1240{ return _bonus->_disable_sp_recovery; }

References _bonus.

◆ bonus_double_attack_percent()

std::shared_ptr< Bonuses::BonusDoubleAttackPercent > Horizon::Zone::Traits::Status::bonus_double_attack_percent ( )

inline

928{ return _bonus->_double_attack_percent; }

References _bonus.

◆ bonus_exp_percent_per_race()

std::shared_ptr< Bonuses::BonusExpPercentPerRace > Horizon::Zone::Traits::Status::bonus_exp_percent_per_race ( )

inline

1600{ return _bonus->_exp_percent_per_race; }

References _bonus.

◆ bonus_flee_percent()

std::shared_ptr< Bonuses::BonusFleePercent > Horizon::Zone::Traits::Status::bonus_flee_percent ( )

inline

1016{ return _bonus->_flee_percent; }

References _bonus.

◆ bonus_gear_fuel_immunity()

std::shared_ptr< Bonuses::BonusGearFuelImmunity > Horizon::Zone::Traits::Status::bonus_gear_fuel_immunity ( )

inline

1112{ return _bonus->_gear_fuel_immunity; }

References _bonus.

◆ bonus_gemstone_immunity()

std::shared_ptr< Bonuses::BonusGemstoneImmunity > Horizon::Zone::Traits::Status::bonus_gemstone_immunity ( )

inline

1104{ return _bonus->_gemstone_immunity; }

References _bonus.

◆ bonus_get_zeny_num()

std::shared_ptr< Bonuses::BonusGetZenyNum > Horizon::Zone::Traits::Status::bonus_get_zeny_num ( )

inline

984{ return _bonus->_get_zeny_num; }

References _bonus.

◆ bonus_hard_defense_percent()

std::shared_ptr< Bonuses::BonusHardDefensePercent > Horizon::Zone::Traits::Status::bonus_hard_defense_percent ( )

inline

1040{ return _bonus->_hard_defense_percent; }

References _bonus.

◆ bonus_hard_magical_defense_percent()

std::shared_ptr< Bonuses::BonusHardMagicalDefensePercent > Horizon::Zone::Traits::Status::bonus_hard_magical_defense_percent ( )

inline

1056{ return _bonus->_hard_magical_defense_percent; }

References _bonus.

◆ bonus_heal_of_skill_casted_on_self()

std::shared_ptr< Bonuses::BonusHealOfSkillCastedOnSelf > Horizon::Zone::Traits::Status::bonus_heal_of_skill_casted_on_self ( )

inline

1648{ return _bonus->_heal_of_skill_casted_on_self; }

References _bonus.

◆ bonus_hit_percent()

std::shared_ptr< Bonuses::BonusHitPercent > Horizon::Zone::Traits::Status::bonus_hit_percent ( )

inline

1008{ return _bonus->_hit_percent; }

References _bonus.

◆ bonus_hp_drain_on_monster_kill()

std::shared_ptr< Bonuses::BonusHPDrainOnMonsterKill > Horizon::Zone::Traits::Status::bonus_hp_drain_on_monster_kill ( )

inline

1320{ return _bonus->_hp_drain_on_monster_kill; }

References _bonus.

◆ bonus_hp_drain_percent()

std::shared_ptr< Bonuses::BonusHPDrainPercent > Horizon::Zone::Traits::Status::bonus_hp_drain_percent ( )

inline

1488{ return _bonus->_hp_drain_percent; }

References _bonus.

◆ bonus_hp_drain_value()

std::shared_ptr< Bonuses::BonusHPDrainValue > Horizon::Zone::Traits::Status::bonus_hp_drain_value ( )

inline

1496{ return _bonus->_hp_drain_value; }

References _bonus.

◆ bonus_hp_gain_on_mob_kill()

std::shared_ptr< Bonuses::BonusHPGainOnMobKill > Horizon::Zone::Traits::Status::bonus_hp_gain_on_mob_kill ( )

inline

1168{ return _bonus->_hp_gain_on_mob_kill; }

References _bonus.

◆ bonus_hp_recovery_percent()

std::shared_ptr< Bonuses::BonusHPRecoveryPercent > Horizon::Zone::Traits::Status::bonus_hp_recovery_percent ( )

inline

888{ return _bonus->_hp_recovery_percent; }

References _bonus.

◆ bonus_hp_vanish_percent()

std::shared_ptr< Bonuses::BonusHPVanishPercent > Horizon::Zone::Traits::Status::bonus_hp_vanish_percent ( )

inline

1288{ return _bonus->_hp_vanish_percent; }

References _bonus.

◆ bonus_ignore_defense_from_element()

std::shared_ptr< Bonuses::BonusIgnoreDefenseFromElement > Horizon::Zone::Traits::Status::bonus_ignore_defense_from_element ( )

inline

1704{ return _bonus->_ignore_defense_from_element; }

References _bonus.

◆ bonus_ignore_defense_from_race()

std::shared_ptr< Bonuses::BonusIgnoreDefenseFromRace > Horizon::Zone::Traits::Status::bonus_ignore_defense_from_race ( )

inline

1712{ return _bonus->_ignore_defense_from_race; }

References _bonus.

◆ bonus_ignore_magic_defense_from_element()

std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromElement > Horizon::Zone::Traits::Status::bonus_ignore_magic_defense_from_element ( )

inline

1720{ return _bonus->_ignore_magic_defense_from_element; }

References _bonus.

◆ bonus_ignore_magic_defense_from_race()

std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromRace > Horizon::Zone::Traits::Status::bonus_ignore_magic_defense_from_race ( )

inline

1728{ return _bonus->_ignore_magic_defense_from_race; }

References _bonus.

◆ bonus_infinite_endure()

std::shared_ptr< Bonuses::BonusInfiniteEndure > Horizon::Zone::Traits::Status::bonus_infinite_endure ( )

inline

1120{ return _bonus->_infinite_endure; }

References _bonus.

◆ bonus_item_usage_immunity()

std::shared_ptr< Bonuses::BonusItemUsageImmunity > Horizon::Zone::Traits::Status::bonus_item_usage_immunity ( )

inline

1272{ return _bonus->_item_usage_immunity; }

References _bonus.

◆ bonus_job_percent_per_race()

std::shared_ptr< Bonuses::BonusJobPercentPerRace > Horizon::Zone::Traits::Status::bonus_job_percent_per_race ( )

inline

1608{ return _bonus->_job_percent_per_race; }

References _bonus.

◆ bonus_knock_back_immunity()

std::shared_ptr< Bonuses::BonusKnockBackImmunity > Horizon::Zone::Traits::Status::bonus_knock_back_immunity ( )

inline

1280{ return _bonus->_knockback_immunity; }

References _bonus.

◆ bonus_learned_skill_heal()

std::shared_ptr< Bonuses::BonusLearnedSkillHeal > Horizon::Zone::Traits::Status::bonus_learned_skill_heal ( )

inline

1640{ return _bonus->_learned_skill_heal; }

References _bonus.

◆ bonus_long_weapon_damage_percent()

std::shared_ptr< Bonuses::BonusLongWeaponDamagePercent > Horizon::Zone::Traits::Status::bonus_long_weapon_damage_percent ( )

inline

1264{ return _bonus->_long_weapon_damage_percent; }

References _bonus.

◆ bonus_magic_attack_percent()

std::shared_ptr< Bonuses::BonusMagicAttackPercent > Horizon::Zone::Traits::Status::bonus_magic_attack_percent ( )

inline

936{ return _bonus->_magic_attack_percent; }

References _bonus.

◆ bonus_magic_damage_immunity()

std::shared_ptr< Bonuses::BonusMagicDamageImmunity > Horizon::Zone::Traits::Status::bonus_magic_damage_immunity ( )

inline

1088{ return _bonus->_magic_damage_immunity; }

References _bonus.

◆ bonus_magic_damage_reduction_against_size()

std::shared_ptr< Bonuses::BonusMagicDamageReductionAgainstSize > Horizon::Zone::Traits::Status::bonus_magic_damage_reduction_against_size ( )

inline

1592{ return _bonus->_magic_damage_reduction_against_size; }

References _bonus.

◆ bonus_magic_damage_reflect_percent_on_self()

std::shared_ptr< Bonuses::BonusMagicDamageReflectPercentOnSelf > Horizon::Zone::Traits::Status::bonus_magic_damage_reflect_percent_on_self ( )

inline

1248{ return _bonus->_magic_damage_reflect_percent_on_self; }

References _bonus.

◆ bonus_magic_defense_percent()

std::shared_ptr< Bonuses::BonusMagicDefensePercent > Horizon::Zone::Traits::Status::bonus_magic_defense_percent ( )

inline

952{ return _bonus->_magic_defense_percent; }

References _bonus.

◆ bonus_max_hp_percent()

std::shared_ptr< Bonuses::BonusMaxHPPercent > Horizon::Zone::Traits::Status::bonus_max_hp_percent ( )

inline

832{ return _bonus->_max_hp_percent; }

References _bonus.

◆ bonus_max_sp_percent()

std::shared_ptr< Bonuses::BonusMaxSPPercent > Horizon::Zone::Traits::Status::bonus_max_sp_percent ( )

inline

840{ return _bonus->_max_sp_percent; }

References _bonus.

◆ bonus_melee_defense()

std::shared_ptr< Bonuses::BonusMeleeDefense > Horizon::Zone::Traits::Status::bonus_melee_defense ( )

inline

912{ return _bonus->_melee_defense; }

References _bonus.

◆ bonus_melee_weapon_damage_reflect_percent_on_self()

std::shared_ptr< Bonuses::BonusMeleeWeaponDamageReflectPercentOnSelf > Horizon::Zone::Traits::Status::bonus_melee_weapon_damage_reflect_percent_on_self ( )

inline

1184{ return _bonus->_melee_weapon_damage_reflect_percent_on_self; }

References _bonus.

◆ bonus_misc_defense_percent()

std::shared_ptr< Bonuses::BonusMiscDefensePercent > Horizon::Zone::Traits::Status::bonus_misc_defense_percent ( )

inline

960{ return _bonus->_misc_defense_percent; }

References _bonus.

◆ bonus_perfect_dodge_percent()

std::shared_ptr< Bonuses::BonusPerfectDodgePercent > Horizon::Zone::Traits::Status::bonus_perfect_dodge_percent ( )

inline

1024{ return _bonus->_perfect_dodge_percent; }

References _bonus.

◆ bonus_perfect_hit_percent()

std::shared_ptr< Bonuses::BonusPerfectHitPercent > Horizon::Zone::Traits::Status::bonus_perfect_hit_percent ( )

inline

968{ return _bonus->_perfect_hit_percent; }

References _bonus.

◆ bonus_raise()

std::shared_ptr< Bonuses::BonusRaise > Horizon::Zone::Traits::Status::bonus_raise ( )

inline

1304{ return _bonus->_raise; }

References _bonus.

◆ bonus_ranged_defense()

std::shared_ptr< Bonuses::BonusRangedDefense > Horizon::Zone::Traits::Status::bonus_ranged_defense ( )

inline

920{ return _bonus->_ranged_defense; }

References _bonus.

◆ bonus_ranged_weapon_damage_reflect_percent_on_self()

std::shared_ptr< Bonuses::BonusRangedWeaponDamageReflectPercentOnSelf > Horizon::Zone::Traits::Status::bonus_ranged_weapon_damage_reflect_percent_on_self ( )

inline

1192{ return _bonus->_ranged_weapon_damage_reflect_percent_on_self; }

References _bonus.

◆ bonus_reduce_sp_consumption_of_skill()

std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkill > Horizon::Zone::Traits::Status::bonus_reduce_sp_consumption_of_skill ( )

inline

1632{ return _bonus->_reduce_sp_consumption_of_skill; }

References _bonus.

◆ bonus_reduce_sp_consumption_of_skill_by_percent()

std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkillByPercent > Horizon::Zone::Traits::Status::bonus_reduce_sp_consumption_of_skill_by_percent ( )

inline

1624{ return _bonus->_reduce_sp_consumption_of_skill_by_percent; }

References _bonus.

◆ bonus_resist_magic_attack_from_race()

std::shared_ptr< Bonuses::BonusResistMagicAttackFromRace > Horizon::Zone::Traits::Status::bonus_resist_magic_attack_from_race ( )

inline

1448{ return _bonus->_resist_magic_attack_from_race; }

References _bonus.

◆ bonus_resist_skill_damage_percent()

std::shared_ptr< Bonuses::BonusResistSkillDamagePercent > Horizon::Zone::Traits::Status::bonus_resist_skill_damage_percent ( )

inline

1696{ return _bonus->_resist_skill_damage_percent; }

References _bonus.

◆ bonus_ressist_effect()

std::shared_ptr< Bonuses::BonusRessistEffect > Horizon::Zone::Traits::Status::bonus_ressist_effect ( )

inline

1408{ return _bonus->_ressist_effect; }

References _bonus.

◆ bonus_restart_with_full_recovery()

std::shared_ptr< Bonuses::BonusRestartWithFullRecovery > Horizon::Zone::Traits::Status::bonus_restart_with_full_recovery ( )

inline

1064{ return _bonus->_restart_with_full_recovery; }

References _bonus.

◆ bonus_short_weapon_damage_percent()

std::shared_ptr< Bonuses::BonusShortWeaponDamagePercent > Horizon::Zone::Traits::Status::bonus_short_weapon_damage_percent ( )

inline

1256{ return _bonus->_short_weapon_damage_percent; }

References _bonus.

◆ bonus_size_modifier_immunity()

std::shared_ptr< Bonuses::BonusSizeModifierImmunity > Horizon::Zone::Traits::Status::bonus_size_modifier_immunity ( )

inline

1080{ return _bonus->_size_modifier_immunity; }

References _bonus.

◆ bonus_skill_attack()

std::shared_ptr< Bonuses::BonusSkillAttack > Horizon::Zone::Traits::Status::bonus_skill_attack ( )

inline

1616{ return _bonus->_skill_attack; }

References _bonus.

◆ bonus_skill_cast_percent()

std::shared_ptr< Bonuses::BonusSkillCastPercent > Horizon::Zone::Traits::Status::bonus_skill_cast_percent ( )

inline

1664{ return _bonus->_skill_cast_percent; }

References _bonus.

◆ bonus_skill_cooldown()

std::shared_ptr< Bonuses::BonusSkillCooldown > Horizon::Zone::Traits::Status::bonus_skill_cooldown ( )

inline

1672{ return _bonus->_skill_cooldown; }

References _bonus.

◆ bonus_skill_fix_cast_percent()

std::shared_ptr< Bonuses::BonusSkillFixCastPercent > Horizon::Zone::Traits::Status::bonus_skill_fix_cast_percent ( )

inline

1680{ return _bonus->_skill_fix_cast_percent; }

References _bonus.

◆ bonus_skill_knockback()

std::shared_ptr< Bonuses::BonusSkillKnockback > Horizon::Zone::Traits::Status::bonus_skill_knockback ( )

inline

1656{ return _bonus->_skill_knockback; }

References _bonus.

◆ bonus_skill_variable_cast_percent()

std::shared_ptr< Bonuses::BonusSkillVariableCastPercent > Horizon::Zone::Traits::Status::bonus_skill_variable_cast_percent ( )

inline

1688{ return _bonus->_skill_variable_cast_percent; }

References _bonus.

◆ bonus_soft_defense_percent()

std::shared_ptr< Bonuses::BonusSoftDefensePercent > Horizon::Zone::Traits::Status::bonus_soft_defense_percent ( )

inline

1032{ return _bonus->_soft_defense_percent; }

References _bonus.

◆ bonus_soft_magical_defense_percent()

std::shared_ptr< Bonuses::BonusSoftMagicalDefensePercent > Horizon::Zone::Traits::Status::bonus_soft_magical_defense_percent ( )

inline

1048{ return _bonus->_soft_magical_defense_percent; }

References _bonus.

◆ bonus_sp_drain_on_monster_kill()

std::shared_ptr< Bonuses::BonusSPDrainOnMonsterKill > Horizon::Zone::Traits::Status::bonus_sp_drain_on_monster_kill ( )

inline

1328{ return _bonus->_sp_drain_on_monster_kill; }

References _bonus.

◆ bonus_sp_drain_percent()

std::shared_ptr< Bonuses::BonusSPDrainPercent > Horizon::Zone::Traits::Status::bonus_sp_drain_percent ( )

inline

1504{ return _bonus->_sp_drain_percent; }

References _bonus.

◆ bonus_sp_drain_value()

std::shared_ptr< Bonuses::BonusSPDrainValue > Horizon::Zone::Traits::Status::bonus_sp_drain_value ( )

inline

1512{ return _bonus->_bonus_sp_drain_value; }

References _bonus.

◆ bonus_sp_gain_on_mob_kill()

std::shared_ptr< Bonuses::BonusSPGainOnMobKill > Horizon::Zone::Traits::Status::bonus_sp_gain_on_mob_kill ( )

inline

1160{ return _bonus->_sp_gain_on_mob_kill; }

References _bonus.

◆ bonus_sp_percent()

std::shared_ptr< Bonuses::BonusSPPercent > Horizon::Zone::Traits::Status::bonus_sp_percent ( )

inline

848{ return _bonus->_sp_percent; }

References _bonus.

◆ bonus_sp_recovery_percent()

std::shared_ptr< Bonuses::BonusSPRecoveryPercent > Horizon::Zone::Traits::Status::bonus_sp_recovery_percent ( )

inline

896{ return _bonus->_sp_recovery_percent; }

References _bonus.

◆ bonus_sp_vanish_percent()

std::shared_ptr< Bonuses::BonusSPVanishPercent > Horizon::Zone::Traits::Status::bonus_sp_vanish_percent ( )

inline

1296{ return _bonus->_sp_vanish_percent; }

References _bonus.

◆ bonus_sub_attack_percentage_from_element()

std::shared_ptr< Bonuses::BonusSubAttackPercentageFromElement > Horizon::Zone::Traits::Status::bonus_sub_attack_percentage_from_element ( )

inline

1376{ return _bonus->_sub_attack_percentage_from_element; }

References _bonus.

◆ bonus_sub_attack_percentage_from_race()

std::shared_ptr< Bonuses::BonusSubAttackPercentageFromRace > Horizon::Zone::Traits::Status::bonus_sub_attack_percentage_from_race ( )

inline

1384{ return _bonus->_sub_attack_percentage_from_race; }

References _bonus.

◆ bonus_unbreakable_armor()

std::shared_ptr< Bonuses::BonusUnbreakableArmor > Horizon::Zone::Traits::Status::bonus_unbreakable_armor ( )

inline

1136{ return _bonus->_unbreakable_armor; }

References _bonus.

◆ bonus_unbreakable_helm()

std::shared_ptr< Bonuses::BonusUnbreakableHelm > Horizon::Zone::Traits::Status::bonus_unbreakable_helm ( )

inline

1144{ return _bonus->_unbreakable_helm; }

References _bonus.

◆ bonus_unbreakable_shield()

std::shared_ptr< Bonuses::BonusUnbreakableShield > Horizon::Zone::Traits::Status::bonus_unbreakable_shield ( )

inline

1152{ return _bonus->_unbreakable_shield; }

References _bonus.

◆ bonus_unbreakable_weapon()

std::shared_ptr< Bonuses::BonusUnbreakableWeapon > Horizon::Zone::Traits::Status::bonus_unbreakable_weapon ( )

inline

1128{ return _bonus->_unbreakable_weapon; }

References _bonus.

◆ bonus_weapon_break_percent()

std::shared_ptr< Bonuses::BonusWeaponBreakPercent > Horizon::Zone::Traits::Status::bonus_weapon_break_percent ( )

inline

1200{ return _bonus->_weapon_break_percent; }

References _bonus.

◆ bonus_weapon_damage_immunity()

std::shared_ptr< Bonuses::BonusWeaponDamageImmunity > Horizon::Zone::Traits::Status::bonus_weapon_damage_immunity ( )

inline

1096{ return _bonus->_weapon_damage_immunity; }

References _bonus.

◆ calculate()

void Status::calculate ( bool notify = true )

{
    // calculate before initialize is set.
    for (auto i : _attributes) {
        i->apply(notify);
    }
}

References _attributes.

Referenced by initialize().

Here is the caller graph for this function:

◆ cloth_color()

std::shared_ptr< ClothColor > Horizon::Zone::Traits::Status::cloth_color ( )

inline

536{ return _cloth_color; }

Horizon::Zone::Traits::Status::_cloth_color

std::shared_ptr< ClothColor > _cloth_color

Definition: Status.hpp:1839

References _cloth_color.

Referenced by save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ creature_attack_damage()

std::shared_ptr< MobAttackDamage > Horizon::Zone::Traits::Status::creature_attack_damage ( )

inline

671{ return _creature_attack_damage; }

Horizon::Zone::Traits::Status::_creature_attack_damage

std::shared_ptr< MobAttackDamage > _creature_attack_damage

Definition: Status.hpp:1864

References _creature_attack_damage.

Referenced by initialize().

Here is the caller graph for this function:

◆ creature_chase_range()

std::shared_ptr< MobChaseRange > Horizon::Zone::Traits::Status::creature_chase_range ( )

inline

695{ return _creature_chase_range; }

Horizon::Zone::Traits::Status::_creature_chase_range

std::shared_ptr< MobChaseRange > _creature_chase_range

Definition: Status.hpp:1867

References _creature_chase_range.

◆ creature_element()

std::shared_ptr< MobElement > Horizon::Zone::Traits::Status::creature_element ( )

inline

719{ return _creature_element; }

Horizon::Zone::Traits::Status::_creature_element

std::shared_ptr< MobElement > _creature_element

Definition: Status.hpp:1870

References _creature_element.

◆ creature_element_level()

std::shared_ptr< MobElementLevel > Horizon::Zone::Traits::Status::creature_element_level ( )

inline

727{ return _creature_element_level; }

Horizon::Zone::Traits::Status::_creature_element_level

std::shared_ptr< MobElementLevel > _creature_element_level

Definition: Status.hpp:1871

References _creature_element_level.

◆ creature_magic_attack_damage()

std::shared_ptr< MobMagicAttackDamage > Horizon::Zone::Traits::Status::creature_magic_attack_damage ( )

inline

679{ return _creature_magic_attack_damage; }

Horizon::Zone::Traits::Status::_creature_magic_attack_damage

std::shared_ptr< MobMagicAttackDamage > _creature_magic_attack_damage

Definition: Status.hpp:1865

References _creature_magic_attack_damage.

Referenced by initialize().

Here is the caller graph for this function:

◆ creature_mode()

std::shared_ptr< MobMode > Horizon::Zone::Traits::Status::creature_mode ( )

inline

735{ return _creature_mode; }

Horizon::Zone::Traits::Status::_creature_mode

std::shared_ptr< MobMode > _creature_mode

Definition: Status.hpp:1872

References _creature_mode.

◆ creature_primary_race()

std::shared_ptr< MobPrimaryRace > Horizon::Zone::Traits::Status::creature_primary_race ( )

inline

703{ return _creature_primary_race; }

Horizon::Zone::Traits::Status::_creature_primary_race

std::shared_ptr< MobPrimaryRace > _creature_primary_race

Definition: Status.hpp:1868

References _creature_primary_race.

◆ creature_secondary_race()

std::shared_ptr< MobSecondaryRace > Horizon::Zone::Traits::Status::creature_secondary_race ( )

inline

711{ return _creature_secondary_race; }

Horizon::Zone::Traits::Status::_creature_secondary_race

std::shared_ptr< MobSecondaryRace > _creature_secondary_race

Definition: Status.hpp:1869

References _creature_secondary_race.

◆ creature_view_range()

std::shared_ptr< MobViewRange > Horizon::Zone::Traits::Status::creature_view_range ( )

inline

687{ return _creature_view_range; }

Horizon::Zone::Traits::Status::_creature_view_range

std::shared_ptr< MobViewRange > _creature_view_range

Definition: Status.hpp:1866

References _creature_view_range.

◆ creature_weapon_attack()

std::shared_ptr< MobWeaponAttack > Horizon::Zone::Traits::Status::creature_weapon_attack ( )

inline

655{ return _creature_weapon_attack; }

Horizon::Zone::Traits::Status::_creature_weapon_attack

std::shared_ptr< MobWeaponAttack > _creature_weapon_attack

Definition: Status.hpp:1862

References _creature_weapon_attack.

◆ creature_weapon_attack_magic()

std::shared_ptr< MobWeaponAttack > Horizon::Zone::Traits::Status::creature_weapon_attack_magic ( )

inline

663{ return _creature_weapon_attack_magic; }

Horizon::Zone::Traits::Status::_creature_weapon_attack_magic

std::shared_ptr< MobWeaponAttack > _creature_weapon_attack_magic

Definition: Status.hpp:1863

References _creature_weapon_attack_magic.

Referenced by initialize().

Here is the caller graph for this function:

◆ crit()

std::shared_ptr< CRIT > Horizon::Zone::Traits::Status::crit ( )

inline

487{ return _crit; }

Horizon::Zone::Traits::Status::_crit

std::shared_ptr< CRIT > _crit

Definition: Status.hpp:1831

References _crit.

Referenced by initialize(), and set_crit().

Here is the caller graph for this function:

◆ current_hp()

std::shared_ptr< CurrentHP > Horizon::Zone::Traits::Status::current_hp ( )

inline

316{ return _current_hp; }

Horizon::Zone::Traits::Status::_current_hp

std::shared_ptr< CurrentHP > _current_hp

Definition: Status.hpp:1809

References _current_hp.

Referenced by initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ current_sp()

std::shared_ptr< CurrentSP > Horizon::Zone::Traits::Status::current_sp ( )

inline

324{ return _current_sp; }

Horizon::Zone::Traits::Status::_current_sp

std::shared_ptr< CurrentSP > _current_sp

Definition: Status.hpp:1810

References _current_sp.

Referenced by initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ current_weight()

std::shared_ptr< CurrentWeight > Horizon::Zone::Traits::Status::current_weight ( )

inline

396{ return _current_weight; }

Horizon::Zone::Traits::Status::_current_weight

std::shared_ptr< CurrentWeight > _current_weight

Definition: Status.hpp:1819

References _current_weight.

Referenced by Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ damage_walk_delay()

std::shared_ptr< DamageWalkDelay > Horizon::Zone::Traits::Status::damage_walk_delay ( )

inline

606{ return _damage_walk_delay; }

Horizon::Zone::Traits::Status::_damage_walk_delay

std::shared_ptr< DamageWalkDelay > _damage_walk_delay

Definition: Status.hpp:1855

References _damage_walk_delay.

Referenced by initialize().

Here is the caller graph for this function:

◆ dexterity()

std::shared_ptr< Dexterity > Horizon::Zone::Traits::Status::dexterity ( )

inline

212{ return _dex; }

Horizon::Zone::Traits::Status::_dex

std::shared_ptr< Dexterity > _dex

Definition: Status.hpp:1797

References _dex.

Referenced by get_status_base(), increase_status_point(), initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ dexterity_cost()

std::shared_ptr< DexterityPointCost > Horizon::Zone::Traits::Status::dexterity_cost ( )

inline

260{ return _dex_cost; }

Horizon::Zone::Traits::Status::_dex_cost

std::shared_ptr< DexterityPointCost > _dex_cost

Definition: Status.hpp:1803

References _dex_cost.

Referenced by increase_status_point(), and initialize().

Here is the caller graph for this function:

◆ equip_atk()

std::shared_ptr< EquipATK > Horizon::Zone::Traits::Status::equip_atk ( )

inline

423{ return _equip_atk; }

Horizon::Zone::Traits::Status::_equip_atk

std::shared_ptr< EquipATK > _equip_atk

Definition: Status.hpp:1823

References _equip_atk.

Referenced by initialize(), and on_equipment_changed().

Here is the caller graph for this function:

◆ equip_matk()

std::shared_ptr< EquipMATK > Horizon::Zone::Traits::Status::equip_matk ( )

inline

439{ return _equip_matk; }

Horizon::Zone::Traits::Status::_equip_matk

std::shared_ptr< EquipMATK > _equip_matk

Definition: Status.hpp:1825

References _equip_matk.

Referenced by on_equipment_changed().

Here is the caller graph for this function:

◆ flee()

std::shared_ptr< FLEE > Horizon::Zone::Traits::Status::flee ( )

inline

495{ return _flee; }

Horizon::Zone::Traits::Status::_flee

std::shared_ptr< FLEE > _flee

Definition: Status.hpp:1832

References _flee.

Referenced by initialize(), and set_flee().

Here is the caller graph for this function:

◆ get_appearance()

std::shared_ptr< Appearance > Horizon::Zone::Traits::Status::get_appearance ( unit_appearance_type type )

inline

    {
        for (auto &appearance : _appearances)
        {
            if (appearance->get_type() == type)
                return appearance;
        }
 
        return nullptr;
    }

References _appearances.

◆ get_attribute()

std::shared_ptr< Attribute > Horizon::Zone::Traits::Status::get_attribute ( status_point_type type )

inline

    {
        for (auto &attribute : _attributes)
        {
            if (attribute->get_type() == type)
                return attribute;
        }
 
        return nullptr;
    }

References _attributes.

◆ get_bonus()

std::shared_ptr< Bonuses::Bonus > Horizon::Zone::Traits::Status::get_bonus ( status_point_type type )

inline

    {
        for (auto &bonus : _bonuses)
        {
            if (bonus->get_type() == type)
                return bonus;
        }
 
        return nullptr;
    }

References _bonuses.

◆ get_bonus_array()

std::shared_ptr< Bonuses::IBonusArray > Horizon::Zone::Traits::Status::get_bonus_array ( status_point_type type )

inline

    {
        for (auto &ba : _bonus_arrays)
        {
            if (ba->get_type() == type)
                return ba;
        }
 
        return nullptr;
    }

References _bonus_arrays.

◆ get_required_statpoints()

uint32_t Status::get_required_statpoints	(	uint16_t	from,
		uint16_t	to
	)

{
    uint32_t sp = 0;
 
    for (; from < to; from++)
        sp += (from < 100) ? (2 + (from - 1) / 10) : (16 + 4 * ((from - 100) / 5));
 
    return sp;
}

Referenced by increase_status_point(), and load().

Here is the caller graph for this function:

◆ get_status_base()

uint32_t Status::get_status_base ( status_point_type type )

{
    uint32_t value = 0;
    switch (type)
    {
        case STATUS_STRENGTH: value = strength()->get_base(); break;
        case STATUS_AGILITY: value = agility()->get_base(); break;
        case STATUS_VITALITY: value = vitality()->get_base(); break;
        case STATUS_INTELLIGENCE: value = intelligence()->get_base(); break;
        case STATUS_DEXTERITY: value = dexterity()->get_base(); break;
        case STATUS_LUCK: value = luck()->get_base(); break;
        default: return 0;
    }
 
    return value;
}

References agility(), dexterity(), intelligence(), luck(), STATUS_AGILITY, STATUS_DEXTERITY, STATUS_INTELLIGENCE, STATUS_LUCK, STATUS_STRENGTH, STATUS_VITALITY, strength(), and vitality().

Referenced by increase_status_point().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hair_color()

std::shared_ptr< HairColor > Horizon::Zone::Traits::Status::hair_color ( )

inline

533{ return _hair_color; }

Horizon::Zone::Traits::Status::_hair_color

std::shared_ptr< HairColor > _hair_color

Definition: Status.hpp:1838

References _hair_color.

Referenced by save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ hair_style()

std::shared_ptr< HairStyle > Horizon::Zone::Traits::Status::hair_style ( )

inline

557{ return _hair_style; }

Horizon::Zone::Traits::Status::_hair_style

std::shared_ptr< HairStyle > _hair_style

Definition: Status.hpp:1846

References _hair_style.

Referenced by save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ hard_def()

std::shared_ptr< HardDEF > Horizon::Zone::Traits::Status::hard_def ( )

inline

455{ return _hard_def; }

Horizon::Zone::Traits::Status::_hard_def

std::shared_ptr< HardDEF > _hard_def

Definition: Status.hpp:1827

References _hard_def.

◆ hard_mdef()

std::shared_ptr< HardMDEF > Horizon::Zone::Traits::Status::hard_mdef ( )

inline

471{ return _hard_mdef; }

Horizon::Zone::Traits::Status::_hard_mdef

std::shared_ptr< HardMDEF > _hard_mdef

Definition: Status.hpp:1829

References _hard_mdef.

◆ head_bottom_sprite()

std::shared_ptr< HeadBottomSprite > Horizon::Zone::Traits::Status::head_bottom_sprite ( )

inline

554{ return _head_bottom_sprite; }

Horizon::Zone::Traits::Status::_head_bottom_sprite

std::shared_ptr< HeadBottomSprite > _head_bottom_sprite

Definition: Status.hpp:1845

References _head_bottom_sprite.

Referenced by on_equipment_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ head_mid_sprite()

std::shared_ptr< HeadMidSprite > Horizon::Zone::Traits::Status::head_mid_sprite ( )

inline

551{ return _head_mid_sprite; }

Horizon::Zone::Traits::Status::_head_mid_sprite

std::shared_ptr< HeadMidSprite > _head_mid_sprite

Definition: Status.hpp:1844

References _head_mid_sprite.

Referenced by on_equipment_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ head_top_sprite()

std::shared_ptr< HeadTopSprite > Horizon::Zone::Traits::Status::head_top_sprite ( )

inline

548{ return _head_top_sprite; }

Horizon::Zone::Traits::Status::_head_top_sprite

std::shared_ptr< HeadTopSprite > _head_top_sprite

Definition: Status.hpp:1843

References _head_top_sprite.

Referenced by on_equipment_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ hit()

std::shared_ptr< HIT > Horizon::Zone::Traits::Status::hit ( )

inline

479{ return _hit; }

Horizon::Zone::Traits::Status::_hit

std::shared_ptr< HIT > _hit

Definition: Status.hpp:1830

References _hit.

Referenced by initialize(), and set_hit().

Here is the caller graph for this function:

◆ honor()

std::shared_ptr< Honor > Horizon::Zone::Traits::Status::honor ( )

inline

571{ return _honor; }

Horizon::Zone::Traits::Status::_honor

std::shared_ptr< Honor > _honor

Definition: Status.hpp:1850

References _honor.

Referenced by save().

Here is the caller graph for this function:

◆ hp_regeneration()

std::shared_ptr< HPRegeneration > Horizon::Zone::Traits::Status::hp_regeneration ( )

inline

511{ return _hp_regeneration; }

Horizon::Zone::Traits::Status::_hp_regeneration

std::shared_ptr< HPRegeneration > _hp_regeneration

Definition: Status.hpp:1834

References _hp_regeneration.

Referenced by initialize().

Here is the caller graph for this function:

◆ increase_status_point()

bool Status::increase_status_point	(	status_point_type	type,
		uint16_t	limit
	)

Increases a status point to a certain limit and returns the current total of the stat.

Parameters

type[in] Type of the status point

See also: status_point_type

Parameters

limit[in] Limit to increase the status point to.

Returns: The total base value of the current status point.

{
    uint32_t value = 0;
 
    if (limit <= 0 || limit > MAX_STATUS_POINTS)
        return false;
 
    if (_unit.expired())
        return false;
 
    uint32_t available_points = status_point()->get_base();
    uint32_t required_points = 0;
 
    limit += get_status_base(type);
 
#define notify_status(t, amount, result) \
        unit()->template downcast<Horizon::Zone::Units::Player>()->get_session()->clif()->notify_status_attribute_update(t, amount, result)
    while (limit > get_status_base(type)) {
        value = get_status_base(type);
        required_points = get_required_statpoints(value + 1, value + 2);
 
        if (required_points > available_points || value >= MAX_STATUS_POINTS)
            break;
 
        available_points -= required_points;
        switch (type)
        {
            case STATUS_STRENGTH:
                strength()->add_base(1);
                strength_cost()->set_base(required_points);
                break;
            case STATUS_AGILITY:
                agility()->add_base(1);
                agility_cost()->set_base(required_points);
                break;
            case STATUS_VITALITY:
                vitality()->add_base(1);
                vitality_cost()->set_base(required_points);
                break;
            case STATUS_INTELLIGENCE:
                intelligence()->add_base(1);
                intelligence_cost()->set_base(required_points);
                break;
            case STATUS_DEXTERITY:
                dexterity()->add_base(1);
                dexterity_cost()->set_base(required_points);
                break;
            case STATUS_LUCK:
                luck()->add_base(1);
                luck_cost()->set_base(required_points);
                break;
            default:
                notify_status(type, get_status_base(type), false);
                return false;
        }
 
        notify_status(type, get_status_base(type), true);
        status_point()->set_base(available_points);
    }
#undef notify_status
    return true;
}

References _unit, agility(), agility_cost(), dexterity(), dexterity_cost(), get_required_statpoints(), get_status_base(), intelligence(), intelligence_cost(), luck(), luck_cost(), MAX_STATUS_POINTS, notify_status, STATUS_AGILITY, STATUS_DEXTERITY, STATUS_INTELLIGENCE, STATUS_LUCK, status_point(), STATUS_STRENGTH, STATUS_VITALITY, strength(), strength_cost(), vitality(), and vitality_cost().

Here is the call graph for this function:

◆ initialize() [1/3]

bool Status::initialize	(	std::shared_ptr< Horizon::Zone::Units::Mob >	creature,
		std::shared_ptr< const monster_config_data >	md
	)

{
    set_movement_speed(std::make_shared<MovementSpeed>(_unit, md->move_speed));
 
    set_base_level(std::make_shared<BaseLevel>(_unit, md->level));
 
    set_current_hp(std::make_shared<CurrentHP>(_unit, md->hp));
    set_current_sp(std::make_shared<CurrentSP>(_unit, md->sp));
    set_max_hp(std::make_shared<MaxHP>(_unit, md->hp));
    set_max_sp(std::make_shared<MaxSP>(_unit, md->sp));
    set_size(std::make_shared<UnitSize>(_unit, (int) md->size));
    set_base_appearance(std::make_shared<BaseAppearance>(_unit, md->monster_id));
    set_hair_color(std::make_shared<HairColor>(_unit, md->view.hair_color_id));
    set_cloth_color(std::make_shared<ClothColor>(_unit, md->view.body_color_id));
    set_head_top_sprite(std::make_shared<HeadTopSprite>(_unit, md->view.headgear_top_id));
    set_head_mid_sprite(std::make_shared<HeadMidSprite>(_unit, md->view.headgear_middle_id));
    set_head_bottom_sprite(std::make_shared<HeadBottomSprite>(_unit, md->view.headgear_bottom_id));
    set_hair_style(std::make_shared<HairStyle>(_unit, md->view.hair_style_id));
    set_shield_sprite(std::make_shared<ShieldSprite>(_unit, md->view.shield_id));
    set_weapon_sprite(std::make_shared<WeaponSprite>(_unit, md->view.weapon_id));
    set_robe_sprite(std::make_shared<RobeSprite>(_unit, md->view.robe_id));
    set_body_style(std::make_shared<BodyStyle>(_unit, md->view.body_style_id));
 
    set_strength(std::make_shared<Strength>(_unit, md->stats.str));
    set_agility(std::make_shared<Agility>(_unit, md->stats.agi, 0, 0));
    set_vitality(std::make_shared<Vitality>(_unit, md->stats.vit, 0, 0));
    set_intelligence(std::make_shared<Intelligence>(_unit, md->stats.int_, 0, 0));
    set_dexterity(std::make_shared<Dexterity>(_unit, md->stats.dex, 0, 0));
    set_luck(std::make_shared<Luck>(_unit, md->stats.luk, 0, 0));
 
    set_soft_def(std::make_shared<SoftDEF>(_unit));
    soft_def()->set_vitality(vitality().get());
    soft_def()->set_base_level(base_level().get());
    // Agility not used for monsters.
 
    set_hard_def(std::make_shared<HardDEF>(_unit, md->defense));
 
    set_soft_mdef(std::make_shared<SoftMDEF>(_unit));
    soft_mdef()->set_base_level(base_level().get());
    soft_mdef()->set_intelligence(intelligence().get());
    soft_mdef()->set_dexterity(dexterity().get());
    soft_mdef()->set_vitality(vitality().get());
 
    set_hit(std::make_shared<HIT>(_unit));
    hit()->set_base_level(base_level().get());
    hit()->set_dexterity(dexterity().get());
    hit()->set_luck(luck().get());
 
    set_crit(std::make_shared<CRIT>(_unit));
    crit()->set_luck(luck().get());
 
    set_flee(std::make_shared<FLEE>(_unit));
    flee()->set_base_level(base_level().get());
    flee()->set_agility(agility().get());
    flee()->set_luck(luck().get());
 
    set_attack_range(std::make_shared<AttackRange>(_unit));
 
    set_attack_delay(std::make_shared<AttackDelay>(_unit));
 
    set_damage_walk_delay(std::make_shared<DamageWalkDelay>(_unit));
 
    set_attack_range(std::make_shared<AttackRange>(_unit));
 
    set_creature_weapon_attack(std::make_shared<MobWeaponAttack>(_unit, md->attack_damage[0]));
    set_creature_weapon_attack_magic(std::make_shared<MobWeaponAttack>(_unit, md->attack_damage[1]));
    
    set_creature_attack_damage(std::make_shared<MobAttackDamage>(_unit));
    creature_attack_damage()->set_strength(strength().get());
    creature_attack_damage()->set_base_level(base_level().get());
    creature_attack_damage()->set_creature_weapon_attack(creature_weapon_attack_magic().get());
 
    set_creature_magic_attack_damage(std::make_shared<MobMagicAttackDamage>(_unit));
    creature_magic_attack_damage()->set_intelligence(intelligence().get());
    creature_magic_attack_damage()->set_base_level(base_level().get());
    creature_magic_attack_damage()->set_creature_weapon_attack(creature_weapon_attack_magic().get());
 
    set_creature_view_range(std::make_shared<MobViewRange>(_unit, (int) md->view_range));
    set_creature_chase_range(std::make_shared<MobChaseRange>(_unit, (int) md->chase_range));
    set_creature_primary_race(std::make_shared<MobPrimaryRace>(_unit, (int) md->primary_race));
    set_creature_secondary_race(std::make_shared<MobSecondaryRace>(_unit, (int) md->secondary_race));
    set_creature_element(std::make_shared<MobElement>(_unit, (int) md->element));
    set_creature_element_level(std::make_shared<MobElementLevel>(_unit, (int) md->element_level));
    set_creature_mode(std::make_shared<MobMode>(_unit, (int) md->mode));
 
    calculate(false);
 
    set_initialized(true);
    return true;
}

References _unit, agility(), base_level(), calculate(), creature_attack_damage(), creature_magic_attack_damage(), creature_weapon_attack_magic(), crit(), dexterity(), flee(), hit(), intelligence(), luck(), set_agility(), set_attack_delay(), set_attack_range(), set_base_appearance(), set_base_level(), set_body_style(), set_cloth_color(), set_creature_attack_damage(), set_creature_chase_range(), set_creature_element(), set_creature_element_level(), set_creature_magic_attack_damage(), set_creature_mode(), set_creature_primary_race(), set_creature_secondary_race(), set_creature_view_range(), set_creature_weapon_attack(), set_creature_weapon_attack_magic(), set_crit(), set_current_hp(), set_current_sp(), set_damage_walk_delay(), set_dexterity(), set_flee(), set_hair_color(), set_hair_style(), set_hard_def(), set_head_bottom_sprite(), set_head_mid_sprite(), set_head_top_sprite(), set_hit(), set_initialized(), set_intelligence(), set_luck(), set_max_hp(), set_max_sp(), set_movement_speed(), set_robe_sprite(), set_shield_sprite(), set_size(), set_soft_def(), set_soft_mdef(), set_strength(), set_vitality(), set_weapon_sprite(), soft_def(), soft_mdef(), strength(), and vitality().

◆ initialize() [2/3]

bool Status::initialize ( std::shared_ptr< Horizon::Zone::Units::NPC > npc )

{
    set_movement_speed(std::make_shared<MovementSpeed>(_unit, 100));
    set_base_level(std::make_shared<BaseLevel>(_unit, 1));
 
    set_current_hp(std::make_shared<CurrentHP>(_unit, 1));
    set_current_sp(std::make_shared<CurrentSP>(_unit, 1));
    set_max_hp(std::make_shared<MaxHP>(_unit, 1));
    set_max_sp(std::make_shared<MaxSP>(_unit, 1));
    set_hair_style(std::make_shared<HairStyle>(_unit, 0));
    set_hair_color(std::make_shared<HairColor>(_unit, 0));
    set_robe_sprite(std::make_shared<RobeSprite>(_unit, 0));
    set_base_appearance(std::make_shared<BaseAppearance>(_unit, npc->job_id()));
 
    calculate(false);
    
    set_initialized(true);
    return true;
}

References _unit, calculate(), set_base_appearance(), set_base_level(), set_current_hp(), set_current_sp(), set_hair_color(), set_hair_style(), set_initialized(), set_max_hp(), set_max_sp(), set_movement_speed(), and set_robe_sprite().

Here is the call graph for this function:

◆ initialize() [3/3]

bool Status::initialize ( std::shared_ptr< Horizon::Zone::Units::Player > player )

{
    load(player);
 
    std::shared_ptr<const job_config_data> job = player->job();
 
    if (job == nullptr) {
        HLog(error) << "Status::initialize_compound_attributes: Job was null.";
        return false;
    }
 
    set_attack_range(std::make_shared<AttackRange>(_unit));
 
    set_max_weight(std::make_shared<MaxWeight>(_unit, job->max_weight));
    max_weight()->set_strength(strength().get());
 
    // Calculated when inventory is synced.
    set_current_weight(std::make_shared<CurrentWeight>(_unit, 0));
 
    set_status_atk(std::make_shared<StatusATK>(_unit));
    status_atk()->set_base_level(base_level().get());
    status_atk()->set_strength(strength().get());
    status_atk()->set_dexterity(dexterity().get());
    status_atk()->set_luck(luck().get());
 
    set_equip_atk(std::make_shared<EquipATK>(_unit));
    equip_atk()->set_strength(strength().get());
    equip_atk()->set_dexterity(dexterity().get());
 
    set_status_matk(std::make_shared<StatusMATK>(_unit));
    status_matk()->set_base_level(base_level().get());
    status_matk()->set_intelligence(intelligence().get());
    status_matk()->set_dexterity(dexterity().get());
    status_matk()->set_luck(luck().get());
 
    set_equip_matk(std::make_shared<EquipMATK>(_unit));
    set_soft_def(std::make_shared<SoftDEF>(_unit));
    soft_def()->set_vitality(vitality().get());
    soft_def()->set_base_level(base_level().get());
    soft_def()->set_agility(agility().get());
 
    set_hard_def(std::make_shared<HardDEF>(_unit));
 
    set_soft_mdef(std::make_shared<SoftMDEF>(_unit));
    soft_mdef()->set_base_level(base_level().get());
    soft_mdef()->set_intelligence(intelligence().get());
    soft_mdef()->set_dexterity(dexterity().get());
    soft_mdef()->set_vitality(vitality().get());
 
    set_hit(std::make_shared<HIT>(_unit));
    hit()->set_base_level(base_level().get());
    hit()->set_dexterity(dexterity().get());
    hit()->set_luck(luck().get());
 
    set_crit(std::make_shared<CRIT>(_unit));
    crit()->set_luck(luck().get());
 
    set_flee(std::make_shared<FLEE>(_unit));
    flee()->set_base_level(base_level().get());
    flee()->set_agility(agility().get());
    flee()->set_luck(luck().get());
 
    set_attack_speed(std::make_shared<AttackSpeed>(_unit));
    attack_speed()->set_base_level(base_level().get());
    attack_speed()->set_agility(agility().get());
    attack_speed()->set_dexterity(dexterity().get());
 
    set_hp_regeneration(std::make_shared<HPRegeneration>(_unit));
    hp_regeneration()->set_vitality(vitality().get());
    hp_regeneration()->set_max_hp(max_hp().get());
 
    set_sp_regeneration(std::make_shared<SPRegeneration>(_unit));
    sp_regeneration()->set_intelligence(intelligence().get());
    sp_regeneration()->set_max_sp(max_sp().get());
 
    // Register Status Observables
    strength()->register_observable(strength().get());
    agility()->register_observable(agility().get());
    vitality()->register_observable(vitality().get());
    intelligence()->register_observable(intelligence().get());
    dexterity()->register_observable(dexterity().get());
    luck()->register_observable(luck().get());
    base_experience()->register_observable(base_experience().get());
    job_experience()->register_observable(job_experience().get());
    base_level()->register_observable(base_level().get());
    job_level()->register_observable(job_level().get());
    max_hp()->register_observable(max_hp().get());
    max_sp()->register_observable(max_sp().get());
    attack_speed()->register_observable(attack_speed().get());
 
    set_base_attack(std::make_shared<BaseAttack>(_unit));
 
    // Register Status Observers
    strength()->register_observers(
        strength_cost().get(),
        max_weight().get(),
        status_atk().get(),
        equip_atk().get(),
        base_attack().get());
 
    agility()->register_observers(
        agility_cost().get(),
        flee().get(),
        attack_speed().get(),
        soft_def().get());
 
    vitality()->register_observers(
        vitality_cost().get(),
        soft_def().get(),
        soft_mdef().get(),
        max_hp().get(),
        hp_regeneration().get());
 
    intelligence()->register_observers(
        intelligence_cost().get(),
        max_sp().get(),
        status_matk().get(),
        soft_mdef().get(),
        sp_regeneration().get());
 
    dexterity()->register_observers(
        dexterity_cost().get(),
        status_atk().get(),
        equip_atk().get(),
        status_matk().get(),
        soft_mdef().get(),
        hit().get(),
        attack_speed().get(),
        base_attack().get());
 
    luck()->register_observers(
        luck_cost().get(),
        status_atk().get(),
        status_matk().get(),
        hit().get(),
        crit().get(),
        flee().get(),
        base_attack().get());
 
    base_level()->register_observers(
        status_point().get(),
        max_hp().get(),
        max_sp().get(),
        next_base_experience().get(),
        status_atk().get(),
        status_matk().get(),
        soft_def().get(),
        soft_mdef().get(),
        hit().get(),
        flee().get(),
        attack_speed().get(),
        base_attack().get());
 
    job_level()->register_observers(
        skill_point().get(),
        next_job_experience().get());
 
    max_hp()->register_observers(
        hp_regeneration().get());
    
    max_sp()->register_observers(
        sp_regeneration().get());
 
    base_experience()->register_observers(base_level().get());
 
    job_experience()->register_observers(job_level().get());
    
    /* Combat Status Attributes */
    set_attack_delay(std::make_shared<AttackDelay>(_unit));
    attack_delay()->set_attack_speed(attack_speed().get());
    
    attack_speed()->register_observers(
        attack_delay().get());
 
    set_damage_walk_delay(std::make_shared<DamageWalkDelay>(_unit));
    damage_walk_delay()->set_agility(agility().get());
 
    base_attack()->set_strength(strength().get());
    base_attack()->set_dexterity(dexterity().get());
    base_attack()->set_luck(luck().get());
    base_attack()->set_base_level(base_level().get());
 
    set_weapon_attack_left(std::make_shared<WeaponAttackLeft>(_unit));
    weapon_attack_left()->register_observable(weapon_attack_left().get());
    
    set_weapon_attack_right(std::make_shared<WeaponAttackRight>(_unit));
    weapon_attack_right()->register_observable(weapon_attack_right().get());
 
    set_weapon_attack_combined(std::make_shared<WeaponAttackCombined>(_unit));
    weapon_attack_combined()->set_weapon_attack_left(weapon_attack_left().get());
    weapon_attack_combined()->set_weapon_attack_right(weapon_attack_right().get());
 
    weapon_attack_left()->register_observers(weapon_attack_combined().get());
    weapon_attack_right()->register_observers(weapon_attack_combined().get());
    
    calculate(false);
 
    player->get_session()->clif()->notify_initial_status();
 
    set_initialized(true);
 
    current_hp()->add_periodic_change(
        s_attribute_change_values(hp_regeneration().get(), s_attribute_change_values::s_attribute_min_max(0, max_hp().get()), 
            [player, this](s_attribute_change_values &this_) {
                player->get_session()->clif()->notify_recovery(ZC_NOTIFY_RECOVERY_HP, this_.get_live_attribute().get_attribute()->total());
            }
        ), 
        0,
        player->map()->container()->game_config().get_natural_heal_hp_interval(), 
        "natural_hp_regen");
        
    current_sp()->add_periodic_change(
        s_attribute_change_values(sp_regeneration().get(), s_attribute_change_values::s_attribute_min_max(0, max_sp().get()), 
            [player, this](s_attribute_change_values &this_) {
                player->get_session()->clif()->notify_recovery(ZC_NOTIFY_RECOVERY_SP, this_.get_live_attribute().get_attribute()->total());
            }
        ), 
        0,
        player->map()->container()->game_config().get_natural_heal_sp_interval(), 
        "natural_sp_regen");
 
    return true;
}

References _unit, agility(), agility_cost(), attack_delay(), attack_speed(), base_attack(), base_experience(), base_level(), calculate(), crit(), current_hp(), current_sp(), damage_walk_delay(), dexterity(), dexterity_cost(), equip_atk(), flee(), Horizon::Zone::Traits::s_attribute_change_values::ApplyLiveAttribute::get_attribute(), Horizon::Zone::Traits::s_attribute_change_values::get_live_attribute(), hit(), HLog, hp_regeneration(), intelligence(), intelligence_cost(), job_experience(), job_level(), load(), luck(), luck_cost(), max_hp(), max_sp(), max_weight(), next_base_experience(), next_job_experience(), set_attack_delay(), set_attack_range(), set_attack_speed(), set_base_attack(), set_crit(), set_current_weight(), set_damage_walk_delay(), set_equip_atk(), set_equip_matk(), set_flee(), set_hard_def(), set_hit(), set_hp_regeneration(), set_initialized(), set_max_weight(), set_soft_def(), set_soft_mdef(), set_sp_regeneration(), set_status_atk(), set_status_matk(), set_weapon_attack_combined(), set_weapon_attack_left(), set_weapon_attack_right(), skill_point(), soft_def(), soft_mdef(), sp_regeneration(), status_atk(), status_matk(), status_point(), strength(), strength_cost(), Horizon::Zone::Traits::Attribute::total(), vitality(), vitality_cost(), weapon_attack_combined(), weapon_attack_left(), weapon_attack_right(), ZC_NOTIFY_RECOVERY_HP, and ZC_NOTIFY_RECOVERY_SP.

◆ intelligence()

std::shared_ptr< Intelligence > Horizon::Zone::Traits::Status::intelligence ( )

inline

220{ return _int; }

Horizon::Zone::Traits::Status::_int

std::shared_ptr< Intelligence > _int

Definition: Status.hpp:1796

References _int.

Referenced by get_status_base(), increase_status_point(), initialize(), load(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ intelligence_cost()

std::shared_ptr< IntelligencePointCost > Horizon::Zone::Traits::Status::intelligence_cost ( )

inline

268{ return _int_cost; }

Horizon::Zone::Traits::Status::_int_cost

std::shared_ptr< IntelligencePointCost > _int_cost

Definition: Status.hpp:1802

References _int_cost.

Referenced by increase_status_point(), and initialize().

Here is the caller graph for this function:

◆ is_initialized()

bool Horizon::Zone::Traits::Status::is_initialized ( )

inline

745{ return _is_initialized; }

Horizon::Zone::Traits::Status::_is_initialized

bool _is_initialized

Definition: Status.hpp:1787

References _is_initialized.

Referenced by recalculate(), and update().

Here is the caller graph for this function:

◆ job_experience()

std::shared_ptr< JobExperience > Horizon::Zone::Traits::Status::job_experience ( )

inline

356{ return _job_exp; }

Horizon::Zone::Traits::Status::_job_exp

std::shared_ptr< JobExperience > _job_exp

Definition: Status.hpp:1814

References _job_exp.

Referenced by initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ job_level()

std::shared_ptr< JobLevel > Horizon::Zone::Traits::Status::job_level ( )

inline

340{ return _job_level; }

Horizon::Zone::Traits::Status::_job_level

std::shared_ptr< JobLevel > _job_level

Definition: Status.hpp:1812

References _job_level.

Referenced by initialize(), load(), on_job_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ load()

bool Status::load ( std::shared_ptr< Horizon::Zone::Units::Player > pl )

Main Attributes.

Misc

{
    std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sZone->get_database_connection();
    
    try {
        boost::mysql::statement stmt = conn->prepare_statement("SELECT `job_id`, `strength`, `agility`, `vitality`, `intelligence`, `dexterity`, "
            "`luck`, `status_points`, `skill_points`, `hp`, `sp`, `maximum_hp`, `maximum_sp`, `base_level`, `job_level`, `base_experience`, `job_experience`, "
            "`hair_color_id`, `cloth_color_id`, `head_top_view_id`, `head_mid_view_id`, `head_bottom_view_id`, `hair_style_id`, `shield_view_id`, `weapon_view_id`, `robe_view_id`, "
            "`body_id`, `zeny`, `virtue`, `honor`, `manner` FROM `character_status` WHERE `id` = ?");
        auto b1 = stmt.bind(pl->character()._character_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        if (results.rows().empty()) {
            HLog(error) << "Error loading status, character with ID " << pl->character()._character_id << " does not exist.";
            return false;
        }
 
        auto r = results.rows()[0];
 
        int32_t job_id = r[0].get_uint64();
 
        std::shared_ptr<const job_config_data> job = JobDB->get_job_by_id(job_id);
        std::shared_ptr<const exp_group_data> bexpg = ExpDB->get_exp_group(job->base_exp_group, EXP_GROUP_TYPE_BASE);
        std::shared_ptr<const exp_group_data> jexpg = ExpDB->get_exp_group(job->job_exp_group, EXP_GROUP_TYPE_JOB);
 
        pl->set_job_id(job_id);
        pl->set_job(job);
 
        int32_t str = r[1].as_uint64();
        int32_t agi = r[2].as_uint64();
        int32_t vit = r[3].as_uint64();
        int32_t _int = r[4].as_uint64();
        int32_t dex = r[5].as_uint64();
        int32_t luk = r[6].as_uint64();
 
        set_strength(std::make_shared<Strength>(_unit, str));
        set_agility(std::make_shared<Agility>(_unit, agi, 0, 0));
        set_vitality(std::make_shared<Vitality>(_unit, vit, 0, 0));
        set_intelligence(std::make_shared<Intelligence>(_unit, _int, 0, 0));
        set_dexterity(std::make_shared<Dexterity>(_unit, dex, 0, 0));
        set_luck(std::make_shared<Luck>(_unit, luk, 0, 0));
 
        set_size(std::make_shared<UnitSize>(_unit, (int)ESZ_MEDIUM));
 
        set_strength_cost(std::make_shared<StrengthPointCost>(_unit, get_required_statpoints(str, str + 1)));
        set_agility_cost(std::make_shared<AgilityPointCost>(_unit, get_required_statpoints(agi, agi + 1)));
        set_vitality_cost(std::make_shared<VitalityPointCost>(_unit, get_required_statpoints(vit, vit + 1)));
        set_intelligence_cost(std::make_shared<IntelligencePointCost>(_unit, get_required_statpoints(_int, _int + 1)));
        set_dexterity_cost(std::make_shared<DexterityPointCost>(_unit, get_required_statpoints(dex, dex + 1)));
        set_luck_cost(std::make_shared<LuckPointCost>(_unit, get_required_statpoints(luk, luk + 1)));
 
        set_status_point(std::make_shared<StatusPoint>(_unit, uint32_t(r[7].as_uint64())));
        set_skill_point(std::make_shared<SkillPoint>(_unit, uint32_t(r[8].as_uint64())));
 
        set_current_hp(std::make_shared<CurrentHP>(_unit, uint32_t(r[9].as_uint64())));
        set_current_sp(std::make_shared<CurrentSP>(_unit, uint32_t(r[10].as_uint64())));
 
        uint32_t base_level_ = uint32_t(r[13].as_uint64());
        uint32_t job_level = uint32_t(r[14].as_uint64());
 
        set_base_level(std::make_shared<BaseLevel>(_unit, base_level_));
        set_job_level(std::make_shared<JobLevel>(_unit, job_level));
 
        // Max HP/SP calculated after base_level is set.
        set_max_hp(std::make_shared<MaxHP>(_unit, uint32_t(r[11].as_uint64())));
        max_hp()->set_base_level(base_level().get());
        max_hp()->set_vitality(vitality().get());
        set_max_sp(std::make_shared<MaxSP>(_unit, uint32_t(r[12].as_uint64())));
        max_sp()->set_intelligence(intelligence().get());
        max_sp()->set_base_level(base_level().get());
 
        set_base_experience(std::make_shared<BaseExperience>(_unit, uint64_t(r[15].as_uint64())));
        set_job_experience(std::make_shared<JobExperience>(_unit, uint64_t(r[16].as_uint64())));
        set_next_base_experience(std::make_shared<NextBaseExperience>(_unit, base_level_ == bexpg->max_level ? 0 : bexpg->exp[base_level_ - 1]));
        set_next_job_experience(std::make_shared<NextJobExperience>(_unit, job_level == jexpg->max_level ? 0 : jexpg->exp[job_level - 1]));
        set_movement_speed(std::make_shared<MovementSpeed>(_unit, DEFAULT_MOVEMENT_SPEED));
 
        set_base_appearance(std::make_shared<BaseAppearance>(_unit, job_id));
        set_hair_color(std::make_shared<HairColor>(_unit, uint32_t(r[17].as_uint64())));
        set_cloth_color(std::make_shared<ClothColor>(_unit, uint32_t(r[18].as_uint64())));
        set_head_top_sprite(std::make_shared<HeadTopSprite>(_unit, uint32_t(r[19].as_uint64())));
        set_head_mid_sprite(std::make_shared<HeadMidSprite>(_unit, uint32_t(r[20].as_uint64())));
        set_head_bottom_sprite(std::make_shared<HeadBottomSprite>(_unit, uint32_t(r[21].as_uint64())));
        set_hair_style(std::make_shared<HairStyle>(_unit, uint32_t(r[22].as_uint64())));
        set_shield_sprite(std::make_shared<ShieldSprite>(_unit, uint32_t(r[23].as_uint64())));
        set_weapon_sprite(std::make_shared<WeaponSprite>(_unit, uint32_t(r[24].as_uint64())));
        set_robe_sprite(std::make_shared<RobeSprite>(_unit, uint32_t(r[25].as_uint64())));
        set_body_style(std::make_shared<BodyStyle>(_unit, uint32_t(r[26].as_uint64())));
 
        set_zeny(std::make_shared<Zeny>(_unit, int32_t(r[27].as_uint64())));
        set_virtue(std::make_shared<Virtue>(_unit, int32_t(r[28].as_int64())));
        set_honor(std::make_shared<Honor>(_unit, int32_t(r[29].as_uint64())));
        set_manner(std::make_shared<Manner>(_unit, int32_t(r[30].as_int64())));
 
        HLog(info) << "Status loaded for character " << pl->name() << "(" << pl->character()._character_id << ").";
 
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << "Status::load:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Status::load:" << error.what();
        return false;
    }
    
    return true;
}

References _int, _unit, base_level(), DEFAULT_MOVEMENT_SPEED, ESZ_MEDIUM, Horizon::Zone::EXP_GROUP_TYPE_BASE, Horizon::Zone::EXP_GROUP_TYPE_JOB, ExpDB, get_required_statpoints(), HLog, intelligence(), job_level(), JobDB, max_hp(), max_sp(), set_agility(), set_agility_cost(), set_base_appearance(), set_base_experience(), set_base_level(), set_body_style(), set_cloth_color(), set_current_hp(), set_current_sp(), set_dexterity(), set_dexterity_cost(), set_hair_color(), set_hair_style(), set_head_bottom_sprite(), set_head_mid_sprite(), set_head_top_sprite(), set_honor(), set_intelligence(), set_intelligence_cost(), set_job_experience(), set_job_level(), set_luck(), set_luck_cost(), set_manner(), set_max_hp(), set_max_sp(), set_movement_speed(), set_next_base_experience(), set_next_job_experience(), set_robe_sprite(), set_shield_sprite(), set_size(), set_skill_point(), set_status_point(), set_strength(), set_strength_cost(), set_virtue(), set_vitality(), set_vitality_cost(), set_weapon_sprite(), set_zeny(), sZone, and vitality().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ luck()

std::shared_ptr< Luck > Horizon::Zone::Traits::Status::luck ( )

inline

228{ return _luk; }

Horizon::Zone::Traits::Status::_luk

std::shared_ptr< Luck > _luk

Definition: Status.hpp:1798

References _luk.

Referenced by get_status_base(), increase_status_point(), initialize(), save(), set_luck(), set_luck_cost(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ luck_cost()

std::shared_ptr< LuckPointCost > Horizon::Zone::Traits::Status::luck_cost ( )

inline

276{ return _luk_cost; }

Horizon::Zone::Traits::Status::_luk_cost

std::shared_ptr< LuckPointCost > _luk_cost

Definition: Status.hpp:1804

References _luk_cost.

Referenced by increase_status_point(), and initialize().

Here is the caller graph for this function:

◆ manner()

std::shared_ptr< Manner > Horizon::Zone::Traits::Status::manner ( )

inline

579{ return _manner; }

Horizon::Zone::Traits::Status::_manner

std::shared_ptr< Manner > _manner

Definition: Status.hpp:1851

References _manner.

Referenced by save().

Here is the caller graph for this function:

◆ max_hp()

std::shared_ptr< MaxHP > Horizon::Zone::Traits::Status::max_hp ( )

inline

300{ return _max_hp; }

Horizon::Zone::Traits::Status::_max_hp

std::shared_ptr< MaxHP > _max_hp

Definition: Status.hpp:1807

References _max_hp.

Referenced by initialize(), load(), on_job_changed(), save(), set_max_hp(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ max_sp()

std::shared_ptr< MaxSP > Horizon::Zone::Traits::Status::max_sp ( )

inline

308{ return _max_sp; }

Horizon::Zone::Traits::Status::_max_sp

std::shared_ptr< MaxSP > _max_sp

Definition: Status.hpp:1808

References _max_sp.

Referenced by initialize(), load(), on_job_changed(), save(), set_max_sp(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ max_weight()

std::shared_ptr< MaxWeight > Horizon::Zone::Traits::Status::max_weight ( )

inline

388{ return _max_weight; }

Horizon::Zone::Traits::Status::_max_weight

std::shared_ptr< MaxWeight > _max_weight

Definition: Status.hpp:1818

References _max_weight.

Referenced by initialize(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ movement_speed()

std::shared_ptr< MovementSpeed > Horizon::Zone::Traits::Status::movement_speed ( )

inline

380{ return _movement_speed; }

Horizon::Zone::Traits::Status::_movement_speed

std::shared_ptr< MovementSpeed > _movement_speed

Definition: Status.hpp:1817

References _movement_speed.

Referenced by Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ next_base_experience()

std::shared_ptr< NextBaseExperience > Horizon::Zone::Traits::Status::next_base_experience ( )

inline

364{ return _next_base_exp; }

Horizon::Zone::Traits::Status::_next_base_exp

std::shared_ptr< NextBaseExperience > _next_base_exp

Definition: Status.hpp:1815

References _next_base_exp.

Referenced by initialize(), on_job_changed(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ next_job_experience()

std::shared_ptr< NextJobExperience > Horizon::Zone::Traits::Status::next_job_experience ( )

inline

372{ return _next_job_exp; }

Horizon::Zone::Traits::Status::_next_job_exp

std::shared_ptr< NextJobExperience > _next_job_exp

Definition: Status.hpp:1816

References _next_job_exp.

Referenced by initialize(), on_job_changed(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ on_equipment_changed()

void Status::on_equipment_changed	(	bool	equipped,
		std::shared_ptr< const item_entry_data >	item
	)

{
    if (item == nullptr)
        return;
 
    if (item->type == IT_TYPE_WEAPON) {
        status_atk()->set_weapon_type(equipped ? item->config->sub_type.weapon_t : IT_WT_FIST);
        equip_atk()->on_weapon_changed();
 
        weapon_attack_left()->on_equipment_changed();
        weapon_attack_right()->on_equipment_changed();
 
        if ((item->config->equip_location_mask & IT_EQPM_HAND_L) == IT_EQPM_HAND_L)
            weapon_sprite()->set_left(equipped ? item->item_id : 0);
        else if ((item->config->equip_location_mask & IT_EQPM_HAND_R) == IT_EQPM_HAND_R)
            weapon_sprite()->set(equipped ? item->item_id : 0);
    } else if (item->type == IT_TYPE_ARMOR) {
        if ((item->config->equip_location_mask & IT_EQPM_HEAD_TOP) == IT_EQPM_HEAD_TOP)
            head_top_sprite()->set(equipped ? item->config->sprite_id : 0);
        else if ((item->config->equip_location_mask & IT_EQPM_HEAD_MID) == IT_EQPM_HEAD_MID)
            head_mid_sprite()->set(equipped ? item->config->sprite_id : 0);
        else if ((item->config->equip_location_mask & IT_EQPM_HEAD_LOW) == IT_EQPM_HEAD_LOW)
            head_bottom_sprite()->set(equipped ? item->config->sprite_id : 0);
        else if ((item->config->equip_location_mask & IT_EQPM_HAND_L) == IT_EQPM_HAND_L)
            shield_sprite()->set(equipped ? item->config->sprite_id : 0);
        else if ((item->config->equip_location_mask & IT_EQPM_GARMENT) == IT_EQPM_GARMENT)
            robe_sprite()->set(equipped ? item->config->sprite_id : 0);
    }
 
    attack_speed()->on_equipment_changed();
    attack_range()->on_equipment_changed();
    base_attack()->on_equipment_changed();
    equip_matk()->on_equipment_changed();
}

References attack_range(), attack_speed(), base_attack(), equip_atk(), equip_matk(), head_bottom_sprite(), head_mid_sprite(), head_top_sprite(), IT_EQPM_GARMENT, IT_EQPM_HAND_L, IT_EQPM_HAND_R, IT_EQPM_HEAD_LOW, IT_EQPM_HEAD_MID, IT_EQPM_HEAD_TOP, IT_TYPE_ARMOR, IT_TYPE_WEAPON, IT_WT_FIST, robe_sprite(), shield_sprite(), status_atk(), weapon_attack_left(), weapon_attack_right(), and weapon_sprite().

Here is the call graph for this function:

◆ on_job_changed()

void Status::on_job_changed ( uint32_t job_id )

{
    base_appearance()->set(job_id);
    max_hp()->compute();
    max_sp()->compute();
    next_base_experience()->compute();
    next_job_experience()->compute();
    attack_speed()->compute();
    base_level()->compute();
    job_level()->compute();
}

References attack_speed(), base_appearance(), base_level(), job_level(), max_hp(), max_sp(), next_base_experience(), and next_job_experience().

Here is the call graph for this function:

◆ recalculate()

bool Status::recalculate ( bool notify = true )

{
    if (!is_initialized()) {
        HLog(error) << "Status::recalculate: Status is not initialized.";
        return false;
    }
 
    // Recalculate all attributes.
    for (auto i : _attributes) {
        i->reset();
        i->apply(notify);
    }
    
    return true;
}

References _attributes, HLog, and is_initialized().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_appearance()

void Horizon::Zone::Traits::Status::remove_appearance ( std::shared_ptr< Appearance > appearance )

inline

    {
        _appearances.erase(std::remove(_appearances.begin(), _appearances.end(), appearance), _appearances.end());
    }

References _appearances.

◆ remove_attribute()

void Horizon::Zone::Traits::Status::remove_attribute ( std::shared_ptr< Attribute > attribute )

inline

    {
        _attributes.erase(std::remove(_attributes.begin(), _attributes.end(), attribute), _attributes.end());
    }

References _attributes.

Referenced by set_agility(), set_agility_cost(), set_attack_delay(), set_attack_range(), set_attack_speed(), set_base_attack(), set_base_experience(), set_base_level(), set_creature_attack_damage(), set_creature_chase_range(), set_creature_element(), set_creature_element_level(), set_creature_magic_attack_damage(), set_creature_mode(), set_creature_primary_race(), set_creature_secondary_race(), set_creature_view_range(), set_creature_weapon_attack(), set_creature_weapon_attack_magic(), set_crit(), set_current_hp(), set_current_sp(), set_current_weight(), set_damage_walk_delay(), set_dexterity(), set_dexterity_cost(), set_equip_atk(), set_equip_matk(), set_flee(), set_hard_def(), set_hard_mdef(), set_hit(), set_honor(), set_hp_regeneration(), set_intelligence(), set_intelligence_cost(), set_job_experience(), set_job_level(), set_luck(), set_luck_cost(), set_manner(), set_max_hp(), set_max_sp(), set_max_weight(), set_movement_speed(), set_next_base_experience(), set_next_job_experience(), set_size(), set_skill_point(), set_soft_def(), set_soft_mdef(), set_sp_regeneration(), set_status_atk(), set_status_matk(), set_status_point(), set_strength(), set_strength_cost(), set_virtue(), set_vitality(), set_vitality_cost(), set_weapon_attack_combined(), set_weapon_attack_left(), set_weapon_attack_right(), and set_zeny().

◆ remove_bonus() [1/2]

void Horizon::Zone::Traits::Status::remove_bonus ( std::shared_ptr< Bonuses::Bonus > bonus )

inline

    {
        _bonuses.erase(std::remove(_bonuses.begin(), _bonuses.end(), bonus), _bonuses.end());
    }

References _bonuses.

◆ remove_bonus() [2/2]

void Horizon::Zone::Traits::Status::remove_bonus ( std::shared_ptr< Bonuses::IBonusArray > ba )

inline

    {
        _bonus_arrays.erase(std::remove(_bonus_arrays.begin(), _bonus_arrays.end(), ba), _bonus_arrays.end());
    }

References _bonus_arrays.

◆ robe_sprite()

std::shared_ptr< RobeSprite > Horizon::Zone::Traits::Status::robe_sprite ( )

inline

545{ return _robe_sprite; }

Horizon::Zone::Traits::Status::_robe_sprite

std::shared_ptr< RobeSprite > _robe_sprite

Definition: Status.hpp:1842

References _robe_sprite.

Referenced by on_equipment_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ save()

bool Status::save ( std::shared_ptr< Horizon::Zone::Units::Player > pl )

{
    std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sZone->get_database_connection();
    
    try {
        boost::mysql::statement stmt = conn->prepare_statement("UPDATE `character_status` SET `job_id` = ?, `base_level` = ?, `job_level` = ?, `base_experience` = ?, `job_experience` = ?, "
            "`zeny` = ?, `strength` = ?, `agility` = ?, `vitality` = ?, `intelligence` = ?, `dexterity` = ?, `luck` = ?, `maximum_hp` = ?, `hp` = ?, `maximum_sp` = ?, `sp` = ?, "
            "`status_points` = ?, `skill_points` = ?, `body_state` = ?, `virtue` = ?, `honor` = ?, `manner` = ?, `hair_style_id` = ?, `hair_color_id` = ?, `cloth_color_id` = ?, `body_id` = ?, "
            "`weapon_view_id` = ?, `shield_view_id` = ?, `head_top_view_id` = ?, `head_mid_view_id` = ?, `head_bottom_view_id` = ?, `robe_view_id` = ? "
            "WHERE id = ?");
        auto b1 = stmt.bind(pl->job_id(), base_level()->total(), job_level()->total(), base_experience()->total(),
            job_experience()->total(), zeny()->total(), strength()->total(), agility()->total(), vitality()->total(),
            intelligence()->total(), dexterity()->total(),
            luck()->total(), max_hp()->total(), current_hp()->total(), max_sp()->total(), current_sp()->total(), status_point()->total(),
            skill_point()->total(), 0, virtue()->total(), honor()->total(), manner()->total(), hair_style()->get(),
            hair_color()->get(), cloth_color()->get(), body_style()->get(), weapon_sprite()->get(), shield_sprite()->get(),
            head_top_sprite()->get(), head_mid_sprite()->get(), head_bottom_sprite()->get(), robe_sprite()->get(),
            pl->character()._character_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        HLog(info) << "Status saved for character " << pl->name() << "(" << pl->character()._character_id << ").";
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << "Status::save:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Status::save:" << error.what();
        return false;
    }
    
    return true;
}

References agility(), base_experience(), base_level(), body_style(), cloth_color(), current_hp(), current_sp(), dexterity(), hair_color(), hair_style(), head_bottom_sprite(), head_mid_sprite(), head_top_sprite(), HLog, honor(), intelligence(), job_experience(), job_level(), luck(), manner(), max_hp(), max_sp(), robe_sprite(), shield_sprite(), skill_point(), status_point(), strength(), sZone, virtue(), vitality(), weapon_sprite(), and zeny().

Here is the call graph for this function:

◆ set_agility()

void Horizon::Zone::Traits::Status::set_agility ( std::shared_ptr< Agility > agi )

inline

                                                 {
        if (_agi != nullptr)
            remove_attribute(_agi);
        add_attribute(agi);
        _agi = agi;
    }

References _agi, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_agility_cost()

void Horizon::Zone::Traits::Status::set_agility_cost ( std::shared_ptr< AgilityPointCost > agi )

inline

                                                               {
        if (_agi_cost != nullptr)
            remove_attribute(_agi_cost);
        add_attribute(agi);
        _agi_cost = agi;
    }

References _agi_cost, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_attack_delay()

void Horizon::Zone::Traits::Status::set_attack_delay ( std::shared_ptr< AttackDelay > a )

inline

                                                        {
        if (_attack_delay != nullptr)
            remove_attribute(_attack_delay);
        add_attribute(a);
        _attack_delay = a;
    }

References _attack_delay, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_attack_range()

void Horizon::Zone::Traits::Status::set_attack_range ( std::shared_ptr< AttackRange > m )

inline

                                                        {
        if (_attack_range != nullptr)
            remove_attribute(_attack_range);
        add_attribute(m);
        _attack_range = m;
    }

References _attack_range, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_attack_speed()

void Horizon::Zone::Traits::Status::set_attack_speed ( std::shared_ptr< AttackSpeed > aspd )

inline

                                                           {
        if (_aspd != nullptr)
            remove_attribute(_aspd);
        add_attribute(aspd);
        _aspd = aspd;
    }

References _aspd, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_base_appearance()

void Horizon::Zone::Traits::Status::set_base_appearance ( std::shared_ptr< BaseAppearance > ba )

inline

531{ add_appearance(ba); _base_appearance = ba; }

Horizon::Zone::Traits::Status::add_appearance

void add_appearance(std::shared_ptr< Appearance > appearance)

Definition: Status.hpp:764

References _base_appearance, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_base_attack()

void Horizon::Zone::Traits::Status::set_base_attack ( std::shared_ptr< BaseAttack > b )

inline

                                                      {
        if (_base_attack != nullptr)
            remove_attribute(_base_attack);
        add_attribute(b);
        _base_attack = b;
    }

References _base_attack, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_base_experience()

void Horizon::Zone::Traits::Status::set_base_experience ( std::shared_ptr< BaseExperience > bexp )

inline

                                                                 {
        if (_base_exp != nullptr)
            remove_attribute(_base_exp);
        add_attribute(bexp);
        _base_exp = bexp;
    }

References _base_exp, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_base_level()

void Horizon::Zone::Traits::Status::set_base_level ( std::shared_ptr< BaseLevel > blvl )

inline

                                                       {
        if (_base_level != nullptr)
            remove_attribute(_base_level);
        add_attribute(blvl);
        _base_level = blvl;
    }

References _base_level, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_body_style()

void Horizon::Zone::Traits::Status::set_body_style ( std::shared_ptr< BodyStyle > bs )

inline

561{ add_appearance(bs); _body_style = bs; }

References _body_style, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_bonus_add_attack()

void Horizon::Zone::Traits::Status::set_bonus_add_attack ( std::shared_ptr< Bonuses::BonusAddAttack > b )

inline

                                                                      {
        if (_bonus->_add_attack != nullptr)
            remove_bonus(_bonus->_add_attack);
        add_bonus(b);
        _bonus->_add_attack = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_attack_percent()

void Horizon::Zone::Traits::Status::set_bonus_add_attack_percent ( std::shared_ptr< Bonuses::BonusAddAttackPercent > b )

inline

                                                                                     {
        if (_bonus->_add_attack_percent != nullptr)
            remove_bonus(_bonus->_add_attack_percent);
        add_bonus(b);
        _bonus->_add_attack_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_attack_percentage_to_element()

void Horizon::Zone::Traits::Status::set_bonus_add_attack_percentage_to_element ( std::shared_ptr< Bonuses::BonusAddAttackPercentageToElement > b )

inline

                                                                                                               {
        if (_bonus->_add_attack_percentage_to_element != nullptr)
            remove_bonus(_bonus->_add_attack_percentage_to_element);
        add_bonus(b);
        _bonus->_add_attack_percentage_to_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_attack_percentage_to_race()

void Horizon::Zone::Traits::Status::set_bonus_add_attack_percentage_to_race ( std::shared_ptr< Bonuses::BonusAddAttackPercentageToRace > b )

inline

                                                                                                         {
        if (_bonus->_add_attack_percentage_to_race != nullptr)
            remove_bonus(_bonus->_add_attack_percentage_to_race);
        add_bonus(b);
        _bonus->_add_attack_percentage_to_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_attack_percentage_to_size()

void Horizon::Zone::Traits::Status::set_bonus_add_attack_percentage_to_size ( std::shared_ptr< Bonuses::BonusAddAttackPercentageToSize > b )

inline

                                                                                                         {
        if (_bonus->_add_attack_percentage_to_size != nullptr)
            remove_bonus(_bonus->_add_attack_percentage_to_size);
        add_bonus(b);
        _bonus->_add_attack_percentage_to_size = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_damage_to_class()

void Horizon::Zone::Traits::Status::set_bonus_add_damage_to_class ( std::shared_ptr< Bonuses::BonusAddDamageToClass > b )

inline

                                                                                      {
        if (_bonus->_add_damage_to_class != nullptr)
            remove_bonus(_bonus->_add_damage_to_class);
        add_bonus(b);
        _bonus->_add_damage_to_class = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_defense_to_class()

void Horizon::Zone::Traits::Status::set_bonus_add_defense_to_class ( std::shared_ptr< Bonuses::BonusAddDefenseToClass > b )

inline

                                                                                        {
        if (_bonus->_add_defense_to_class != nullptr)
            remove_bonus(_bonus->_add_defense_to_class);
        add_bonus(b);
        _bonus->_add_defense_to_class = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_effect_on_damage()

void Horizon::Zone::Traits::Status::set_bonus_add_effect_on_damage ( std::shared_ptr< Bonuses::BonusAddEffectOnDamage > b )

inline

                                                                                        {
        if (_bonus->_add_effect_on_damage != nullptr)
            remove_bonus(_bonus->_add_effect_on_damage);
        add_bonus(b);
        _bonus->_add_effect_on_damage = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_effect_on_magic_attack()

void Horizon::Zone::Traits::Status::set_bonus_add_effect_on_magic_attack ( std::shared_ptr< Bonuses::BonusAddEffectOnMagicAttack > b )

inline

                                                                                                   {
        if (_bonus->_add_effect_on_magic_attack != nullptr)
            remove_bonus(_bonus->_add_effect_on_magic_attack);
        add_bonus(b);
        _bonus->_add_effect_on_magic_attack = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_effect_when_damaged()

void Horizon::Zone::Traits::Status::set_bonus_add_effect_when_damaged ( std::shared_ptr< Bonuses::BonusAddEffectWhenDamaged > b )

inline

                                                                                              {
        if (_bonus->_add_effect_when_damaged != nullptr)
            remove_bonus(_bonus->_add_effect_when_damaged);
        add_bonus(b);
        _bonus->_add_effect_when_damaged = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_ele_magic_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_add_ele_magic_damage_percent ( std::shared_ptr< Bonuses::BonusAddEleMagicDamagePercent > b )

inline

                                                                                                       {
        if (_bonus->_add_ele_magic_damage_percent != nullptr)
            remove_bonus(_bonus->_add_ele_magic_damage_percent);
        add_bonus(b);
        _bonus->_add_ele_magic_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_ele_weapon_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_add_ele_weapon_damage_percent ( std::shared_ptr< Bonuses::BonusAddEleWeaponDamagePercent > b )

inline

                                                                                                         {
        if (_bonus->_add_ele_weapon_damage_percent != nullptr)
            remove_bonus(_bonus->_add_ele_weapon_damage_percent);
        add_bonus(b);
        _bonus->_add_ele_weapon_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_item_drop_on_monster_kill()

void Horizon::Zone::Traits::Status::set_bonus_add_item_drop_on_monster_kill ( std::shared_ptr< Bonuses::BonusAddItemDropOnMonsterKill > b )

inline

                                                                                                        {
        if (_bonus->_add_item_drop_on_monster_kill != nullptr)
            remove_bonus(_bonus->_add_item_drop_on_monster_kill);
        add_bonus(b);
        _bonus->_add_item_drop_on_monster_kill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_magic_attack_percentage_to_element()

void Horizon::Zone::Traits::Status::set_bonus_add_magic_attack_percentage_to_element ( std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToElement > b )

inline

                                                                                                                          {
        if (_bonus->_add_magic_attack_percentage_to_element != nullptr)
            remove_bonus(_bonus->_add_magic_attack_percentage_to_element);
        add_bonus(b);
        _bonus->_add_magic_attack_percentage_to_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_magic_attack_percentage_to_race()

void Horizon::Zone::Traits::Status::set_bonus_add_magic_attack_percentage_to_race ( std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToRace > b )

inline

                                                                                                                    {
        if (_bonus->_add_magic_attack_percentage_to_race != nullptr)
            remove_bonus(_bonus->_add_magic_attack_percentage_to_race);
        add_bonus(b);
        _bonus->_add_magic_attack_percentage_to_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_magic_attack_percentage_to_size()

void Horizon::Zone::Traits::Status::set_bonus_add_magic_attack_percentage_to_size ( std::shared_ptr< Bonuses::BonusAddMagicAttackPercentageToSize > b )

inline

                                                                                                                    {
        if (_bonus->_add_magic_attack_percentage_to_size != nullptr)
            remove_bonus(_bonus->_add_magic_attack_percentage_to_size);
        add_bonus(b);
        _bonus->_add_magic_attack_percentage_to_size = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_magic_damage_to_class()

void Horizon::Zone::Traits::Status::set_bonus_add_magic_damage_to_class ( std::shared_ptr< Bonuses::BonusAddMagicDamageToClass > b )

inline

                                                                                                 {
        if (_bonus->_add_magic_damage_to_class != nullptr)
            remove_bonus(_bonus->_add_magic_damage_to_class);
        add_bonus(b);
        _bonus->_add_magic_damage_to_class = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_magical_defense_to_class()

void Horizon::Zone::Traits::Status::set_bonus_add_magical_defense_to_class ( std::shared_ptr< Bonuses::BonusAddMagicalDefenseToClass > b )

inline

                                                                                                       {
        if (_bonus->_add_magical_defense_to_class != nullptr)
            remove_bonus(_bonus->_add_magical_defense_to_class);
        add_bonus(b);
        _bonus->_add_magical_defense_to_class = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_movement_speed_percent()

void Horizon::Zone::Traits::Status::set_bonus_add_movement_speed_percent ( std::shared_ptr< Bonuses::BonusAddMovementSpeedPercent > b )

inline

                                                                                                    {
        if (_bonus->_bonus_add_movement_speed_percent != nullptr)
            remove_bonus(_bonus->_bonus_add_movement_speed_percent);
        add_bonus(b);
        _bonus->_bonus_add_movement_speed_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_steal_percent()

void Horizon::Zone::Traits::Status::set_bonus_add_steal_percent ( std::shared_ptr< Bonuses::BonusAddStealPercent > b )

inline

                                                                                   {
        if (_bonus->_add_steal_percent != nullptr)
            remove_bonus(_bonus->_add_steal_percent);
        add_bonus(b);
        _bonus->_add_steal_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_weapon_coma_to_element()

void Horizon::Zone::Traits::Status::set_bonus_add_weapon_coma_to_element ( std::shared_ptr< Bonuses::BonusAddWeaponComaToElement > b )

inline

                                                                                                   {
        if (_bonus->_add_weapon_coma_to_element != nullptr)
            remove_bonus(_bonus->_add_weapon_coma_to_element);
        add_bonus(b);
        _bonus->_add_weapon_coma_to_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_weapon_coma_to_race()

void Horizon::Zone::Traits::Status::set_bonus_add_weapon_coma_to_race ( std::shared_ptr< Bonuses::BonusAddWeaponComaToRace > b )

inline

                                                                                             {
        if (_bonus->_add_weapon_coma_to_race != nullptr)
            remove_bonus(_bonus->_add_weapon_coma_to_race);
        add_bonus(b);
        _bonus->_add_weapon_coma_to_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_weapon_coma_to_sub_element()

void Horizon::Zone::Traits::Status::set_bonus_add_weapon_coma_to_sub_element ( std::shared_ptr< Bonuses::BonusAddWeaponComaToSubElement > b )

inline

                                                                                                          {
        if (_bonus->_add_weapon_coma_to_sub_element != nullptr)
            remove_bonus(_bonus->_add_weapon_coma_to_sub_element);
        add_bonus(b);
        _bonus->_add_weapon_coma_to_sub_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_add_weapon_coma_to_sub_race()

void Horizon::Zone::Traits::Status::set_bonus_add_weapon_coma_to_sub_race ( std::shared_ptr< Bonuses::BonusAddWeaponComaToSubRace > b )

inline

                                                                                                    {
        if (_bonus->_add_weapon_coma_to_sub_race != nullptr)
            remove_bonus(_bonus->_add_weapon_coma_to_sub_race);
        add_bonus(b);
        _bonus->_add_weapon_coma_to_sub_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_all_status()

void Horizon::Zone::Traits::Status::set_bonus_all_status ( std::shared_ptr< Bonuses::BonusAllStatus > b )

inline

                                                                      {
        if (_bonus->_all_status != nullptr)
            remove_bonus(_bonus->_all_status);
        add_bonus(b);
        _bonus->_all_status = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_armor_break_percent()

void Horizon::Zone::Traits::Status::set_bonus_armor_break_percent ( std::shared_ptr< Bonuses::BonusArmorBreakPercent > b )

inline

                                                                                       {
        if (_bonus->_armor_break_percent != nullptr)
            remove_bonus(_bonus->_armor_break_percent);
        add_bonus(b);
        _bonus->_armor_break_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_element()

void Horizon::Zone::Traits::Status::set_bonus_attack_element ( std::shared_ptr< Bonuses::BonusAttackElement > b )

inline

                                                                              {
        if (_bonus->_attack_element != nullptr)
            remove_bonus(_bonus->_attack_element);
        add_bonus(b);
        _bonus->_attack_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_on_defense_ratio_for_element()

void Horizon::Zone::Traits::Status::set_bonus_attack_on_defense_ratio_for_element ( std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForElement > b )

inline

                                                                                                                    {
        if (_bonus->_attack_on_defense_ratio_for_element != nullptr)
            remove_bonus(_bonus->_attack_on_defense_ratio_for_element);
        add_bonus(b);
        _bonus->_attack_on_defense_ratio_for_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_on_defense_ratio_for_race()

void Horizon::Zone::Traits::Status::set_bonus_attack_on_defense_ratio_for_race ( std::shared_ptr< Bonuses::BonusAttackOnDefenseRatioForRace > b )

inline

                                                                                                              {
        if (_bonus->_attack_on_defense_ratio_for_race != nullptr)
            remove_bonus(_bonus->_attack_on_defense_ratio_for_race);
        add_bonus(b);
        _bonus->_attack_on_defense_ratio_for_race = b;
    };

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_percent()

void Horizon::Zone::Traits::Status::set_bonus_attack_percent ( std::shared_ptr< Bonuses::BonusAttackPercent > b )

inline

                                                                              {
        if (_bonus->_attack_percent != nullptr)
            remove_bonus(_bonus->_attack_percent);
        add_bonus(b);
        _bonus->_attack_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_range()

void Horizon::Zone::Traits::Status::set_bonus_attack_range ( std::shared_ptr< Bonuses::BonusAttackRange > b )

inline

                                                                          {
        if (_bonus->_attack_range != nullptr)
            remove_bonus(_bonus->_attack_range);
        add_bonus(b);
        _bonus->_attack_range = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_range_percent()

void Horizon::Zone::Traits::Status::set_bonus_attack_range_percent ( std::shared_ptr< Bonuses::BonusAttackRangePercent > b )

inline

                                                                                         {
        if (_bonus->_attack_range_percent != nullptr)
            remove_bonus(_bonus->_attack_range_percent);
        add_bonus(b);
        _bonus->_attack_range_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_attack_speed_percent()

void Horizon::Zone::Traits::Status::set_bonus_attack_speed_percent ( std::shared_ptr< Bonuses::BonusAttackSpeedPercent > b )

inline

                                                                                         {
        if (_bonus->_attack_speed_percent != nullptr)
            remove_bonus(_bonus->_attack_speed_percent);
        add_bonus(b);
        _bonus->_attack_speed_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_auto_spell_on_attack()

void Horizon::Zone::Traits::Status::set_bonus_auto_spell_on_attack ( std::shared_ptr< Bonuses::BonusAutoSpellOnAttack > b )

inline

                                                                                        {
        if (_bonus->_auto_spell_on_attack != nullptr)
            remove_bonus(_bonus->_auto_spell_on_attack);
        add_bonus(b);
        _bonus->_auto_spell_on_attack = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_auto_spell_on_receive_damage()

void Horizon::Zone::Traits::Status::set_bonus_auto_spell_on_receive_damage ( std::shared_ptr< Bonuses::BonusAutoSpellOnReceiveDamage > b )

inline

                                                                                                       {
        if (_bonus->_auto_spell_on_receive_damage != nullptr)
            remove_bonus(_bonus->_auto_spell_on_receive_damage);
        add_bonus(b);
        _bonus->_auto_spell_on_receive_damage = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_auto_spell_on_self()

void Horizon::Zone::Traits::Status::set_bonus_auto_spell_on_self ( std::shared_ptr< Bonuses::BonusAutoSpellOnSelf > b )

inline

                                                                                    {
        if (_bonus->_auto_spell_on_self != nullptr)
            remove_bonus(_bonus->_auto_spell_on_self);
        add_bonus(b);
        _bonus->_auto_spell_on_self = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_auto_spell_on_skill()

void Horizon::Zone::Traits::Status::set_bonus_auto_spell_on_skill ( std::shared_ptr< Bonuses::BonusAutoSpellOnSkill > b )

inline

                                                                                      {
        if (_bonus->_auto_spell_on_skill != nullptr)
            remove_bonus(_bonus->_auto_spell_on_skill);
        add_bonus(b);
        _bonus->_auto_spell_on_skill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_cast_cancel_immunity()

void Horizon::Zone::Traits::Status::set_bonus_cast_cancel_immunity ( std::shared_ptr< Bonuses::BonusCastCancelImmunity > b )

inline

                                                                                         {
        if (_bonus->_cast_cancel_immunity != nullptr)
            remove_bonus(_bonus->_cast_cancel_immunity);
        add_bonus(b);
        _bonus->_cast_cancel_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_cast_percent()

void Horizon::Zone::Traits::Status::set_bonus_cast_percent ( std::shared_ptr< Bonuses::BonusCastPercent > b )

inline

                                                                          {
        if (_bonus->_cast_percent != nullptr)
            remove_bonus(_bonus->_cast_percent);
        add_bonus(b);
        _bonus->_cast_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_critical_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_critical_damage_percent ( std::shared_ptr< Bonuses::BonusCriticalDamagePercent > b )

inline

                                                                                               {
        if (_bonus->_critical_damage_percent != nullptr)
            remove_bonus(_bonus->_critical_damage_percent);
        add_bonus(b);
        _bonus->_critical_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_critical_defense()

void Horizon::Zone::Traits::Status::set_bonus_critical_defense ( std::shared_ptr< Bonuses::BonusCriticalDefense > b )

inline

                                                                                  {
        if (_bonus->_critical_defense != nullptr)
            remove_bonus(_bonus->_critical_defense);
        add_bonus(b);
        _bonus->_critical_defense = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_critical_percent()

void Horizon::Zone::Traits::Status::set_bonus_critical_percent ( std::shared_ptr< Bonuses::BonusCriticalPercent > b )

inline

                                                                                  {
        if (_bonus->_critical_percent != nullptr)
            remove_bonus(_bonus->_critical_percent);
        add_bonus(b);
        _bonus->_critical_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_critical_race()

void Horizon::Zone::Traits::Status::set_bonus_critical_race ( std::shared_ptr< Bonuses::BonusCriticalRace > b )

inline

                                                                            {
        if (_bonus->_critical_race != nullptr)
            remove_bonus(_bonus->_critical_race);
        add_bonus(b);
        _bonus->_critical_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_critical_race_percent()

void Horizon::Zone::Traits::Status::set_bonus_critical_race_percent ( std::shared_ptr< Bonuses::BonusCriticalRacePercent > b )

inline

                                                                                           {
        if (_bonus->_critical_race_percent != nullptr)
            remove_bonus(_bonus->_critical_race_percent);
        add_bonus(b);
        _bonus->_critical_race_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_damage_reduction_against_size()

void Horizon::Zone::Traits::Status::set_bonus_damage_reduction_against_size ( std::shared_ptr< Bonuses::BonusDamageReductionAgainstSize > b )

inline

                                                                                                          {
        if (_bonus->_damage_reduction_against_size != nullptr)
            remove_bonus(_bonus->_damage_reduction_against_size);
        add_bonus(b);
        _bonus->_damage_reduction_against_size = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_damage_splash_range()

void Horizon::Zone::Traits::Status::set_bonus_damage_splash_range ( std::shared_ptr< Bonuses::BonusDamageSplashRange > b )

inline

                                                                                       {
        if (_bonus->_damage_splash_range != nullptr)
            remove_bonus(_bonus->_damage_splash_range);
        add_bonus(b);
        _bonus->_damage_splash_range = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_defense_element()

void Horizon::Zone::Traits::Status::set_bonus_defense_element ( std::shared_ptr< Bonuses::BonusDefenseElement > b )

inline

                                                                                {
        if (_bonus->_defense_element != nullptr)
            remove_bonus(_bonus->_defense_element);
        add_bonus(b);
        _bonus->_defense_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_disable_hp_recovery()

void Horizon::Zone::Traits::Status::set_bonus_disable_hp_recovery ( std::shared_ptr< Bonuses::BonusDisableHPRecovery > b )

inline

                                                                                       {
        if (_bonus->_disable_hp_recovery != nullptr)
            remove_bonus(_bonus->_disable_hp_recovery);
        add_bonus(b);
        _bonus->_disable_hp_recovery = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_disable_sp_recovery()

void Horizon::Zone::Traits::Status::set_bonus_disable_sp_recovery ( std::shared_ptr< Bonuses::BonusDisableSPRecovery > b )

inline

                                                                                       {
        if (_bonus->_disable_sp_recovery != nullptr)
            remove_bonus(_bonus->_disable_sp_recovery);
        add_bonus(b);
        _bonus->_disable_sp_recovery = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_double_attack_percent()

void Horizon::Zone::Traits::Status::set_bonus_double_attack_percent ( std::shared_ptr< Bonuses::BonusDoubleAttackPercent > b )

inline

                                                                                           {
        if (_bonus->_double_attack_percent != nullptr)
            remove_bonus(_bonus->_double_attack_percent);
        add_bonus(b);
        _bonus->_double_attack_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_exp_percent_per_race()

void Horizon::Zone::Traits::Status::set_bonus_exp_percent_per_race ( std::shared_ptr< Bonuses::BonusExpPercentPerRace > b )

inline

                                                                                        {
        if (_bonus->_exp_percent_per_race != nullptr)
            remove_bonus(_bonus->_exp_percent_per_race);
        add_bonus(b);
        _bonus->_exp_percent_per_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_flee_percent()

void Horizon::Zone::Traits::Status::set_bonus_flee_percent ( std::shared_ptr< Bonuses::BonusFleePercent > b )

inline

                                                                          {
        if (_bonus->_flee_percent != nullptr)
            remove_bonus(_bonus->_flee_percent);
        add_bonus(b);
        _bonus->_flee_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_gear_fuel_immunity()

void Horizon::Zone::Traits::Status::set_bonus_gear_fuel_immunity ( std::shared_ptr< Bonuses::BonusGearFuelImmunity > b )

inline

                                                                                     {
        if (_bonus->_gear_fuel_immunity != nullptr)
            remove_bonus(_bonus->_gear_fuel_immunity);
        add_bonus(b);
        _bonus->_gear_fuel_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_gemstone_immunity()

void Horizon::Zone::Traits::Status::set_bonus_gemstone_immunity ( std::shared_ptr< Bonuses::BonusGemstoneImmunity > b )

inline

                                                                                    {
        if (_bonus->_gemstone_immunity != nullptr)
            remove_bonus(_bonus->_gemstone_immunity);
        add_bonus(b);
        _bonus->_gemstone_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_get_zeny_num()

void Horizon::Zone::Traits::Status::set_bonus_get_zeny_num ( std::shared_ptr< Bonuses::BonusGetZenyNum > b )

inline

                                                                         {
        if (_bonus->_get_zeny_num != nullptr)
            remove_bonus(_bonus->_get_zeny_num);
        add_bonus(b);
        _bonus->_get_zeny_num = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hard_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_hard_defense_percent ( std::shared_ptr< Bonuses::BonusHardDefensePercent > b )

inline

                                                                                         {
        if (_bonus->_hard_defense_percent != nullptr)
            remove_bonus(_bonus->_hard_defense_percent);
        add_bonus(b);
        _bonus->_hard_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hard_magical_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_hard_magical_defense_percent ( std::shared_ptr< Bonuses::BonusHardMagicalDefensePercent > b )

inline

                                                                                                        {
        if (_bonus->_hard_magical_defense_percent != nullptr)
            remove_bonus(_bonus->_hard_magical_defense_percent);
        add_bonus(b);
        _bonus->_hard_magical_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_heal_of_skill_casted_on_self()

void Horizon::Zone::Traits::Status::set_bonus_heal_of_skill_casted_on_self ( std::shared_ptr< Bonuses::BonusHealOfSkillCastedOnSelf > b )

inline

                                                                                                      {
        if (_bonus->_heal_of_skill_casted_on_self != nullptr)
            remove_bonus(_bonus->_heal_of_skill_casted_on_self);
        add_bonus(b);
        _bonus->_heal_of_skill_casted_on_self = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hit_percent()

void Horizon::Zone::Traits::Status::set_bonus_hit_percent ( std::shared_ptr< Bonuses::BonusHitPercent > b )

inline

                                                                        {
        if (_bonus->_hit_percent != nullptr)
            remove_bonus(_bonus->_hit_percent);
        add_bonus(b);
        _bonus->_hit_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_drain_on_monster_kill()

void Horizon::Zone::Traits::Status::set_bonus_hp_drain_on_monster_kill ( std::shared_ptr< Bonuses::BonusHPDrainOnMonsterKill > b )

inline

                                                                                               {
        if (_bonus->_hp_drain_on_monster_kill != nullptr)
            remove_bonus(_bonus->_hp_drain_on_monster_kill);
        add_bonus(b);
        _bonus->_hp_drain_on_monster_kill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_drain_percent()

void Horizon::Zone::Traits::Status::set_bonus_hp_drain_percent ( std::shared_ptr< Bonuses::BonusHPDrainPercent > b )

inline

                                                                                 {
        if (_bonus->_hp_drain_percent != nullptr)
            remove_bonus(_bonus->_hp_drain_percent);
        add_bonus(b);
        _bonus->_hp_drain_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_drain_value()

void Horizon::Zone::Traits::Status::set_bonus_hp_drain_value ( std::shared_ptr< Bonuses::BonusHPDrainValue > b )

inline

                                                                             {
        if (_bonus->_hp_drain_value != nullptr)
            remove_bonus(_bonus->_hp_drain_value);
        add_bonus(b);
        _bonus->_hp_drain_value = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_gain_on_mob_kill()

void Horizon::Zone::Traits::Status::set_bonus_hp_gain_on_mob_kill ( std::shared_ptr< Bonuses::BonusHPGainOnMobKill > b )

inline

                                                                                     {
        if (_bonus->_hp_gain_on_mob_kill != nullptr)
            remove_bonus(_bonus->_hp_gain_on_mob_kill);
        add_bonus(b);
        _bonus->_hp_gain_on_mob_kill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_recovery_percent()

void Horizon::Zone::Traits::Status::set_bonus_hp_recovery_percent ( std::shared_ptr< Bonuses::BonusHPRecoveryPercent > b )

inline

                                                                                       {
        if (_bonus->_hp_recovery_percent != nullptr)
            remove_bonus(_bonus->_hp_recovery_percent);
        add_bonus(b);
        _bonus->_hp_recovery_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_hp_vanish_percent()

void Horizon::Zone::Traits::Status::set_bonus_hp_vanish_percent ( std::shared_ptr< Bonuses::BonusHPVanishPercent > b )

inline

                                                                                   {
        if (_bonus->_hp_vanish_percent != nullptr)
            remove_bonus(_bonus->_hp_vanish_percent);
        add_bonus(b);
        _bonus->_hp_vanish_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ignore_defense_from_element()

void Horizon::Zone::Traits::Status::set_bonus_ignore_defense_from_element ( std::shared_ptr< Bonuses::BonusIgnoreDefenseFromElement > b )

inline

                                                                                                      {
        if (_bonus->_ignore_defense_from_element != nullptr)
            remove_bonus(_bonus->_ignore_defense_from_element);
        add_bonus(b);
        _bonus->_ignore_defense_from_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ignore_defense_from_race()

void Horizon::Zone::Traits::Status::set_bonus_ignore_defense_from_race ( std::shared_ptr< Bonuses::BonusIgnoreDefenseFromRace > b )

inline

                                                                                                {
        if (_bonus->_ignore_defense_from_race != nullptr)
            remove_bonus(_bonus->_ignore_defense_from_race);
        add_bonus(b);
        _bonus->_ignore_defense_from_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ignore_magic_defense_from_element()

void Horizon::Zone::Traits::Status::set_bonus_ignore_magic_defense_from_element ( std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromElement > b )

inline

                                                                                                                 {
        if (_bonus->_ignore_magic_defense_from_element != nullptr)
            remove_bonus(_bonus->_ignore_magic_defense_from_element);
        add_bonus(b);
        _bonus->_ignore_magic_defense_from_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ignore_magic_defense_from_race()

void Horizon::Zone::Traits::Status::set_bonus_ignore_magic_defense_from_race ( std::shared_ptr< Bonuses::BonusIgnoreMagicDefenseFromRace > b )

inline

                                                                                                           {
        if (_bonus->_ignore_magic_defense_from_race != nullptr)
            remove_bonus(_bonus->_ignore_magic_defense_from_race);
        add_bonus(b);
        _bonus->_ignore_magic_defense_from_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_infinite_endure()

void Horizon::Zone::Traits::Status::set_bonus_infinite_endure ( std::shared_ptr< Bonuses::BonusInfiniteEndure > b )

inline

                                                                                {
        if (_bonus->_infinite_endure != nullptr)
            remove_bonus(_bonus->_infinite_endure);
        add_bonus(b);
        _bonus->_infinite_endure = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_item_usage_immunity()

void Horizon::Zone::Traits::Status::set_bonus_item_usage_immunity ( std::shared_ptr< Bonuses::BonusItemUsageImmunity > b )

inline

                                                                                       {
        if (_bonus->_item_usage_immunity != nullptr)
            remove_bonus(_bonus->_item_usage_immunity);
        add_bonus(b);
        _bonus->_item_usage_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_job_percent_per_race()

void Horizon::Zone::Traits::Status::set_bonus_job_percent_per_race ( std::shared_ptr< Bonuses::BonusJobPercentPerRace > b )

inline

                                                                                        {
        if (_bonus->_job_percent_per_race != nullptr)
            remove_bonus(_bonus->_job_percent_per_race);
        add_bonus(b);
        _bonus->_job_percent_per_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_knock_back_immunity()

void Horizon::Zone::Traits::Status::set_bonus_knock_back_immunity ( std::shared_ptr< Bonuses::BonusKnockBackImmunity > b )

inline

                                                                                       {
        if (_bonus->_knockback_immunity != nullptr)
            remove_bonus(_bonus->_knockback_immunity);
        add_bonus(b);
        _bonus->_knockback_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_learned_skill_heal()

void Horizon::Zone::Traits::Status::set_bonus_learned_skill_heal ( std::shared_ptr< Bonuses::BonusLearnedSkillHeal > b )

inline

                                                                                     {
        if (_bonus->_learned_skill_heal != nullptr)
            remove_bonus(_bonus->_learned_skill_heal);
        add_bonus(b);
        _bonus->_learned_skill_heal = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_long_weapon_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_long_weapon_damage_percent ( std::shared_ptr< Bonuses::BonusLongWeaponDamagePercent > b )

inline

                                                                                                    {
        if (_bonus->_long_weapon_damage_percent != nullptr)
            remove_bonus(_bonus->_long_weapon_damage_percent);
        add_bonus(b);
        _bonus->_long_weapon_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_magic_attack_percent()

void Horizon::Zone::Traits::Status::set_bonus_magic_attack_percent ( std::shared_ptr< Bonuses::BonusMagicAttackPercent > b )

inline

                                                                                         {
        if (_bonus->_magic_attack_percent != nullptr)
            remove_bonus(_bonus->_magic_attack_percent);
        add_bonus(b);
        _bonus->_magic_attack_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_magic_damage_immunity()

void Horizon::Zone::Traits::Status::set_bonus_magic_damage_immunity ( std::shared_ptr< Bonuses::BonusMagicDamageImmunity > b )

inline

                                                                                           {
        if (_bonus->_magic_damage_immunity != nullptr)
            remove_bonus(_bonus->_magic_damage_immunity);
        add_bonus(b);
        _bonus->_magic_damage_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_magic_damage_reduction_against_size()

void Horizon::Zone::Traits::Status::set_bonus_magic_damage_reduction_against_size ( std::shared_ptr< Bonuses::BonusMagicDamageReductionAgainstSize > b )

inline

                                                                                                                     {
        if (_bonus->_magic_damage_reduction_against_size != nullptr)
            remove_bonus(_bonus->_magic_damage_reduction_against_size);
        add_bonus(b);
        _bonus->_magic_damage_reduction_against_size = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_magic_damage_reflect_percent_on_self()

void Horizon::Zone::Traits::Status::set_bonus_magic_damage_reflect_percent_on_self ( std::shared_ptr< Bonuses::BonusMagicDamageReflectPercentOnSelf > b )

inline

                                                                                                                      {
        if (_bonus->_magic_damage_reflect_percent_on_self != nullptr)
            remove_bonus(_bonus->_magic_damage_reflect_percent_on_self);
        add_bonus(b);
        _bonus->_magic_damage_reflect_percent_on_self = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_magic_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_magic_defense_percent ( std::shared_ptr< Bonuses::BonusMagicDefensePercent > b )

inline

                                                                                           {
        if (_bonus->_magic_defense_percent != nullptr)
            remove_bonus(_bonus->_magic_defense_percent);
        add_bonus(b);
        _bonus->_magic_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_max_hp_percent()

void Horizon::Zone::Traits::Status::set_bonus_max_hp_percent ( std::shared_ptr< Bonuses::BonusMaxHPPercent > b )

inline

                                                                             {
        if (_bonus->_max_hp_percent != nullptr)
            remove_bonus(_bonus->_max_hp_percent);
        add_bonus(b);
        _bonus->_max_hp_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_max_sp_percent()

void Horizon::Zone::Traits::Status::set_bonus_max_sp_percent ( std::shared_ptr< Bonuses::BonusMaxSPPercent > b )

inline

                                                                             {
        if (_bonus->_max_sp_percent != nullptr)
            remove_bonus(_bonus->_max_sp_percent);
        add_bonus(b);
        _bonus->_max_sp_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_melee_defense()

void Horizon::Zone::Traits::Status::set_bonus_melee_defense ( std::shared_ptr< Bonuses::BonusMeleeDefense > b )

inline

                                                                            {
        if (_bonus->_melee_defense != nullptr)
            remove_bonus(_bonus->_melee_defense);
        add_bonus(b);
        _bonus->_melee_defense = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_melee_weapon_damage_reflect_percent_on_self()

void Horizon::Zone::Traits::Status::set_bonus_melee_weapon_damage_reflect_percent_on_self ( std::shared_ptr< Bonuses::BonusMeleeWeaponDamageReflectPercentOnSelf > b )

inline

                                                                                                                                   {
        if (_bonus->_melee_weapon_damage_reflect_percent_on_self != nullptr)
            remove_bonus(_bonus->_melee_weapon_damage_reflect_percent_on_self);
        add_bonus(b);
        _bonus->_melee_weapon_damage_reflect_percent_on_self = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_misc_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_misc_defense_percent ( std::shared_ptr< Bonuses::BonusMiscDefensePercent > b )

inline

                                                                                         {
        if (_bonus->_misc_defense_percent != nullptr)
            remove_bonus(_bonus->_misc_defense_percent);
        add_bonus(b);
        _bonus->_misc_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_perfect_dodge_percent()

void Horizon::Zone::Traits::Status::set_bonus_perfect_dodge_percent ( std::shared_ptr< Bonuses::BonusPerfectDodgePercent > b )

inline

                                                                                           {
        if (_bonus->_perfect_dodge_percent != nullptr)
            remove_bonus(_bonus->_perfect_dodge_percent);
        add_bonus(b);
        _bonus->_perfect_dodge_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_perfect_hit_percent()

void Horizon::Zone::Traits::Status::set_bonus_perfect_hit_percent ( std::shared_ptr< Bonuses::BonusPerfectHitPercent > b )

inline

                                                                                       {
        if (_bonus->_perfect_hit_percent != nullptr)
            remove_bonus(_bonus->_perfect_hit_percent);
        add_bonus(b);
        _bonus->_perfect_hit_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_raise()

void Horizon::Zone::Traits::Status::set_bonus_raise ( std::shared_ptr< Bonuses::BonusRaise > b )

inline

                                                             {
        if (_bonus->_raise != nullptr)
            remove_bonus(_bonus->_raise);
        add_bonus(b);
        _bonus->_raise = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ranged_defense()

void Horizon::Zone::Traits::Status::set_bonus_ranged_defense ( std::shared_ptr< Bonuses::BonusRangedDefense > b )

inline

                                                                              {
        if (_bonus->_ranged_defense != nullptr)
            remove_bonus(_bonus->_ranged_defense);
        add_bonus(b);
        _bonus->_ranged_defense = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ranged_weapon_damage_reflect_percent_on_self()

void Horizon::Zone::Traits::Status::set_bonus_ranged_weapon_damage_reflect_percent_on_self ( std::shared_ptr< Bonuses::BonusRangedWeaponDamageReflectPercentOnSelf > b )

inline

                                                                                                                                     {
        if (_bonus->_ranged_weapon_damage_reflect_percent_on_self != nullptr)
            remove_bonus(_bonus->_ranged_weapon_damage_reflect_percent_on_self);
        add_bonus(b);
        _bonus->_ranged_weapon_damage_reflect_percent_on_self = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_reduce_sp_consumption_of_skill()

void Horizon::Zone::Traits::Status::set_bonus_reduce_sp_consumption_of_skill ( std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkill > b )

inline

                                                                                                           {
        if (_bonus->_reduce_sp_consumption_of_skill != nullptr)
            remove_bonus(_bonus->_reduce_sp_consumption_of_skill);
        add_bonus(b);
        _bonus->_reduce_sp_consumption_of_skill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_reduce_sp_consumption_of_skill_by_percent()

void Horizon::Zone::Traits::Status::set_bonus_reduce_sp_consumption_of_skill_by_percent ( std::shared_ptr< Bonuses::BonusReduceSPConsumptionOfSkillByPercent > b )

inline

                                                                                                                               {
        if (_bonus->_reduce_sp_consumption_of_skill_by_percent != nullptr)
            remove_bonus(_bonus->_reduce_sp_consumption_of_skill_by_percent);
        add_bonus(b);
        _bonus->_reduce_sp_consumption_of_skill_by_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_resist_magic_attack_from_race()

void Horizon::Zone::Traits::Status::set_bonus_resist_magic_attack_from_race ( std::shared_ptr< Bonuses::BonusResistMagicAttackFromRace > b )

inline

                                                                                                         {
        if (_bonus->_resist_magic_attack_from_race != nullptr)
            remove_bonus(_bonus->_resist_magic_attack_from_race);
        add_bonus(b);
        _bonus->_resist_magic_attack_from_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_resist_skill_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_resist_skill_damage_percent ( std::shared_ptr< Bonuses::BonusResistSkillDamagePercent > b )

inline

                                                                                                      {
        if (_bonus->_resist_skill_damage_percent != nullptr)
            remove_bonus(_bonus->_resist_skill_damage_percent);
        add_bonus(b);
        _bonus->_resist_skill_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_ressist_effect()

void Horizon::Zone::Traits::Status::set_bonus_ressist_effect ( std::shared_ptr< Bonuses::BonusRessistEffect > b )

inline

                                                                              {
        if (_bonus->_ressist_effect != nullptr)
            remove_bonus(_bonus->_ressist_effect);
        add_bonus(b);
        _bonus->_ressist_effect = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_restart_with_full_recovery()

void Horizon::Zone::Traits::Status::set_bonus_restart_with_full_recovery ( std::shared_ptr< Bonuses::BonusRestartWithFullRecovery > b )

inline

                                                                                                    {
        if (_bonus->_restart_with_full_recovery != nullptr)
            remove_bonus(_bonus->_restart_with_full_recovery);
        add_bonus(b);
        _bonus->_restart_with_full_recovery = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_short_weapon_damage_percent()

void Horizon::Zone::Traits::Status::set_bonus_short_weapon_damage_percent ( std::shared_ptr< Bonuses::BonusShortWeaponDamagePercent > b )

inline

                                                                                                      {
        if (_bonus->_short_weapon_damage_percent != nullptr)
            remove_bonus(_bonus->_short_weapon_damage_percent);
        add_bonus(b);
        _bonus->_short_weapon_damage_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_size_modifier_immunity()

void Horizon::Zone::Traits::Status::set_bonus_size_modifier_immunity ( std::shared_ptr< Bonuses::BonusSizeModifierImmunity > b )

inline

                                                                                             {
        if (_bonus->_size_modifier_immunity != nullptr)
            remove_bonus(_bonus->_size_modifier_immunity);
        add_bonus(b);
        _bonus->_size_modifier_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_attack()

void Horizon::Zone::Traits::Status::set_bonus_skill_attack ( std::shared_ptr< Bonuses::BonusSkillAttack > b )

inline

                                                                          {
        if (_bonus->_skill_attack != nullptr)
            remove_bonus(_bonus->_skill_attack);
        add_bonus(b);
        _bonus->_skill_attack = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_cast_percent()

void Horizon::Zone::Traits::Status::set_bonus_skill_cast_percent ( std::shared_ptr< Bonuses::BonusSkillCastPercent > b )

inline

                                                                                     {
        if (_bonus->_skill_cast_percent != nullptr)
            remove_bonus(_bonus->_skill_cast_percent);
        add_bonus(b);
        _bonus->_skill_cast_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_cooldown()

void Horizon::Zone::Traits::Status::set_bonus_skill_cooldown ( std::shared_ptr< Bonuses::BonusSkillCooldown > b )

inline

                                                                              {
        if (_bonus->_skill_cooldown != nullptr)
            remove_bonus(_bonus->_skill_cooldown);
        add_bonus(b);
        _bonus->_skill_cooldown = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_fix_cast_percent()

void Horizon::Zone::Traits::Status::set_bonus_skill_fix_cast_percent ( std::shared_ptr< Bonuses::BonusSkillFixCastPercent > b )

inline

                                                                                            {
        if (_bonus->_skill_fix_cast_percent != nullptr)
            remove_bonus(_bonus->_skill_fix_cast_percent);
        add_bonus(b);
        _bonus->_skill_fix_cast_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_knockback()

void Horizon::Zone::Traits::Status::set_bonus_skill_knockback ( std::shared_ptr< Bonuses::BonusSkillKnockback > b )

inline

                                                                                {
        if (_bonus->_skill_knockback != nullptr)
            remove_bonus(_bonus->_skill_knockback);
        add_bonus(b);
        _bonus->_skill_knockback = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_skill_variable_cast_percent()

void Horizon::Zone::Traits::Status::set_bonus_skill_variable_cast_percent ( std::shared_ptr< Bonuses::BonusSkillVariableCastPercent > b )

inline

                                                                                                      {
        if (_bonus->_skill_variable_cast_percent != nullptr)
            remove_bonus(_bonus->_skill_variable_cast_percent);
        add_bonus(b);
        _bonus->_skill_variable_cast_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_soft_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_soft_defense_percent ( std::shared_ptr< Bonuses::BonusSoftDefensePercent > b )

inline

                                                                                         {
        if (_bonus->_soft_defense_percent != nullptr)
            remove_bonus(_bonus->_soft_defense_percent);
        add_bonus(b);
        _bonus->_soft_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_soft_magical_defense_percent()

void Horizon::Zone::Traits::Status::set_bonus_soft_magical_defense_percent ( std::shared_ptr< Bonuses::BonusSoftMagicalDefensePercent > b )

inline

                                                                                                        {
        if (_bonus->_soft_magical_defense_percent != nullptr)
            remove_bonus(_bonus->_soft_magical_defense_percent);
        add_bonus(b);
        _bonus->_soft_magical_defense_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_drain_on_monster_kill()

void Horizon::Zone::Traits::Status::set_bonus_sp_drain_on_monster_kill ( std::shared_ptr< Bonuses::BonusSPDrainOnMonsterKill > b )

inline

                                                                                               {
        if (_bonus->_sp_drain_on_monster_kill != nullptr)
            remove_bonus(_bonus->_sp_drain_on_monster_kill);
        add_bonus(b);
        _bonus->_sp_drain_on_monster_kill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_drain_percent()

void Horizon::Zone::Traits::Status::set_bonus_sp_drain_percent ( std::shared_ptr< Bonuses::BonusSPDrainPercent > b )

inline

                                                                                 {
        if (_bonus->_sp_drain_percent != nullptr)
            remove_bonus(_bonus->_sp_drain_percent);
        add_bonus(b);
        _bonus->_sp_drain_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_drain_value()

void Horizon::Zone::Traits::Status::set_bonus_sp_drain_value ( std::shared_ptr< Bonuses::BonusSPDrainValue > b )

inline

                                                                             {
        if (_bonus->_bonus_sp_drain_value != nullptr)
            remove_bonus(_bonus->_bonus_sp_drain_value);
        add_bonus(b);
        _bonus->_bonus_sp_drain_value = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_gain_on_mob_kill()

void Horizon::Zone::Traits::Status::set_bonus_sp_gain_on_mob_kill ( std::shared_ptr< Bonuses::BonusSPGainOnMobKill > b )

inline

                                                                                     {
        if (_bonus->_sp_gain_on_mob_kill != nullptr)
            remove_bonus(_bonus->_sp_gain_on_mob_kill);
        add_bonus(b);
        _bonus->_sp_gain_on_mob_kill = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_percent()

void Horizon::Zone::Traits::Status::set_bonus_sp_percent ( std::shared_ptr< Bonuses::BonusSPPercent > b )

inline

                                                                      {
        if (_bonus->_sp_percent != nullptr)
            remove_bonus(_bonus->_sp_percent);
        add_bonus(b);
        _bonus->_sp_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_recovery_percent()

void Horizon::Zone::Traits::Status::set_bonus_sp_recovery_percent ( std::shared_ptr< Bonuses::BonusSPRecoveryPercent > b )

inline

                                                                                       {
        if (_bonus->_sp_recovery_percent != nullptr)
            remove_bonus(_bonus->_sp_recovery_percent);
        add_bonus(b);
        _bonus->_sp_recovery_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sp_vanish_percent()

void Horizon::Zone::Traits::Status::set_bonus_sp_vanish_percent ( std::shared_ptr< Bonuses::BonusSPVanishPercent > b )

inline

                                                                                   {
        if (_bonus->_sp_vanish_percent != nullptr)
            remove_bonus(_bonus->_sp_vanish_percent);
        add_bonus(b);
        _bonus->_sp_vanish_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sub_attack_percentage_from_element()

void Horizon::Zone::Traits::Status::set_bonus_sub_attack_percentage_from_element ( std::shared_ptr< Bonuses::BonusSubAttackPercentageFromElement > b )

inline

                                                                                                                   {
        if (_bonus->_sub_attack_percentage_from_element != nullptr)
            remove_bonus(_bonus->_sub_attack_percentage_from_element);
        add_bonus(b);
        _bonus->_sub_attack_percentage_from_element = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_sub_attack_percentage_from_race()

void Horizon::Zone::Traits::Status::set_bonus_sub_attack_percentage_from_race ( std::shared_ptr< Bonuses::BonusSubAttackPercentageFromRace > b )

inline

                                                                                                             {
        if (_bonus->_sub_attack_percentage_from_race != nullptr)
            remove_bonus(_bonus->_sub_attack_percentage_from_race);
        add_bonus(b);
        _bonus->_sub_attack_percentage_from_race = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_unbreakable_armor()

void Horizon::Zone::Traits::Status::set_bonus_unbreakable_armor ( std::shared_ptr< Bonuses::BonusUnbreakableArmor > b )

inline

                                                                                    {
        if (_bonus->_unbreakable_armor != nullptr)
            remove_bonus(_bonus->_unbreakable_armor);
        add_bonus(b);
        _bonus->_unbreakable_armor = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_unbreakable_helm()

void Horizon::Zone::Traits::Status::set_bonus_unbreakable_helm ( std::shared_ptr< Bonuses::BonusUnbreakableHelm > b )

inline

                                                                                  {
        if (_bonus->_unbreakable_helm != nullptr)
            remove_bonus(_bonus->_unbreakable_helm);
        add_bonus(b);
        _bonus->_unbreakable_helm = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_unbreakable_shield()

void Horizon::Zone::Traits::Status::set_bonus_unbreakable_shield ( std::shared_ptr< Bonuses::BonusUnbreakableShield > b )

inline

                                                                                      {
        if (_bonus->_unbreakable_shield != nullptr)
            remove_bonus(_bonus->_unbreakable_shield);
        add_bonus(b);
        _bonus->_unbreakable_shield = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_unbreakable_weapon()

void Horizon::Zone::Traits::Status::set_bonus_unbreakable_weapon ( std::shared_ptr< Bonuses::BonusUnbreakableWeapon > b )

inline

                                                                                      {
        if (_bonus->_unbreakable_weapon != nullptr)
            remove_bonus(_bonus->_unbreakable_weapon);
        add_bonus(b);
        _bonus->_unbreakable_weapon = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_weapon_break_percent()

void Horizon::Zone::Traits::Status::set_bonus_weapon_break_percent ( std::shared_ptr< Bonuses::BonusWeaponBreakPercent > b )

inline

                                                                                         {
        if (_bonus->_weapon_break_percent != nullptr)
            remove_bonus(_bonus->_weapon_break_percent);
        add_bonus(b);
        _bonus->_weapon_break_percent = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_bonus_weapon_damage_immunity()

void Horizon::Zone::Traits::Status::set_bonus_weapon_damage_immunity ( std::shared_ptr< Bonuses::BonusWeaponDamageImmunity > b )

inline

                                                                                             {
        if (_bonus->_weapon_damage_immunity != nullptr)
            remove_bonus(_bonus->_weapon_damage_immunity);
        add_bonus(b);
        _bonus->_weapon_damage_immunity = b;
    }

References _bonus, add_bonus(), and remove_bonus().

Here is the call graph for this function:

◆ set_cloth_color()

void Horizon::Zone::Traits::Status::set_cloth_color ( std::shared_ptr< ClothColor > cc )

inline

537{ add_appearance(cc); _cloth_color = cc; }

References _cloth_color, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_attack_damage()

void Horizon::Zone::Traits::Status::set_creature_attack_damage ( std::shared_ptr< MobAttackDamage > m )

inline

                                                                      {
        if (_creature_attack_damage != nullptr)
            remove_attribute(_creature_attack_damage);
        add_attribute(m);
        _creature_attack_damage = m;
    }

References _creature_attack_damage, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_chase_range()

void Horizon::Zone::Traits::Status::set_creature_chase_range ( std::shared_ptr< MobChaseRange > m )

inline

                                                                  {
        if (_creature_chase_range != nullptr)
            remove_attribute(_creature_chase_range);
        add_attribute(m);
        _creature_chase_range = m;
    }

References _creature_chase_range, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_element()

void Horizon::Zone::Traits::Status::set_creature_element ( std::shared_ptr< MobElement > m )

inline

                                                           {
        if (_creature_element != nullptr)
            remove_attribute(_creature_element);
        add_attribute(m);
        _creature_element = m;
    }

References _creature_element, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_element_level()

void Horizon::Zone::Traits::Status::set_creature_element_level ( std::shared_ptr< MobElementLevel > m )

inline

                                                                      {
        if (_creature_element_level != nullptr)
            remove_attribute(_creature_element_level);
        add_attribute(m);
        _creature_element_level = m;
    }

References _creature_element_level, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_magic_attack_damage()

void Horizon::Zone::Traits::Status::set_creature_magic_attack_damage ( std::shared_ptr< MobMagicAttackDamage > m )

inline

                                                                                 {
        if (_creature_magic_attack_damage != nullptr)
            remove_attribute(_creature_magic_attack_damage);
        add_attribute(m);
        _creature_magic_attack_damage = m;
    }

References _creature_magic_attack_damage, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_mode()

void Horizon::Zone::Traits::Status::set_creature_mode ( std::shared_ptr< MobMode > m )

inline

                                                     {
        if (_creature_mode != nullptr)
            remove_attribute(_creature_mode);
        add_attribute(m);
        _creature_mode = m;
    }

References _creature_mode, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_primary_race()

void Horizon::Zone::Traits::Status::set_creature_primary_race ( std::shared_ptr< MobPrimaryRace > m )

inline

                                                                    {
        if (_creature_primary_race != nullptr)
            remove_attribute(_creature_primary_race);
        add_attribute(m);
        _creature_primary_race = m;
    }

References _creature_primary_race, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_secondary_race()

void Horizon::Zone::Traits::Status::set_creature_secondary_race ( std::shared_ptr< MobSecondaryRace > m )

inline

                                                                        {
        if (_creature_secondary_race != nullptr)
            remove_attribute(_creature_secondary_race);
        add_attribute(m);
        _creature_secondary_race = m;
    }

References _creature_secondary_race, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_view_range()

void Horizon::Zone::Traits::Status::set_creature_view_range ( std::shared_ptr< MobViewRange > m )

inline

                                                                {
        if (_creature_view_range != nullptr)
            remove_attribute(_creature_view_range);
        add_attribute(m);
        _creature_view_range = m;
    }

References _creature_view_range, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_weapon_attack()

void Horizon::Zone::Traits::Status::set_creature_weapon_attack ( std::shared_ptr< MobWeaponAttack > m )

inline

                                                                      {
        if (_creature_weapon_attack != nullptr)
            remove_attribute(_creature_weapon_attack);
        add_attribute(m);
        _creature_weapon_attack = m;
    }

References _creature_weapon_attack, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_creature_weapon_attack_magic()

void Horizon::Zone::Traits::Status::set_creature_weapon_attack_magic ( std::shared_ptr< MobWeaponAttack > m )

inline

                                                                            {
        if (_creature_weapon_attack_magic != nullptr)
            remove_attribute(_creature_weapon_attack_magic);
        add_attribute(m);
        _creature_weapon_attack_magic = m;
    }

References _creature_weapon_attack_magic, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_crit()

void Horizon::Zone::Traits::Status::set_crit ( std::shared_ptr< CRIT > crit )

inline

                                            {
        if (_crit != nullptr)
            remove_attribute(_crit);
        add_attribute(crit);
        _crit = crit;
    }

References _crit, add_attribute(), crit(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_current_hp()

void Horizon::Zone::Traits::Status::set_current_hp ( std::shared_ptr< CurrentHP > hp )

inline

                                                     {
        if (_current_hp != nullptr)
            remove_attribute(_current_hp);
        add_attribute(hp);
        _current_hp = hp;
    }

References _current_hp, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_current_sp()

void Horizon::Zone::Traits::Status::set_current_sp ( std::shared_ptr< CurrentSP > sp )

inline

                                                     {
        if (_current_sp != nullptr)
            remove_attribute(_current_sp);
        add_attribute(sp);
        _current_sp = sp;
    }

References _current_sp, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_current_weight()

void Horizon::Zone::Traits::Status::set_current_weight ( std::shared_ptr< CurrentWeight > cw )

inline

                                                             {
        if (_current_weight != nullptr)
            remove_attribute(_current_weight);
        add_attribute(cw);
        _current_weight = cw;
    }

References _current_weight, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_damage_walk_delay()

void Horizon::Zone::Traits::Status::set_damage_walk_delay ( std::shared_ptr< DamageWalkDelay > m )

inline

                                                                 {
        if (_damage_walk_delay != nullptr)
            remove_attribute(_damage_walk_delay);
        add_attribute(m);
        _damage_walk_delay = m;
    } 

References _damage_walk_delay, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dexterity()

void Horizon::Zone::Traits::Status::set_dexterity ( std::shared_ptr< Dexterity > dex )

inline

                                                     {
        if (_dex != nullptr)
            remove_attribute(_dex);
        add_attribute(dex);
        _dex = dex;
    }

References _dex, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dexterity_cost()

void Horizon::Zone::Traits::Status::set_dexterity_cost ( std::shared_ptr< DexterityPointCost > dex )

inline

                                                                   {
        if (_dex_cost != nullptr)
            remove_attribute(_dex_cost);
        add_attribute(dex);
        _dex_cost = dex;
    }

References _dex_cost, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_equip_atk()

void Horizon::Zone::Traits::Status::set_equip_atk ( std::shared_ptr< EquipATK > eatk )

inline

                                                     {
        if (_equip_atk != nullptr)
            remove_attribute(_equip_atk);
        add_attribute(eatk);
        _equip_atk = eatk;
    }

References _equip_atk, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_equip_matk()

void Horizon::Zone::Traits::Status::set_equip_matk ( std::shared_ptr< EquipMATK > ematk )

inline

                                                        {
        if (_equip_matk != nullptr)
            remove_attribute(_equip_matk);
        add_attribute(ematk);
        _equip_matk = ematk;
    }

References _equip_matk, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_flee()

void Horizon::Zone::Traits::Status::set_flee ( std::shared_ptr< FLEE > flee )

inline

                                            {
        if (_flee != nullptr)
            remove_attribute(_flee);
        add_attribute(flee);
        _flee = flee;
    }

References _flee, add_attribute(), flee(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hair_color()

void Horizon::Zone::Traits::Status::set_hair_color ( std::shared_ptr< HairColor > hc )

inline

534{ add_appearance(hc); _hair_color = hc; }

References _hair_color, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hair_style()

void Horizon::Zone::Traits::Status::set_hair_style ( std::shared_ptr< HairStyle > hs )

inline

558{ add_appearance(hs); _hair_style = hs; }

References _hair_style, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hard_def()

void Horizon::Zone::Traits::Status::set_hard_def ( std::shared_ptr< HardDEF > hdef )

inline

                                                   {
        if (_hard_def != nullptr)
            remove_attribute(_hard_def);
        add_attribute(hdef);
        _hard_def = hdef;
    }

References _hard_def, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hard_mdef()

void Horizon::Zone::Traits::Status::set_hard_mdef ( std::shared_ptr< HardMDEF > hmdef )

inline

                                                      {
        if (_hard_mdef != nullptr)
            remove_attribute(_hard_mdef);
        add_attribute(hmdef);
        _hard_mdef = hmdef;
    }

References _hard_mdef, add_attribute(), and remove_attribute().

Here is the call graph for this function:

◆ set_head_bottom_sprite()

void Horizon::Zone::Traits::Status::set_head_bottom_sprite ( std::shared_ptr< HeadBottomSprite > hbs )

inline

555{ add_appearance(hbs); _head_bottom_sprite = hbs; }

References _head_bottom_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_head_mid_sprite()

void Horizon::Zone::Traits::Status::set_head_mid_sprite ( std::shared_ptr< HeadMidSprite > hms )

inline

552{ add_appearance(hms); _head_mid_sprite = hms; }

References _head_mid_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_head_top_sprite()

void Horizon::Zone::Traits::Status::set_head_top_sprite ( std::shared_ptr< HeadTopSprite > hts )

inline

549{ add_appearance(hts); _head_top_sprite = hts; }

References _head_top_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hit()

void Horizon::Zone::Traits::Status::set_hit ( std::shared_ptr< HIT > hit )

inline

                                         {
        if (_hit != nullptr)
            remove_attribute(_hit);
        add_attribute(hit);
        _hit = hit;
    }

References _hit, add_attribute(), hit(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_honor()

void Horizon::Zone::Traits::Status::set_honor ( std::shared_ptr< Honor > h )

inline

                                           {
        if (_honor != nullptr)
            remove_attribute(_honor);
        add_attribute(h);
        _honor = h;
    }

References _honor, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hp_regeneration()

void Horizon::Zone::Traits::Status::set_hp_regeneration ( std::shared_ptr< HPRegeneration > hpr )

inline

                                                                {
        if (_hp_regeneration != nullptr)
            remove_attribute(_hp_regeneration);
        add_attribute(hpr);
        _hp_regeneration = hpr;
    }

References _hp_regeneration, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_initialized()

void Horizon::Zone::Traits::Status::set_initialized ( bool b )

inline

746{ _is_initialized = b; }

References _is_initialized.

Referenced by initialize().

Here is the caller graph for this function:

◆ set_intelligence()

void Horizon::Zone::Traits::Status::set_intelligence ( std::shared_ptr< Intelligence > int_ )

inline

                                                            {
        if (_int != nullptr)
            remove_attribute(_int);
        add_attribute(int_);
        _int = int_;
    }

References _int, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_intelligence_cost()

void Horizon::Zone::Traits::Status::set_intelligence_cost ( std::shared_ptr< IntelligencePointCost > int_ )

inline

                                                                          {
        if (_int_cost != nullptr)
            remove_attribute(_int_cost);
        add_attribute(int_);
        _int_cost = int_;
    }

References _int_cost, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_job_experience()

void Horizon::Zone::Traits::Status::set_job_experience ( std::shared_ptr< JobExperience > jexp )

inline

                                                               {
        if (_job_exp != nullptr)
            remove_attribute(_job_exp);
        add_attribute(jexp);
        _job_exp = jexp;
    }

References _job_exp, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_job_level()

void Horizon::Zone::Traits::Status::set_job_level ( std::shared_ptr< JobLevel > jlvl )

inline

                                                     {
        if (_job_level != nullptr)
            remove_attribute(_job_level);
        add_attribute(jlvl);
        _job_level = jlvl;
    }

References _job_level, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_luck()

void Horizon::Zone::Traits::Status::set_luck ( std::shared_ptr< Luck > luck )

inline

                                            {
        if (_luk != nullptr)
            remove_attribute(_luk);
        add_attribute(luck);
        _luk = luck;
    }

References _luk, add_attribute(), luck(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_luck_cost()

void Horizon::Zone::Traits::Status::set_luck_cost ( std::shared_ptr< LuckPointCost > luck )

inline

                                                          {
        if (_luk_cost != nullptr)
            remove_attribute(_luk_cost);
        add_attribute(luck);
        _luk_cost = luck;
    }

References _luk_cost, add_attribute(), luck(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_manner()

void Horizon::Zone::Traits::Status::set_manner ( std::shared_ptr< Manner > m )

inline

                                             {
        if (_manner != nullptr)
            remove_attribute(_manner);
        add_attribute(m);
        _manner = m;
    }

References _manner, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_max_hp()

void Horizon::Zone::Traits::Status::set_max_hp ( std::shared_ptr< MaxHP > max_hp )

inline

                                                 {
        if (_max_hp != nullptr)
            remove_attribute(_max_hp);
        add_attribute(max_hp);
        _max_hp = max_hp;
    }

References _max_hp, add_attribute(), max_hp(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_max_sp()

void Horizon::Zone::Traits::Status::set_max_sp ( std::shared_ptr< MaxSP > max_sp )

inline

                                                 {
        if (_max_sp != nullptr)
            remove_attribute(_max_sp);
        add_attribute(max_sp);
        _max_sp = max_sp;
    }

References _max_sp, add_attribute(), max_sp(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_max_weight()

void Horizon::Zone::Traits::Status::set_max_weight ( std::shared_ptr< MaxWeight > mw )

inline

                                                     {
        if (_max_weight != nullptr)
            remove_attribute(_max_weight);
        add_attribute(mw);
        _max_weight = mw;
    }

References _max_weight, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_movement_speed()

void Horizon::Zone::Traits::Status::set_movement_speed ( std::shared_ptr< MovementSpeed > speed )

inline

                                                                {
        if (_movement_speed != nullptr)
            remove_attribute(_movement_speed);
        add_attribute(speed);
        _movement_speed = speed;
    }

References _movement_speed, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_next_base_experience()

void Horizon::Zone::Traits::Status::set_next_base_experience ( std::shared_ptr< NextBaseExperience > nbexp )

inline

                                                                           {
        if (_next_base_exp != nullptr)
            remove_attribute(_next_base_exp);
        add_attribute(nbexp);
        _next_base_exp = nbexp;
    }

References _next_base_exp, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_next_job_experience()

void Horizon::Zone::Traits::Status::set_next_job_experience ( std::shared_ptr< NextJobExperience > njexp )

inline

                                                                         {
        if (_next_job_exp != nullptr)
            remove_attribute(_next_job_exp);
        add_attribute(njexp);
        _next_job_exp = njexp;
    }

References _next_job_exp, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_robe_sprite()

void Horizon::Zone::Traits::Status::set_robe_sprite ( std::shared_ptr< RobeSprite > rs )

inline

546{ add_appearance(rs); _robe_sprite = rs; }

References _robe_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_shield_sprite()

void Horizon::Zone::Traits::Status::set_shield_sprite ( std::shared_ptr< ShieldSprite > ss )

inline

543{ add_appearance(ss); _shield_sprite = ss; }

Horizon::Zone::Traits::Status::_shield_sprite

std::shared_ptr< ShieldSprite > _shield_sprite

Definition: Status.hpp:1841

References _shield_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_size()

void Horizon::Zone::Traits::Status::set_size ( std::shared_ptr< UnitSize > s )

inline

                                             {
        if (_size != nullptr)
            remove_attribute(_size);
        add_attribute(s);
        _size = s;
    }

References _size, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_skill_point()

void Horizon::Zone::Traits::Status::set_skill_point ( std::shared_ptr< SkillPoint > sk )

inline

                                                       {
        if (_skill_point != nullptr)
            remove_attribute(_skill_point);
        add_attribute(sk);
        _skill_point = sk;
    }

References _skill_point, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_soft_def()

void Horizon::Zone::Traits::Status::set_soft_def ( std::shared_ptr< SoftDEF > sdef )

inline

                                                   {
        if (_soft_def != nullptr)
            remove_attribute(_soft_def);
        add_attribute(sdef);
        _soft_def = sdef;
    }

References _soft_def, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_soft_mdef()

void Horizon::Zone::Traits::Status::set_soft_mdef ( std::shared_ptr< SoftMDEF > smdef )

inline

                                                      {
        if (_soft_mdef != nullptr)
            remove_attribute(_soft_mdef);
        add_attribute(smdef);
        _soft_mdef = smdef;
    }

References _soft_mdef, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_sp_regeneration()

void Horizon::Zone::Traits::Status::set_sp_regeneration ( std::shared_ptr< SPRegeneration > spr )

inline

                                                                {
        if (_sp_regeneration != nullptr)
            remove_attribute(_sp_regeneration);
        add_attribute(spr);
        _sp_regeneration = spr;
    }

References _sp_regeneration, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_status_atk()

void Horizon::Zone::Traits::Status::set_status_atk ( std::shared_ptr< StatusATK > satk )

inline

                                                       {
        if (_status_atk != nullptr)
            remove_attribute(_status_atk);
        add_attribute(satk);
        _status_atk = satk;
    }

References _status_atk, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_status_matk()

void Horizon::Zone::Traits::Status::set_status_matk ( std::shared_ptr< StatusMATK > smatk )

inline

                                                          {
        if (_status_matk != nullptr)
            remove_attribute(_status_matk);
        add_attribute(smatk);
        _status_matk = smatk;
    }

References _status_matk, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_status_point()

void Horizon::Zone::Traits::Status::set_status_point ( std::shared_ptr< StatusPoint > st )

inline

                                                         {
        if (_status_point != nullptr)
            remove_attribute(_status_point);
        add_attribute(st);
        _status_point = st;
    }

References _status_point, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_strength()

void Horizon::Zone::Traits::Status::set_strength ( std::shared_ptr< Strength > str )

inline

                                                   {
        if (_str != nullptr)
            remove_attribute(_str);
        add_attribute(str);
        _str = str;
    }

References _str, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_strength_cost()

void Horizon::Zone::Traits::Status::set_strength_cost ( std::shared_ptr< StrengthPointCost > str )

inline

                                                                 {
        if (_str_cost != nullptr)
            remove_attribute(_str_cost);
        add_attribute(str);
        _str_cost = str;
    }

References _str_cost, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_virtue()

void Horizon::Zone::Traits::Status::set_virtue ( std::shared_ptr< Virtue > v )

inline

                                             {
        if (_virtue != nullptr)
            remove_attribute(_virtue);
        add_attribute(v);
        _virtue = v;
    }

References _virtue, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_vitality()

void Horizon::Zone::Traits::Status::set_vitality ( std::shared_ptr< Vitality > vit )

inline

                                                   {
        if (_vit != nullptr)
            remove_attribute(_vit);
        add_attribute(vit);
        _vit = vit;
    }

References _vit, add_attribute(), and remove_attribute().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_vitality_cost()

void Horizon::Zone::Traits::Status::set_vitality_cost ( std::shared_ptr< VitalityPointCost > vit )

inline

                                                                 {
        if (_vit_cost != nullptr)
            remove_attribute(_vit_cost);
        add_attribute(vit);
        _vit_cost = vit;
    }

References _vit_cost, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_weapon_attack_combined()

void Horizon::Zone::Traits::Status::set_weapon_attack_combined ( std::shared_ptr< WeaponAttackCombined > w )

inline

                                                                           {
        if (_weapon_attack_combined != nullptr)
            remove_attribute(_weapon_attack_combined);
        add_attribute(w);
        _weapon_attack_combined = w;
    }

References _weapon_attack_combined, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_weapon_attack_left()

void Horizon::Zone::Traits::Status::set_weapon_attack_left ( std::shared_ptr< WeaponAttackLeft > w )

inline

                                                                   {
        if (_weapon_attack_left != nullptr)
            remove_attribute(_weapon_attack_left);
        add_attribute(w);
        _weapon_attack_left = w;
    }

References _weapon_attack_left, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_weapon_attack_right()

void Horizon::Zone::Traits::Status::set_weapon_attack_right ( std::shared_ptr< WeaponAttackRight > w )

inline

                                                                     {
        if (_weapon_attack_right != nullptr)
            remove_attribute(_weapon_attack_right);
        add_attribute(w);
        _weapon_attack_right = w;
    }

References _weapon_attack_right, add_attribute(), and remove_attribute().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_weapon_sprite()

void Horizon::Zone::Traits::Status::set_weapon_sprite ( std::shared_ptr< WeaponSprite > ws )

inline

540{ add_appearance(ws); _weapon_sprite = ws; }

Horizon::Zone::Traits::Status::_weapon_sprite

std::shared_ptr< WeaponSprite > _weapon_sprite

Definition: Status.hpp:1840

References _weapon_sprite, and add_appearance().

Referenced by initialize(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_zeny()

void Horizon::Zone::Traits::Status::set_zeny ( std::shared_ptr< Zeny > z )

inline

                                         {
        if (_zeny != nullptr)
            remove_attribute(_zeny);
        add_attribute(z);
        _zeny = z;
    }

References _zeny, add_attribute(), and remove_attribute().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shield_sprite()

std::shared_ptr< ShieldSprite > Horizon::Zone::Traits::Status::shield_sprite ( )

inline

542{ return _shield_sprite; }

References _shield_sprite.

Referenced by on_equipment_changed(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ size()

std::shared_ptr< UnitSize > Horizon::Zone::Traits::Status::size ( )

inline

646{ return _size; }

References _size.

◆ skill_point()

std::shared_ptr< SkillPoint > Horizon::Zone::Traits::Status::skill_point ( )

inline

292{ return _skill_point; }

References _skill_point.

Referenced by initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ soft_def()

std::shared_ptr< SoftDEF > Horizon::Zone::Traits::Status::soft_def ( )

inline

447{ return _soft_def; }

References _soft_def.

Referenced by initialize().

Here is the caller graph for this function:

◆ soft_mdef()

std::shared_ptr< SoftMDEF > Horizon::Zone::Traits::Status::soft_mdef ( )

inline

463{ return _soft_mdef; }

References _soft_mdef.

Referenced by initialize().

Here is the caller graph for this function:

◆ sp_regeneration()

std::shared_ptr< SPRegeneration > Horizon::Zone::Traits::Status::sp_regeneration ( )

inline

519{ return _sp_regeneration; }

References _sp_regeneration.

Referenced by initialize().

Here is the caller graph for this function:

◆ status_atk()

std::shared_ptr< StatusATK > Horizon::Zone::Traits::Status::status_atk ( )

inline

SubAttributes.

415{ return _status_atk; }

References _status_atk.

Referenced by initialize(), and on_equipment_changed().

Here is the caller graph for this function:

◆ status_matk()

std::shared_ptr< StatusMATK > Horizon::Zone::Traits::Status::status_matk ( )

inline

431{ return _status_matk; }

References _status_matk.

Referenced by initialize().

Here is the caller graph for this function:

◆ status_point()

std::shared_ptr< StatusPoint > Horizon::Zone::Traits::Status::status_point ( )

inline

284{ return _status_point; }

References _status_point.

Referenced by increase_status_point(), initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ status_registry()

std::shared_ptr< StatusRegistry > Horizon::Zone::Traits::Status::status_registry ( )

inline

743{ return _status_registry; }

References _status_registry.

◆ strength()

std::shared_ptr< Strength > Horizon::Zone::Traits::Status::strength ( )

inline

Attributes.

188{ return _str; }

References _str.

Referenced by get_status_base(), increase_status_point(), initialize(), save(), and Horizon::Zone::UnitComponent::sync_data_types().

Here is the caller graph for this function:

◆ strength_cost()

std::shared_ptr< StrengthPointCost > Horizon::Zone::Traits::Status::strength_cost ( )

inline

236{ return _str_cost; }

References _str_cost.

Referenced by increase_status_point(), and initialize().

Here is the caller graph for this function:

◆ unit()

std::shared_ptr< Unit > Horizon::Zone::Traits::Status::unit ( )

inlineprotected

1785{ return _unit.lock(); }

References _unit.

◆ update()

bool Status::update ( uint64_t delta )

{
    if (!is_initialized()) {
        return false;
    }
 
    bool recalculate = false;
    // Update all attributes in the list.
    // When a change is made in the list of temporary, permanent and interval changes, the attribute requires a recalculation?
    for (auto i : _attributes) {
        i->update(delta);
        if (i->needs_recalculation())
            recalculate = true;
    }
 
    if (recalculate)
        this->recalculate();
 
    return true;
}