自学教程：C++ GetMaxSkillValueForLevel函数代码示例

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::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(){     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);}