void Player::UpdateCritPercentage(WeaponAttackType attType) { BaseModGroup modGroup; uint16 index; CombatRating cr; switch (attType) { case OFF_ATTACK: modGroup = OFFHAND_CRIT_PERCENTAGE; index = PLAYER_OFFHAND_CRIT_PERCENTAGE; cr = CR_CRIT_MELEE; break; case RANGED_ATTACK: modGroup = RANGED_CRIT_PERCENTAGE; index = PLAYER_RANGED_CRIT_PERCENTAGE; cr = CR_CRIT_RANGED; break; case BASE_ATTACK: default: modGroup = CRIT_PERCENTAGE; index = PLAYER_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; value = value < 0.0f ? 0.0f : value; SetStatFloatValue(index, value); }
void Player::UpdateDodgePercentage() { 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 }; float diminishing = 0.0f, nondiminishing = 0.0f; GetDodgeFromAgility(diminishing, nondiminishing); // 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; // 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 uint32 pclass = getClass()-1; float value = nondiminishing + (diminishing * dodge_cap[pclass] / (diminishing + dodge_cap[pclass] * m_diminishing_k[pclass])); value = value < 0.0f ? 0.0f : value; SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, value); }
float Player::GetMissPercentageFromDefence() const { float const miss_cap[MAX_CLASSES] = { 16.00f, // Warrior //correct 16.00f, // Paladin //correct 16.00f, // Hunter //? 16.00f, // Rogue //? 16.00f, // Priest //? 16.00f, // DK //correct 16.00f, // Shaman //? 16.00f, // Mage //? 16.00f, // Warlock //? 0.0f, // ?? 16.00f // Druid //? }; float diminishing = 0.0f, nondiminishing = 0.0f; // 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; // apply diminishing formula to diminishing miss chance uint32 pclass = getClass()-1; return nondiminishing + (diminishing * miss_cap[pclass] / (diminishing + miss_cap[pclass] * m_diminishing_k[pclass])); }
void Player::UpdateCritPercentage(WeaponAttackType attType) { BaseModGroup modGroup; uint16 index; switch (attType) { case RANGED_ATTACK: modGroup = RANGED_CRIT_PERCENTAGE; index = PLAYER_RANGED_CRIT_PERCENTAGE; break; case BASE_ATTACK: modGroup = CRIT_PERCENTAGE; index = PLAYER_CRIT_PERCENTAGE; break; case OFF_ATTACK: // client have only main hand crit default: return; } float value = GetTotalPercentageModValue(modGroup); // Modify crit from weapon skill and maximized defense skill of same level victim difference value += (int32(GetWeaponSkillValue(attType)) - int32(GetMaxSkillValueForLevel())) * 0.04f; value = value < 0.0f ? 0.0f : value; SetStatFloatValue(index, value); }
void Player::UpdateDodgePercentage() { // Dodge from agility float value = GetDodgeFromAgility(); // Modify value from defense skill value += (int32(GetDefenseSkillValue()) - int32(GetMaxSkillValueForLevel())) * 0.04f; // Dodge from SPELL_AURA_MOD_DODGE_PERCENT aura value += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT); value = value < 0.0f ? 0.0f : value; SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, value); }
void Player::UpdateParryPercentage() { // Base parry float 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::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); value = value < 0.0f ? 0.0f : value; } SetStatFloatValue(PLAYER_BLOCK_PERCENTAGE, value); }
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 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::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(GetMaxSkillValueForLevel())) * 0.04f; } m_modBlockChance = real; SetStatFloatValue(PLAYER_BLOCK_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(GetMaxSkillValueForLevel())) * 0.04f; } // Set current dodge chance m_modParryChance = real; SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, std::max(0.0f, std::min(value, 100.0f))); }
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); }