void Player::UpdateBlockPercentage() { // No block float value = 0.0f; if (CanBlock()) { // Base value value = 5.0f; // Modify value from defense skill value += (int32(GetDefenseSkillValue()) - int32(GetMaxSkillValueForLevel())) * 0.04f; // Increase from SPELL_AURA_MOD_BLOCK_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT); // Increase from rating value += GetRatingBonusValue(CR_BLOCK); value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_BLOCK_PERCENTAGE, value); }
void Player::UpdateParryPercentage() { // No parry float value = 0.0f; if (CanParry()) { // Base parry value = 5.0f; // Modify value from defense skill value += (int32(GetDefenseSkillValue()) - int32(GetMaxSkillValueForLevel())) * 0.04f; // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // Parry from rating value += GetRatingBonusValue(CR_PARRY); value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value); }
void Player::UpdateDodgePercentage() { static const float dodge_cap[MAX_CLASSES] = { 88.129021f, // Warrior 88.129021f, // Paladin 145.560408f, // Hunter 145.560408f, // Rogue 150.375940f, // Priest 88.129021f, // DK 145.560408f, // Shaman 150.375940f, // Mage 150.375940f, // Warlock 0.0f, // ?? 116.890707f // Druid }; static const float k[MAX_CLASSES] = { 0.9560f, // Warrior 0.9560f, // Paladin 0.9880f, // Hunter 0.9880f, // Rogue 0.9830f, // Priest 0.9560f, // DK 0.9880f, // Shaman 0.9830f, // Mage 0.9830f, // Warlock 0.0f, // ?? 0.9720f // Druid }; float diminishing = 0.f, nondiminishing = 0.f; // Dodge from agility GetDodgeFromAgility(diminishing, nondiminishing); // Modify value from defense skill nondiminishing += (GetSkillValue(SKILL_DEFENSE) - GetMaxSkillValueForLevel()) * 0.04f; diminishing += (int32(GetRatingBonusValue(CR_DEFENSE_SKILL))) * 0.04f; // Dodge from SPELL_AURA_MOD_DODGE_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT); // Dodge from rating diminishing += GetRatingBonusValue(CR_DODGE); // apply diminishing formula to diminishing dodge uint32 pclass = getClass()-1; float value = nondiminishing + (diminishing*dodge_cap[pclass] / (diminishing + dodge_cap[pclass]*k[pclass])); value = value < 0.0f ? 0.0f : value; SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, value); }
void Player::UpdateBlockPercentage() { float value = 0.0f; float real = 0.0f; if (CanBlock()) { // Base value value = 5.0f; // Increase from SPELL_AURA_MOD_BLOCK_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT); // Increase from rating value += GetRatingBonusValue(CR_BLOCK); real = value; // Set UI display value: modify value from defense skill against same level target value += (int32(GetDefenseSkillValue()) - int32(GetSkillMaxForLevel())) * 0.04f; } m_modBlockChance = real; SetStatFloatValue(PLAYER_BLOCK_PERCENTAGE, std::max(0.0f, std::min(value, 100.0f))); }
void Player::UpdateDodgePercentage() { // Base dodge float value = (getClass() < MAX_CLASSES) ? PLAYER_BASE_DODGE[getClass()] : 0.0f; // Dodge from agility value += GetDodgeFromAgility(GetStat(STAT_AGILITY)); // Dodge from SPELL_AURA_MOD_DODGE_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT); // Dodge from rating value += GetRatingBonusValue(CR_DODGE); // Set current dodge chance m_modDodgeChance = value; // Set value for diminishing when in combat m_modDodgeChanceDiminishing = GetDodgeFromAgility((GetStat(STAT_AGILITY) - (GetCreateStat(STAT_AGILITY) * m_auraModifiersGroup[UNIT_MOD_STAT_START + STAT_AGILITY][BASE_PCT]))); m_modDodgeChanceDiminishing += GetRatingBonusValue(CR_DODGE); // Set UI display value: modify value from defense skill against same level target value += (int32(GetDefenseSkillValue()) - int32(GetMaxSkillValueForLevel())) * 0.04f; SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, std::max(0.0f, std::min(value, 100.0f))); }
void Player::UpdateParryPercentage() { float value = 0.0f; float real = 0.0f; if (CanParry()) { // Base parry value = 5.0f; // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // Parry from rating value += GetRatingBonusValue(CR_PARRY); real = value; // Set UI display value: modify value from defense skill against same level target value += (int32(GetDefenseSkillValue()) - int32(GetSkillMaxForLevel())) * 0.04f; } // Set current dodge chance m_modParryChance = real; SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, std::max(0.0f, std::min(value, 100.0f))); }
void Player::UpdateBlockPercentage() { // No block float value = 0.0f; if (CanBlock()) { // Base value value = 5.0f; // Increase from SPELL_AURA_MOD_BLOCK_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT); // Increase from rating value += GetRatingBonusValue(CR_BLOCK); if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE)) value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_BLOCK) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_BLOCK) : value; value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_FIELD_PLAYER_FLAGS, value); }
void Player::UpdateParryPercentage() { const float parry_cap[MAX_CLASSES] = { 47.003525f, // Warrior 47.003525f, // Paladin 145.560408f, // Hunter 145.560408f, // Rogue 0.0f, // Priest 47.003525f, // DK 145.560408f, // Shaman 0.0f, // Mage 0.0f, // Warlock 0.0f, // ?? 0.0f // Druid }; // No parry float value = 0.0f; m_realParry = 0.0f; uint32 pclass = getClass()-1; if (CanParry() && parry_cap[pclass] > 0.0f) { float nondiminishing = 5.0f; // Parry from rating float diminishing = GetRatingBonusValue(CR_PARRY); // Modify value from defense skill (only bonus from defense rating diminishes) nondiminishing += (GetSkillValue(SKILL_DEFENSE) - GetMaxSkillValueForLevel()) * 0.04f; diminishing += (int32(GetRatingBonusValue(CR_DEFENSE_SKILL))) * 0.04f; // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // apply diminishing formula to diminishing parry chance m_realParry = nondiminishing + diminishing * parry_cap[pclass] / (diminishing + parry_cap[pclass] * m_diminishing_k[pclass]); m_realParry = m_realParry < 0.0f ? 0.0f : m_realParry; value = std::max(diminishing + nondiminishing, 0.0f); } SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value); }
void Player::UpdateParryPercentage() { const float parry_cap[MAX_CLASSES] = { 65.631440f, // Warrior 65.631440f, // Paladin 145.560408f, // Hunter 145.560408f, // Rogue 0.0f, // Priest 65.631440f, // DK 145.560408f, // Shaman 0.0f, // Mage 0.0f, // Warlock 90.6425f, // Monk 0.0f, // Druid 65.631440f // Demon Hunter }; // No parry float value = 0.0f; uint32 pclass = getClass()-1; if (CanParry() && parry_cap[pclass] > 0.0f) { float nondiminishing = 5.0f; // Parry from rating float diminishing = GetRatingBonusValue(CR_PARRY); // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // apply diminishing formula to diminishing parry chance value = nondiminishing + diminishing * parry_cap[pclass] / (diminishing + parry_cap[pclass] * m_diminishing_k[pclass]); if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE)) value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_PARRY) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_PARRY) : value; value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value); }
void Player::UpdateParryPercentage() { const float parry_cap[MAX_CLASSES] = { 65.631440f, // Warrior 65.631440f, // Paladin 145.560408f, // Hunter 145.560408f, // Rogue 0.0f, // Priest 65.631440f, // DK 145.560408f, // Shaman 0.0f, // Mage 0.0f, // Warlock 0.0f, // ?? 0.0f // Druid }; // No parry float value = 0.0f; uint32 pclass = getClass() - 1; if (CanParry() && parry_cap[pclass] > 0.0f) { // Base parry float nondiminishing = 5.0f; float diminishing = 0.0f; GetParryFromStrength(diminishing, nondiminishing); // Parry from rating diminishing += GetRatingBonusValue(CR_PARRY); // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // apply diminishing formula to diminishing parry chance value = nondiminishing + diminishing * parry_cap[pclass] / (diminishing + parry_cap[pclass] * m_diminishing_k[pclass]); value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value); }
void Player::UpdateCritPercentage(WeaponAttackType attType) { BaseModGroup modGroup; uint16 index; CombatRating cr; switch (attType) { case OFF_ATTACK: modGroup = OFFHAND_CRIT_PERCENTAGE; index = PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE; cr = CR_CRIT_MELEE; break; case RANGED_ATTACK: modGroup = RANGED_CRIT_PERCENTAGE; index = PLAYER_FIELD_RANGED_CRIT_PERCENTAGE; cr = CR_CRIT_RANGED; break; case BASE_ATTACK: default: modGroup = CRIT_PERCENTAGE; index = PLAYER_FIELD_CRIT_PERCENTAGE; cr = CR_CRIT_MELEE; break; } float value = GetTotalPercentageModValue(modGroup) + GetRatingBonusValue(cr); // Modify crit from weapon skill and maximized defense skill of same level victim difference value += (int32(GetMaxSkillValueForLevel()) - int32(GetMaxSkillValueForLevel())) * 0.04f; if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE)) value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_CRIT) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_CRIT) : value; value = value < 0.0f ? 0.0f : value; SetStatFloatValue(index, value); }
void Unit::UpdateDamagePhysical(WeaponAttackType attType) { float minDamage = 0.0f; float maxDamage = 0.0f; CalculateMinMaxDamage(attType, false, true, minDamage, maxDamage); switch (attType) { case BASE_ATTACK: default: SetStatFloatValue(UNIT_FIELD_MINDAMAGE, minDamage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxDamage); break; case OFF_ATTACK: SetStatFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, minDamage); SetStatFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, maxDamage); break; case RANGED_ATTACK: SetStatFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, minDamage); SetStatFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, maxDamage); break; } }
void Player::UpdateDamagePhysical(WeaponAttackType attType) { float mindamage; float maxdamage; CalculateMinMaxDamage(attType, false, true, mindamage, maxdamage); switch (attType) { case BASE_ATTACK: default: SetStatFloatValue(UNIT_FIELD_MIN_DAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAX_DAMAGE, maxdamage); break; case OFF_ATTACK: SetStatFloatValue(UNIT_FIELD_MIN_OFF_HAND_DAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAX_OFF_HAND_DAMAGE, maxdamage); break; case RANGED_ATTACK: SetStatFloatValue(UNIT_FIELD_MIN_RANGED_DAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAX_RANGED_DAMAGE, maxdamage); break; } }
void Player::UpdateParryPercentage() { // Table for base parry values const int parry_base[MAX_CLASSES] = { 3, // Warrior 3, // Paladin 0, // Hunter 3, // Rogue 0, // Priest 3, // DK 0, // Shaman 0, // Mage 0, // Warlock 3, // Monk 0 // Druid }; const float parry_cap[MAX_CLASSES] = { 237.186f, // Warrior 237.186f, // Paladin 0.0f, // Hunter 90.6424f, // Rogue 0.0f, // Priest 237.186f, // DK 0.0f, // Shaman 0.0f, // Mage 0.0f, // Warlock 90.6424f, // Monk 0.0f // Druid }; // No parry float value = 0.0f; uint32 pclass = getClass()-1; if (CanParry() && parry_cap[pclass] > 0.0f) { float nondiminishing = parry_base[pclass]; // Parry from rating float diminishing = GetRatingBonusValue(CR_PARRY); // TODO: research if talents/effects that increase total parry by x% should increase non-diminishing part float base_strength = GetCreateStat(STAT_STRENGTH) * m_auraModifiersGroup[UNIT_MOD_STAT_START + STAT_STRENGTH][BASE_PCT]; float bonus_strength = GetTotalStatValue(STAT_STRENGTH) - base_strength; float perc_cap = sObjectMgr->GetParryCapForClassLevel(pclass * GT_MAX_LEVEL + getLevel() - 1); // calculate diminishing (green in char screen) and non-diminishing (white) contribution diminishing += (bonus_strength / perc_cap) / ((bonus_strength / perc_cap) / parry_cap[pclass] + m_diminishing_k[pclass]); nondiminishing += base_strength / perc_cap; // Parry from SPELL_AURA_MOD_PARRY_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT); // apply diminishing formula to diminishing parry chance value = nondiminishing + diminishing; if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE)) value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_PARRY) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_PARRY) : value; value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value); }
void Player::UpdateManaRegen() { // Mana regen from spirit float spirit_regen = OCTRegenMPPerSpirit(); spirit_regen *= GetTotalAuraMultiplierByMiscValue(SPELL_AURA_MOD_POWER_REGEN_PERCENT, POWER_MANA); float HastePct = 1.0f + GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_HASTE_MELEE) * GetRatingMultiplier(CR_HASTE_MELEE) / 100.0f; float combat_regen = 0.004f * GetMaxPower(POWER_MANA) + spirit_regen + (GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) / 5.0f); float base_regen = 0.004f * GetMaxPower(POWER_MANA) + (GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) / 5.0f); if (getClass() == CLASS_WARLOCK) { combat_regen = 0.01f * GetMaxPower(POWER_MANA) + spirit_regen + GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA); base_regen = 0.01f * GetMaxPower(POWER_MANA) + GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA); } // Mana Meditation && Meditation if (HasAuraType(SPELL_AURA_MOD_MANA_REGEN_INTERRUPT)) base_regen += 0.5 * spirit_regen; // Allows 50% of your mana regeneration from Spirit to continue while in combat. // Rune of Power : Increase Mana regeneration by 100% if (HasAura(116014)) { combat_regen *= 2; base_regen *= 2; } // Incanter's Ward : Increase Mana regen by 65% if (HasAura(118858)) { combat_regen *= 1.65f; base_regen *= 1.65f; } // Chaotic Energy : Increase Mana regen by 625% if (HasAura(111546)) { // haste also increase your mana regeneration HastePct = 1.0f + GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_HASTE_MELEE) * GetRatingMultiplier(CR_HASTE_MELEE) / 100.0f; combat_regen = combat_regen + (combat_regen * 6.25f); combat_regen *= HastePct; base_regen = base_regen + (base_regen * 6.25f); base_regen *= HastePct; } // Nether Attunement - 117957 : Haste also increase your mana regeneration if (HasAura(117957)) { HastePct = 1.0f + GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_HASTE_MELEE) * GetRatingMultiplier(CR_HASTE_MELEE) / 100.0f; combat_regen *= HastePct; base_regen *= HastePct; } // Mana Attunement : Increase Mana regen by 50% if (HasAura(121039)) { combat_regen = combat_regen + (combat_regen * 0.5f); combat_regen *= HastePct; base_regen = base_regen + (base_regen * 0.5f); base_regen *= HastePct; } // Invocation : Decrease your mana regen by 50% if (HasAura(114003)) { combat_regen *= 0.5f; base_regen *= 0.5f; } // Not In Combat : 2% of base mana + spirit_regen SetStatFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER, base_regen); // In Combat : 2% of base mana SetStatFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER, combat_regen); }
void Guardian::UpdateDamagePhysical(WeaponAttackType attType) { if (attType > BASE_ATTACK) return; float bonusDamage = 0.0f; if (m_owner->GetTypeId() == TYPEID_PLAYER) { //force of nature if (GetEntry() == ENTRY_TREANT) { int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE); if (spellDmg > 0) bonusDamage = spellDmg * 0.09f; } //greater fire elemental else if (GetEntry() == ENTRY_FIRE_ELEMENTAL) { int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE); if (spellDmg > 0) bonusDamage = spellDmg * 0.4f; } } UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND; float att_speed = float(GetAttackTime(BASE_ATTACK))/1000.0f; float base_value = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed + bonusDamage; float base_pct = GetModifierValue(unitMod, BASE_PCT); float total_value = GetModifierValue(unitMod, TOTAL_VALUE); float total_pct = GetModifierValue(unitMod, TOTAL_PCT); float weapon_mindamage = GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE); float weapon_maxdamage = GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE); float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct; float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct; // Pet's base damage changes depending on happiness if (isHunterPet() && attType == BASE_ATTACK) { switch (ToPet()->GetHappinessState()) { case HAPPY: // 125% of normal damage mindamage = mindamage * 1.25f; maxdamage = maxdamage * 1.25f; break; case CONTENT: // 100% of normal damage, nothing to modify break; case UNHAPPY: // 75% of normal damage mindamage = mindamage * 0.75f; maxdamage = maxdamage * 0.75f; break; } } Unit::AuraEffectList const& mDummy = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACKSPEED); for (Unit::AuraEffectList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr) { switch ((*itr)->GetSpellInfo()->Id) { case 61682: case 61683: AddPct(mindamage, -(*itr)->GetAmount()); AddPct(maxdamage, -(*itr)->GetAmount()); break; default: break; } } SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage); }
void Guardian::UpdateDamagePhysical(WeaponAttackType attType) { if (attType > BASE_ATTACK) return; float bonusDamage = 0.0f; if (Unit* owner = GetOwner()) { //force of nature if (GetEntry() == 1964) { int32 spellDmg = int32(owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE)) - owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE); if (spellDmg > 0) bonusDamage = spellDmg * 0.09f; } //greater fire elemental else if (GetEntry() == 15438) { if (Unit* shaman = owner->GetOwner()) { int32 spellDmg = int32(shaman->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - shaman->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE); if (spellDmg > 0) bonusDamage = spellDmg * 0.4f; } } // shadowfiend 65.7% per 10 hits so 6.57 per hit else if (GetEntry() == 19668) { if (Unit* owner = GetOwner()) { int32 spellDmg = int32(owner->SpellBaseDamageBonus(SPELL_SCHOOL_MASK_SHADOW)); if (spellDmg > 0) bonusDamage = spellDmg * 0.0657f; } } } UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND; float att_speed = float(GetAttackTime(BASE_ATTACK))/1000.0f; float base_value = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed + bonusDamage; float base_pct = GetModifierValue(unitMod, BASE_PCT); float total_value = GetModifierValue(unitMod, TOTAL_VALUE); float total_pct = GetModifierValue(unitMod, TOTAL_PCT); float weapon_mindamage = GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE); float weapon_maxdamage = GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE); int32 speed_mod = GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKSPEED); base_pct *= 100.0f/(100.0f+float(speed_mod/2)); float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct; float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct; // Pet's base damage changes depending on happiness if (isHunterPet() && attType == BASE_ATTACK) { switch (ToPet()->GetHappinessState()) { case HAPPY: // 125% of normal damage mindamage = mindamage * 1.25f; maxdamage = maxdamage * 1.25f; break; case CONTENT: // 100% of normal damage, nothing to modify break; case UNHAPPY: // 75% of normal damage mindamage = mindamage * 0.75f; maxdamage = maxdamage * 0.75f; break; } } SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage); }
void TempSummon::InitStats(uint32 duration) { ASSERT(!isPet()); m_timer = duration; m_lifetime = duration; if (m_type == TEMPSUMMON_MANUAL_DESPAWN) m_type = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN; Unit* owner = GetSummoner(); if (owner && isTrigger() && m_spells[0]) { setFaction(owner->getFaction()); SetLevel(owner->getLevel()); if (owner->GetTypeId() == TYPEID_PLAYER) m_ControlledByPlayer = true; } if (!m_Properties) return; // Fix Force of Nature treants stats if (owner && owner->getClass() == CLASS_DRUID && owner->HasSpell(106737)) { float damage = 0.0f; switch (GetEntry()) { case ENTRY_TREANT_RESTO: case ENTRY_TREANT_BALANCE: SetMaxHealth(owner->CountPctFromMaxHealth(40)); break; case ENTRY_TREANT_GUARDIAN: SetMaxHealth(owner->CountPctFromMaxHealth(40)); // (Attack power / 14 * 2 * 0.75) * 0.2f damage = ((owner->GetTotalAttackPowerValue(BASE_ATTACK) / 14.0f) * 2.0f * 0.75f) * 0.2f; SetStatFloatValue(UNIT_FIELD_MINDAMAGE, damage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, damage); case ENTRY_TREANT_FERAL: SetMaxHealth(owner->CountPctFromMaxHealth(40)); // Attack power / 14 * 2 * 0.75 damage = (owner->GetTotalAttackPowerValue(BASE_ATTACK) / 14.0f) * 2.0f * 0.75f; SetStatFloatValue(UNIT_FIELD_MINDAMAGE, damage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, damage); default: break; } } if (owner) { if (uint32 slot = m_Properties->Slot) { if (owner->m_SummonSlot[slot] && owner->m_SummonSlot[slot] != GetGUID()) { Creature* oldSummon = GetMap()->GetCreature(owner->m_SummonSlot[slot]); if (oldSummon && oldSummon->IsSummon()) oldSummon->ToTempSummon()->UnSummon(); } owner->m_SummonSlot[slot] = GetGUID(); } } if (m_Properties->Faction) setFaction(m_Properties->Faction); else if (IsVehicle() && owner) // properties should be vehicle setFaction(owner->getFaction()); }
void Guardian::UpdateDamagePhysical(WeaponAttackType attType) { if(attType > BASE_ATTACK) return; float bonusDamage = 0.0f; if(m_owner->GetTypeId() == TYPEID_PLAYER) { //force of nature if(GetEntry() == ENTRY_TREANT) { int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE); if(spellDmg > 0) bonusDamage = spellDmg * 0.09f; } //greater fire elemental else if(GetEntry() == ENTRY_FIRE_ELEMENTAL) { int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE); if(spellDmg > 0) bonusDamage = spellDmg * 0.4f; } } UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND; float att_speed = float(GetAttackTime(BASE_ATTACK))/1000.0f; float base_value = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed + bonusDamage; float base_pct = GetModifierValue(unitMod, BASE_PCT); float total_value = GetModifierValue(unitMod, TOTAL_VALUE); float total_pct = GetModifierValue(unitMod, TOTAL_PCT); float weapon_mindamage = GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE); float weapon_maxdamage = GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE); float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct; float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct; // Pet's base damage changes depending on happiness if (isHunterPet() && attType == BASE_ATTACK) { switch(((Pet*)this)->GetHappinessState()) { case HAPPY: // 125% of normal damage mindamage = mindamage * 1.25; maxdamage = maxdamage * 1.25; break; case CONTENT: // 100% of normal damage, nothing to modify break; case UNHAPPY: // 75% of normal damage mindamage = mindamage * 0.75; maxdamage = maxdamage * 0.75; break; } } SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage); SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage); }
void Player::UpdateDodgePercentage() { // Table for base dodge values const int dodge_base[MAX_CLASSES] = { 3, // Warrior 3, // Paladin 3, // Hunter 3, // Rogue 3, // Priest 5, // DK 3, // Shaman 3, // Mage 3, // Warlock 3, // Monk 5 // Druid }; // Table for dodge cap values const float dodge_cap[MAX_CLASSES] = { 90.6425f, // Warrior 66.567f, // Paladin 145.560408f, // Hunter 145.560408f, // Rogue 150.375940f, // Priest 90.6426f, // DK 66.567f, // Shaman 150.375940f, // Mage 150.375940f, // Warlock 501.253f, // Monk 150.375940f // Druid }; float diminishing = 0.0f, nondiminishing = 0.0f; uint32 pclass = getClass() - 1; // Warriors, Death Knights and Paladins no longer gain dodge from agility if (getClass() != CLASS_WARRIOR && getClass() != CLASS_DEATH_KNIGHT && getClass() != CLASS_PALADIN) { // TODO: research if talents/effects that increase total agility by x% should increase non-diminishing part float base_agility = GetCreateStat(STAT_AGILITY) * m_auraModifiersGroup[UNIT_MOD_STAT_START + STAT_AGILITY][BASE_PCT]; float bonus_agility = GetTotalStatValue(STAT_AGILITY) - base_agility; float perc_cap = sObjectMgr->GetDodgeCapForClassLevel(pclass * GT_MAX_LEVEL + getLevel() - 1); // calculate diminishing (green in char screen) and non-diminishing (white) contribution diminishing = (bonus_agility / perc_cap) / ((bonus_agility / perc_cap) / dodge_cap[pclass] + m_diminishing_k[pclass]); nondiminishing = dodge_base[pclass] + base_agility / perc_cap; } else nondiminishing = dodge_base[pclass]; // Dodge from SPELL_AURA_MOD_DODGE_PERCENT aura nondiminishing += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT); // Dodge from rating diminishing += GetRatingBonusValue(CR_DODGE); // apply diminishing formula to diminishing dodge chance float value = nondiminishing + diminishing; if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE)) value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_DODGE) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_DODGE) : value; value = value < 0.0f ? 0.0f : value; SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, value); }