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

bool Pet::UpdateStats(Stats stat){    if(stat > STAT_SPIRIT || stat < STAT_STRENGTH )        return false;    // value = ((create_value + base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    SetStat(stat, int32(value));    switch(stat)    {        case STAT_STRENGTH:            UpdateAttackPowerAndDamage();            break;        case STAT_AGILITY:            UpdateAttackPowerAndDamage(true);            UpdateArmor();            break;        case STAT_STAMINA:            UpdateMaxHealth();            break;        case STAT_INTELLECT:            UpdateMaxPower(POWER_MANA);            break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Player::UpdateStats(Stats stat){    if (stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    SetStat(stat, int32(value));    if (stat == STAT_STAMINA || stat == STAT_INTELLECT)    {        Pet* pet = GetPet();        if (pet)            pet->UpdateStats(stat);    }    switch (stat)    {        case STAT_STRENGTH:            break;        case STAT_AGILITY:            UpdateArmor();            UpdateAllCritPercentages();            UpdateDodgePercentage();            break;        case STAT_STAMINA:   UpdateMaxHealth(); break;        case STAT_INTELLECT:            UpdateMaxPower(POWER_MANA);            UpdateAllSpellCritChances();            UpdateArmor();                                  // SPELL_AURA_MOD_RESISTANCE_OF_INTELLECT_PERCENT, only armor currently            break;        case STAT_SPIRIT:            break;        default:            break;    }    // Need update (exist AP from stat auras)    UpdateAttackPowerAndDamage();    UpdateAttackPowerAndDamage(true);    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    // Update ratings in exist SPELL_AURA_MOD_RATING_FROM_STAT and only depends from stat    uint32 mask = 0;    AuraList const& modRatingFromStat = GetAurasByType(SPELL_AURA_MOD_RATING_FROM_STAT);    for (AuraList::const_iterator i = modRatingFromStat.begin(); i != modRatingFromStat.end(); ++i)        if (Stats((*i)->GetMiscBValue()) == stat)            mask |= (*i)->GetMiscValue();    if (mask)    {        for (uint32 rating = 0; rating < MAX_COMBAT_RATING; ++rating)            if (mask & (1 << rating))                ApplyRatingMod(CombatRating(rating), 0, true);    }    return true;}

bool Player::UpdateAllStats(){    for (int8 i = STAT_STRENGTH; i < MAX_STATS; ++i)    {        float value = GetTotalStatValue(Stats(i));        SetStat(Stats(i), int32(value));    }    UpdateArmor();    // calls UpdateAttackPowerAndDamage() in UpdateArmor for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR    UpdateAttackPowerAndDamage(true);    UpdateMaxHealth();    for (uint8 i = POWER_MANA; i < MAX_POWERS; ++i)        UpdateMaxPower(Powers(i));    UpdateAllRatings();    UpdateAllCritPercentages();    UpdateAllSpellCritChances();    UpdateBlockPercentage();    UpdateParryPercentage();    UpdateDodgePercentage();    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    UpdateExpertise(BASE_ATTACK);    UpdateExpertise(OFF_ATTACK);    RecalculateRating(CR_ARMOR_PENETRATION);    for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)        UpdateResistances(i);    return true;}

bool Player::UpdateAllStats(){    for (int i = STAT_STRENGTH; i < MAX_STATS; ++i)    {        float value = GetTotalStatValue(Stats(i));        SetStat(Stats(i), (int32)value);    }    UpdateAttackPowerAndDamage();    UpdateAttackPowerAndDamage(true);    UpdateArmor();    UpdateMaxHealth();    for (int i = POWER_MANA; i < MAX_POWERS; ++i)        { UpdateMaxPower(Powers(i)); }    UpdateAllCritPercentages();    UpdateAllSpellCritChances();    UpdateDefenseBonusesMod();    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)        { UpdateResistances(i); }    return true;}

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value = GetTotalStatValue(stat);    SetStat(stat, int32(value));    switch (stat)    {        case STAT_STRENGTH:            UpdateAttackPowerAndDamage();            break;        case STAT_AGILITY:            UpdateArmor();            UpdateMeleeCritChance();            break;        case STAT_STAMINA:            UpdateMaxHealth();            break;        case STAT_INTELLECT:            UpdateMaxPower(POWER_MANA);            UpdateSpellCritChance();            break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Guardian::UpdateStats(Stats stat){    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit* owner = GetOwner();    // Handle Death Knight Glyphs and Talents    float mod = 0.75f;    if (IsPetGhoul() && (stat == STAT_STAMINA || stat == STAT_STRENGTH))    {        if (stat == STAT_STAMINA)            mod = 0.3f; // Default Owner's Stamina scale        else            mod = 0.7f; // Default Owner's Strength scale        ownersBonus = float(owner->GetStat(stat)) * mod;        value += ownersBonus;    }    else if (stat == STAT_STAMINA)    {        ownersBonus = CalculatePct(owner->GetStat(STAT_STAMINA), 30);        value += ownersBonus;    }                                                            //warlock's and mage's pets gain 30% of owner's intellect    else if (stat == STAT_INTELLECT)    {        if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)        {            ownersBonus = CalculatePct(owner->GetStat(stat), 30);            value += ownersBonus;        }    }/*    else if (stat == STAT_STRENGTH)    {        if (IsPetGhoul())            value += float(owner->GetStat(stat)) * 0.3f;    }*/    SetStat(stat, int32(value));    m_statFromOwner[stat] = ownersBonus;    ApplyStatBuffMod(stat, m_statFromOwner[stat], true);    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        default:            break;    }    return true;}

bool Pet::UpdateStats(Stats stat){    if (stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    Unit* owner = GetOwner();    // chained, use original owner instead    if (owner && owner->GetTypeId() == TYPEID_UNIT && ((Creature*)owner)->GetEntry() == GetEntry())    {        if (Unit* creator = GetCreator())            owner = creator;    }    if (stat == STAT_STAMINA)    {        if(owner && owner->GetTypeId() == TYPEID_PLAYER  && owner->getClass() == CLASS_WARLOCK)            value += float(owner->GetStat(stat)) * 0.75f;        else if (owner)            value += float(owner->GetStat(stat)) * 0.3f;    }    // warlock's and mage's pets gain 30% of owner's intellect    else if (stat == STAT_INTELLECT && getPetType() == SUMMON_PET)    {        if (owner && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE))            value += float(owner->GetStat(stat)) * 0.3f;    }    // deathknight's ghoul gain 100% of owner's strength    else if (stat == STAT_STRENGTH && getPetType() == SUMMON_PET)    {        if (owner && (owner->getClass() == CLASS_DEATH_KNIGHT))        {            value += float(owner->GetStat(stat)) * 1.0f;        }    }    SetStat(stat, int32(value));    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit *owner = GetOwner();    if (stat == STAT_STAMINA)    {        if (owner->getClass() == CLASS_WARLOCK && isPet() || isHunterPet())        {            // TOTAL_PCT should be applied after ownersBonus            UnitMods unitMod = UnitMods(UNIT_MOD_STAT_START + stat);            value *= (1.0f / m_auraModifiersGroup[unitMod][TOTAL_PCT]) ;            ownersBonus = CalculatePct(owner->GetStat(stat), 30);            value += ownersBonus;            value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];        }    }    else if (stat == STAT_INTELLECT)    {        // Warlock and Mage pets gain 30% of owners intellect        if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)        {            // TOTAL_PCT should be applied after ownersBonus            UnitMods unitMod = UnitMods(UNIT_MOD_STAT_START + stat);            value *= (1.0f / m_auraModifiersGroup[unitMod][TOTAL_PCT]) ;            ownersBonus = CalculatePct(owner->GetStat(stat), 30);            value += ownersBonus;            value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];        }    }    SetStat(stat, int32(value));    m_statFromOwner[stat] = ownersBonus;    ApplyStatBuffMod(stat, m_statFromOwner[stat], true);    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Player::UpdateStats(Stats stat){    if (stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    SetStat(stat, int32(value));    if (stat == STAT_STAMINA || stat == STAT_INTELLECT)    {        Pet* pet = GetPet();        if (pet)            pet->UpdateStats(stat);    }    switch (stat)    {    case STAT_STRENGTH:        UpdateAttackPowerAndDamage();        UpdateShieldBlockValue();        break;    case STAT_AGILITY:        UpdateArmor();        UpdateAttackPowerAndDamage(true);        if (getClass() == CLASS_ROGUE || getClass() == CLASS_HUNTER || (getClass() == CLASS_DRUID && m_form == FORM_CAT))            UpdateAttackPowerAndDamage();        UpdateAllCritPercentages();        UpdateDodgePercentage();        break;    case STAT_STAMINA:        UpdateMaxHealth();        break;    case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);        UpdateAllSpellCritChances();        UpdateAttackPowerAndDamage(true);               //SPELL_AURA_MOD_RANGED_ATTACK_POWER_OF_STAT_PERCENT, only intellect currently        UpdateArmor();                                  //SPELL_AURA_MOD_RESISTANCE_OF_INTELLECT_PERCENT, only armor currently        break;    case STAT_SPIRIT:        break;    default:        break;    }    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    return true;}

bool Player::UpdateStats(Stats stat){    if (stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    SetStat(stat, int32(value));    if (stat == STAT_STAMINA || stat == STAT_INTELLECT)    {        Pet* pet = GetPet();        if (pet)            pet->UpdateStats(stat);    }    switch (stat)    {    case STAT_STRENGTH:        UpdateShieldBlockValue();        break;    case STAT_AGILITY:        UpdateArmor();        UpdateAllCritPercentages();        UpdateDodgePercentage();        break;    case STAT_STAMINA:        UpdateMaxHealth();        break;    case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);        UpdateAllSpellCritChances();        UpdateArmor();                                  // SPELL_AURA_MOD_RESISTANCE_OF_INTELLECT_PERCENT, only armor currently        break;    case STAT_SPIRIT:        break;    default:        break;    }    // Need update (exist AP from stat auras)    UpdateAttackPowerAndDamage();    UpdateAttackPowerAndDamage(true);    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    return true;}

bool Pet::UpdateStats(Stats stat){    if(stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    Unit *owner = GetOwner();    if ( stat == STAT_STAMINA )    {        if(owner)        {            float scale_coeff = 0.3f;            switch (owner->getClass())            {                case CLASS_HUNTER:                    scale_coeff = 0.45f;                    break;                case CLASS_WARLOCK:                    scale_coeff = 0.75f;                    break;            }            value += float(owner->GetStat(stat)) * scale_coeff;        }    }                                                            //warlock's and mage's pets gain 30% of owner's intellect    else if ( stat == STAT_INTELLECT && getPetType() == SUMMON_PET )    {        if(owner && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE) )            value += float(owner->GetStat(stat)) * 0.3f;    }    SetStat(stat, int32(value));    switch(stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Pet::UpdateStats(Stats stat){    if(stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    Unit *owner = GetOwner();    if (owner)    {        switch(stat)        {            case STAT_STAMINA:                // warlock's pets gain 75% of owner's stamina                if (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)                    value += owner->GetStat(stat) * 0.75f;                else                {                    if (getPetType() == SUMMON_PET || getPetType() == HUNTER_PET || owner->getClass() == CLASS_DEATH_KNIGHT)                        value += owner->GetStat(stat) * 0.3f;                }                break;            case STAT_INTELLECT:                // warlock's and mage's pets gain 30% of owner's intellect                if (getPetType() == SUMMON_PET && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE))                    value += owner->GetStat(stat) * 0.3f;                break;        };    }    SetStat(stat, int32(value));    switch(stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Player::UpdateAllStats(){    for (int i = STAT_STRENGTH; i < MAX_STATS; ++i)    {        float value = GetTotalStatValue(Stats(i));        SetStat(Stats(i), (int32)value);    }    UpdateArmor();    // calls UpdateAttackPowerAndDamage() in UpdateArmor for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR    UpdateAttackPowerAndDamage(true);    UpdateMaxHealth();    for (uint32 i = 0; i <= sChrPowerTypesStore.GetNumRows(); i++)    {        ChrPowerTypesEntry const* cEntry = sChrPowerTypesStore.LookupEntry(i);        if (!cEntry)            continue;        if (getClass() != cEntry->classId)            continue;        if (cEntry->power == 10)            continue;        SetMaxPower(Powers(cEntry->power),  uint32(GetCreatePowers(Powers(cEntry->power))));    }    UpdateAllRatings();    UpdateAllCritPercentages();    UpdateAllSpellCritChances();    UpdateDefenseBonusesMod();    UpdateShieldBlockValue();    UpdateArmorPenetration();    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    UpdateExpertise(BASE_ATTACK);    UpdateExpertise(OFF_ATTACK);    for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)        UpdateResistances(i);    return true;}

bool Guardian::UpdateStats(Stats stat){     if (stat >= MAX_STATS)        return false;	float value = GetTotalStatValue(stat);    SetStat(stat, int32(value));    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        //case STAT_SPIRIT:    }    return true;}

bool Pet::UpdateStats(Stats stat){    if (stat > STAT_SPIRIT)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    CreatureInfo const *cinfo = GetCreatureInfo();     Unit *owner = GetOwner();    // chained, use original owner instead    if (owner && owner->GetTypeId() == TYPEID_UNIT && ((Creature*)owner)->GetEntry() == GetEntry())        if (Unit *creator = GetCreator())            owner = creator;    if (owner && owner->GetTypeId() == TYPEID_PLAYER)    {        float scale_coeff = 0.0f;        switch(stat)        {            case STAT_STRENGTH:            {                if (owner->getClass() == CLASS_DEATH_KNIGHT)                {                    if (getPetType() == SUMMON_PET)                    {                        scale_coeff = 0.7f;                        // Ravenous Dead                        if (SpellEntry const* spell = ((Player*)owner)->GetKnownTalentRankById(1934))                            scale_coeff *= 1.0f + spell->CalculateSimpleValue(EFFECT_INDEX_1) / 100.0f;                        // Glyph of Ghoul                        if (Aura *glyph = owner->GetDummyAura(58686))                            scale_coeff += glyph->GetModifier()->m_amount / 100.0f;                    }                }                break;            }            case STAT_STAMINA:            {                scale_coeff = 0.3f;                switch (owner->getClass())                {                    case CLASS_HUNTER:                    {                        scale_coeff = 0.45f;                        //Wild Hunt                        uint32 bonus_id = 0;                        if (HasSpell(62762))                            bonus_id = 62762;                        else if (HasSpell(62758))                            bonus_id = 62758;                        if (const SpellEntry *bonusProto = sSpellStore.LookupEntry(bonus_id))                             scale_coeff *= 1 + bonusProto->CalculateSimpleValue(EFFECT_INDEX_0) / 100.0f;                        break;                    }                    case CLASS_WARLOCK:                    {                        scale_coeff = 0.75f;                        break;                    }                    case CLASS_DEATH_KNIGHT:                    {                        if (getPetType() == SUMMON_PET)                        {                            // Ravenous Dead                            if (owner->GetTypeId() == TYPEID_PLAYER)                                if (SpellEntry const* spell = ((Player*)owner)->GetKnownTalentRankById(1934))                                    scale_coeff *= 1.0f + spell->CalculateSimpleValue(EFFECT_INDEX_1) / 100.0f;                            // Glyph of Ghoul                            if (Aura *glyph = owner->GetDummyAura(58686))                                scale_coeff += glyph->GetModifier()->m_amount / 100.0f;                        }                        break;                     }                    case CLASS_DRUID:                    {                                                //For treants, use 70% of stamina / 3 treants, guessed                        scale_coeff = 0.7f / 3.0f;                         break;                    }                }                break;            }            case STAT_INTELLECT:            {                //warlock's and mage's pets gain 30% of owner's intellect                if (getPetType() == SUMMON_PET)                {                    if (owner && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE) )                        scale_coeff = 0.3f;                }                break;            }        }        value += float(owner->GetStat(stat)) * scale_coeff;    }    SetStat(stat, int32(value));//.........这里部分代码省略.........

bool Player::UpdateAllStats(){    for (int8 i = STAT_STRENGTH; i < MAX_STATS; ++i)    {        float value = GetTotalStatValue(Stats(i));        SetStat(Stats(i), int32(value));    }    UpdateArmor();    // calls UpdateAttackPowerAndDamage() in UpdateArmor for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR    UpdateAttackPowerAndDamage(true);    UpdateMaxHealth();    for (uint8 i = POWER_MANA; i < MAX_POWERS; ++i)        UpdateMaxPower(Powers(i));    // Custom MoP script    // Jab Override Driver    if (GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_MONK)    {        Item* mainItem = GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);        if (mainItem && mainItem->GetTemplate()->Class == ITEM_CLASS_WEAPON && !HasAura(125660))        {            RemoveAura(108561); // 2H Staff Override            RemoveAura(115697); // 2H Polearm Override            RemoveAura(115689); // D/W Axes            RemoveAura(115694); // D/W Maces            RemoveAura(115696); // D/W Swords            switch (mainItem->GetTemplate()->SubClass)            {                case ITEM_SUBCLASS_WEAPON_STAFF:                    CastSpell(this, 108561, true);                    break;                case ITEM_SUBCLASS_WEAPON_POLEARM:                    CastSpell(this, 115697, true);                    break;                case ITEM_SUBCLASS_WEAPON_AXE:                    CastSpell(this, 115689, true);                    break;                case ITEM_SUBCLASS_WEAPON_MACE:                    CastSpell(this, 115694, true);                    break;                case ITEM_SUBCLASS_WEAPON_SWORD:                    CastSpell(this, 115696, true);                    break;                default:                    break;            }        }        else if (HasAura(125660))        {            RemoveAura(108561); // 2H Staff Override            RemoveAura(115697); // 2H Polearm Override            RemoveAura(115689); // D/W Axes            RemoveAura(115694); // D/W Maces            RemoveAura(115696); // D/W Swords        }    }    UpdateAllRatings();    UpdateAllCritPercentages();    UpdateAllSpellCritChances();    UpdateBlockPercentage();    UpdateParryPercentage();    UpdateDodgePercentage();    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    UpdateExpertise(BASE_ATTACK);    UpdateExpertise(OFF_ATTACK);    UpdateExpertise(RANGED_ATTACK);    for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)        UpdateResistances(i);    return true;}

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);}

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    float value  = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit* owner = GetOwner();    // Handle Death Knight Glyphs and Talents    float mod = 0.75f;    switch (stat)    {        case STAT_STAMINA:        {            mod = 0.3f;            if (IsPetGhoul() || IsPetGargoyle())                mod = 0.45f;            else if (owner->getClass() == CLASS_WARLOCK && isPet())                mod = 0.75f;            else if (owner->getClass() == CLASS_MAGE && isPet())                mod = 0.75f;            else            {                mod = 0.45f;                if (isPet())                {                    switch (ToPet()->GetSpecializationId())                    {                        case SPEC_PET_FEROCITY: mod = 0.67f; break;                        case SPEC_PET_TENACITY: mod = 0.78f; break;                        case SPEC_PET_CUNNING: mod = 0.725f; break;                    }                }            }            ownersBonus = float(owner->GetStat(stat)) * mod;            ownersBonus *= GetModifierValue(UNIT_MOD_STAT_STAMINA, TOTAL_PCT);            value += ownersBonus;            break;        }        case STAT_STRENGTH:        {            mod = 0.7f;            ownersBonus = owner->GetStat(stat) * mod;            value += ownersBonus;            break;        }        case STAT_INTELLECT:        {            if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)            {                mod = 0.3f;                ownersBonus = owner->GetStat(stat) * mod;            }            else if (owner->getClass() == CLASS_DEATH_KNIGHT && GetEntry() == 31216)            {                mod = 0.3f;                if (owner->GetSimulacrumTarget())                    ownersBonus = owner->GetSimulacrumTarget()->GetStat(stat) * mod;                else                    ownersBonus = owner->GetStat(stat) * mod;            }            value += ownersBonus;            break;        }        default:            break;    }    SetStat(stat, int32(value));    m_statFromOwner[stat] = ownersBonus;    ApplyStatBuffMod(stat, m_statFromOwner[stat], true);    switch (stat)    {        case STAT_STRENGTH:            UpdateAttackPowerAndDamage();            break;        case STAT_AGILITY:            UpdateArmor();            break;        case STAT_STAMINA:            UpdateMaxHealth();            break;        case STAT_INTELLECT:            UpdateMaxPower(POWER_MANA);            if (owner->getClass() == CLASS_MAGE)                UpdateAttackPowerAndDamage();            break;        case STAT_SPIRIT:        default:            break;    }//.........这里部分代码省略.........

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit* owner = GetOwner();        float mod = 0.75f;    switch (stat)    {        case STAT_STRENGTH:        {            if (IsPetGhoul())            {                mod = 0.7f;                                // Glyph of the Ghoul                if (AuraEffect const* aurEff = owner->GetAuraEffect(58686, 0))                    mod += CalculatePct(1.0f, aurEff->GetAmount());                ownersBonus = owner->GetStat(stat) * mod;                value += ownersBonus;            }            break;        }        case STAT_STAMINA:        {            mod = 0.0f;            if (IsPetGhoul() || IsPetGargoyle())            {                // Glyph of the Ghoul                if (AuraEffect const* aurEff = owner->GetAuraEffect(58686, 0))                    mod += CalculatePct(1.0f, aurEff->GetAmount());             }            ownersBonus = owner->GetStat(stat) * mod;            ownersBonus *= GetModifierValue(UNIT_MOD_STAT_STAMINA, TOTAL_PCT);            value += ownersBonus;            break;        }        case STAT_INTELLECT:        {            if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)            {                mod = 0.3f;                ownersBonus = owner->GetStat(stat) * mod;            }            else if (owner->getClass() == CLASS_DEATH_KNIGHT && GetEntry() == 31216)            {                mod = 0.3f;                if (owner->getSimulacrumTarget())                    ownersBonus = owner->getSimulacrumTarget()->GetStat(stat) * mod;                else                    ownersBonus = owner->GetStat(stat) * mod;            }            value += ownersBonus;            break;        }    }    SetStat(stat, int32(value));    m_statFromOwner[stat] = ownersBonus;    ApplyStatBuffMod(stat, m_statFromOwner[stat], true);    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:            UpdateMaxPower(POWER_MANA);            if (isPet() && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE))                UpdateAttackPowerAndDamage();             break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit* owner = GetOwner();    // Handle Death Knight Glyphs and Talents    float mod = 0.75f;    if (IsPetGhoul() && (stat == STAT_STAMINA || stat == STAT_STRENGTH))    {        switch (stat)        {            case STAT_STAMINA:  mod = 0.9f; break;                // Default is 0.48            case STAT_STRENGTH: mod = 0.7f; break;                // Default Owner's Strength scale            default: break;        }        // Check just if owner has Ravenous Dead since it's effect is not an aura        AuraEffect const* aurEff = owner->GetAuraEffect(SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, SPELLFAMILY_DEATHKNIGHT, 3010, 0);        if (aurEff)        {            SpellInfo const* spellInfo = aurEff->GetSpellInfo();                                                 // Then get the SpellProto and add the dummy effect value            AddPct(mod, spellInfo->Effects[EFFECT_1].CalcValue(owner));                                              // Ravenous Dead edits the original scale        }        // Glyph of the Ghoul        aurEff = owner->GetAuraEffect(58686, 0);        if (aurEff)            mod += CalculatePct(1.0f, aurEff->GetAmount());                                                    // Glyph of the Ghoul adds a flat value to the scale mod        ownersBonus = float(owner->GetStat(stat)) * mod;        value += ownersBonus;    }    else if (stat == STAT_STAMINA)    {        int pct = 30;        switch(owner->getClass())        {            case CLASS_WARLOCK:                pct = 75;                break;            case CLASS_DEATH_KNIGHT:                // Ebon Gargoyle                if(GetEntry() == 27829)                {                    pct = 80;                }                break;            case CLASS_MAGE:                pct = 78;                break;            case CLASS_SHAMAN:                pct = 78;                break;            case CLASS_HUNTER:                pct = 67;                                // Looks for creature template                if(CreatureTemplate const* cinfo = GetCreatureTemplate())                {                    // Checks the pet talent type                    CreatureFamilyEntry const* pet_family = sCreatureFamilyStore.LookupEntry(cinfo->family);                    if (pet_family)                    {                        switch(pet_family->petTalentType)                        {                            // Ferocity                            case 0:                                pct = 67;                                break;                            // Tenacity                            case 1:                                pct = 78;                                break;                            // Cunning                            case 2:                                pct = 73;                                break;                        }                    }                }                break;        }        ownersBonus = CalculatePct(owner->GetStat(STAT_STAMINA) - owner->GetCreateStat(STAT_STAMINA), pct);        value += ownersBonus;    }                                                            //warlock's and mage's pets gain 30% of owner's intellect    else if (stat == STAT_INTELLECT)    {        if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)        {            ownersBonus = CalculatePct(owner->GetStat(stat), 30);            value += ownersBonus;        }    }//.........这里部分代码省略.........

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    ApplyStatBuffMod(stat, m_statFromOwner[stat], false);    float ownersBonus = 0.0f;    Unit *owner = GetOwner();    // Handle Death Knight Glyphs and Talents    float mod = 0.75f;    if (IsPetGhoul() && (stat == STAT_STAMINA || stat == STAT_STRENGTH))    {        switch (stat)        {            case STAT_STAMINA:  mod = 0.3f; break;                // Default Owner's Stamina scale            case STAT_STRENGTH: mod = 0.7f; break;                // Default Owner's Strength scale            default: break;        }        // Ravenous Dead        AuraEffect const *aurEff = NULL;        // Check just if owner has Ravenous Dead since it's effect is not an aura        aurEff = owner->GetAuraEffect(SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, SPELLFAMILY_DEATHKNIGHT, 3010, 0);        if (aurEff)        {            SpellInfo const* spellInfo = aurEff->GetSpellInfo();                                                 // Then get the SpellProto and add the dummy effect value            AddPctN(mod, spellInfo->Effects[EFFECT_1].CalcValue());                                              // Ravenous Dead edits the original scale        }        // Glyph of the Ghoul        aurEff = owner->GetAuraEffect(58686, 0);        if (aurEff)            mod += CalculatePctN(1.0f, aurEff->GetAmount());                                                    // Glyph of the Ghoul adds a flat value to the scale mod        ownersBonus = float(owner->GetStat(stat)) * mod;        // ownersBonus is multiplied by TOTAL_PCT too        ownersBonus *= GetModifierValue(UNIT_MOD_STAT_STAMINA, TOTAL_PCT);        value += ownersBonus;    }    else if (stat == STAT_STAMINA)    {        if (owner->getClass() == CLASS_WARLOCK && isPet())        {            ownersBonus = CalculatePctN(owner->GetStat(STAT_STAMINA), 75);            value += ownersBonus;        }        else        {            mod = 0.45f;            if (isPet())            {                PetSpellMap::const_iterator itr = (ToPet()->m_spells.find(62758)); // Wild Hunt rank 1                if (itr == ToPet()->m_spells.end())                    itr = ToPet()->m_spells.find(62762);                            // Wild Hunt rank 2                if (itr != ToPet()->m_spells.end())                                 // If pet has Wild Hunt                {                    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first); // Then get the SpellProto and add the dummy effect value                    AddPctN(mod, spellInfo->Effects[EFFECT_0].CalcValue());                }            }            ownersBonus = float(owner->GetStat(stat)) * mod;            value += ownersBonus;        }    }                                                            //warlock's and mage's pets gain 30% of owner's intellect    else if (stat == STAT_INTELLECT)    {        if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)        {            ownersBonus = CalculatePctN(owner->GetStat(stat), 30);            value += ownersBonus;        }    }/*    else if (stat == STAT_STRENGTH)    {        if (IsPetGhoul())            value += float(owner->GetStat(stat)) * 0.3f;    }*/    SetStat(stat, int32(value));    m_statFromOwner[stat] = ownersBonus;    ApplyStatBuffMod(stat, m_statFromOwner[stat], true);    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}

bool Guardian::UpdateStats(Stats stat){    if (stat >= MAX_STATS)        return false;    // value = ((base_value * base_pct) + total_value) * total_pct    float value  = GetTotalStatValue(stat);    Unit *owner = GetOwner();    // Handle Death Knight Glyphs and Talents    if (IsPetGhoul() && (stat == STAT_STAMINA || stat == STAT_STRENGTH))    {         float mod = 0.0f;        switch (stat)        {            case STAT_STAMINA:  mod = 0.3f; break;                // Default Owner's Stamina scale            case STAT_STRENGTH: mod = 0.7f; break;                // Default Owner's Strength scale            default: break;        }        // Ravenous Dead        AuraEffect const *aurEff;        // Check just if owner has Ravenous Dead since it's effect is not an aura        if (aurEff = owner->GetAuraEffect(SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, SPELLFAMILY_DEATHKNIGHT, 3010, 0))        {            SpellEntry const* sProto = aurEff->GetSpellProto();                                                       // Then get the SpellProto and add the dummy effect value            mod += mod * (sProto->EffectBasePoints[1] / 100.0f);                                                      // Ravenous Dead edits the original scale        }        // Glyph of the Ghoul        if (aurEff = owner->GetAuraEffect(58686, 0))            mod += (aurEff->GetAmount() / 100.0f);                                                                    // Glyph of the Ghoul adds a flat value to the scale mod        value += float(owner->GetStat(stat)) * mod;    }    else if (stat == STAT_STAMINA)    {        if (owner->getClass() == CLASS_WARLOCK && isPet())            value += float(owner->GetStat(STAT_STAMINA)) * 0.75f;        else            value += float(owner->GetStat(stat)) * 0.3f;    }                                                            //warlock's and mage's pets gain 30% of owner's intellect    else if (stat == STAT_INTELLECT)    {        if (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE)            value += float(owner->GetStat(stat)) * 0.3f;    }/*    else if (stat == STAT_STRENGTH)    {        if (IsPetGhoul())            value += float(owner->GetStat(stat)) * 0.3f;    }*/    SetStat(stat, int32(value));    switch (stat)    {        case STAT_STRENGTH:         UpdateAttackPowerAndDamage();        break;        case STAT_AGILITY:          UpdateArmor();                       break;        case STAT_STAMINA:          UpdateMaxHealth();                   break;        case STAT_INTELLECT:        UpdateMaxPower(POWER_MANA);          break;        case STAT_SPIRIT:        default:            break;    }    return true;}