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

void Player::UpdateExpertise(WeaponAttackType attack){    float expertise = GetRatingBonusValue(CR_EXPERTISE);    Item* weapon = GetWeaponForAttack(attack, true);    AuraEffectList const& expAuras = GetAuraEffectsByType(SPELL_AURA_MOD_EXPERTISE);    for (AuraEffectList::const_iterator itr = expAuras.begin(); itr != expAuras.end(); ++itr)    {        // item neutral spell        if ((*itr)->GetSpellInfo()->EquippedItemClass == -1)            expertise += (*itr)->GetAmount();        // item dependent spell        else if (weapon && weapon->IsFitToSpellRequirements((*itr)->GetSpellInfo()))            expertise += (*itr)->GetAmount();    }    if (expertise < 0)        expertise = 0.0f;    switch (attack)    {        case BASE_ATTACK: SetFloatValue(PLAYER_EXPERTISE, expertise);          break;        case OFF_ATTACK:  SetFloatValue(PLAYER_OFFHAND_EXPERTISE, expertise);  break;        case RANGED_ATTACK: SetFloatValue(PLAYER_RANGED_EXPERTISE, expertise); break;        default: break;    }}

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 || stat == STAT_STRENGTH)    {        Pet* pet = GetPet();        if (pet)            pet->UpdateStats(stat);    }    switch (stat)    {        case STAT_STRENGTH:            UpdateParryPercentage();            UpdateAttackPowerAndDamage(false);            break;        case STAT_AGILITY:            UpdateAllCritPercentages();            UpdateDodgePercentage();            UpdateAttackPowerAndDamage(false);            UpdateAttackPowerAndDamage(true);            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;    }    UpdateSpellDamageAndHealingBonus();    UpdateManaRegen();    // Update ratings in exist SPELL_AURA_MOD_RATING_FROM_STAT and only depends from stat    uint32 mask = 0;    AuraEffectList const& modRatingFromStat = GetAuraEffectsByType(SPELL_AURA_MOD_RATING_FROM_STAT);    for (AuraEffectList::const_iterator i = modRatingFromStat.begin(); i != modRatingFromStat.end(); ++i)        if (Stats((*i)->GetMiscValueB()) == 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;}

void Player::UpdateArmor(){    float value = 0.0f;    UnitMods unitMod = UNIT_MOD_ARMOR;    value  = GetModifierValue(unitMod, BASE_VALUE);         // base armor (from items)    value *= GetModifierValue(unitMod, BASE_PCT);           // armor percent from items    value += GetModifierValue(unitMod, TOTAL_VALUE);    // Custom MoP Script    // 77494 - Mastery : Nature's Guardian    if (GetTypeId() == TYPEID_PLAYER && HasAura(77494))    {        float Mastery = 1.0f + GetFloatValue(PLAYER_MASTERY) * 1.25f / 100.0f;        value *= Mastery;    }    //add dynamic flat mods    AuraEffectList const& mResbyIntellect = GetAuraEffectsByType(SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT);    for (AuraEffectList::const_iterator i = mResbyIntellect.begin(); i != mResbyIntellect.end(); ++i)    {        if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)            value += CalculatePct(GetStat(Stats((*i)->GetMiscValueB())), (*i)->GetAmount());    }    value *= GetModifierValue(unitMod, TOTAL_PCT);    SetArmor(int32(value));    Pet* pet = GetPet();    if (pet)        pet->UpdateArmor();    UpdateAttackPowerAndDamage();                           // armor dependent auras update for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR}

void Player::UpdateSpellDamageAndHealingBonus(){    // Magic damage modifiers implemented in Unit::SpellDamageBonusDone    // This information for client side use only    // Get healing bonus for all schools    SetStatInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_ALL));    // Get damage bonus for all schools    Unit::AuraEffectList const& modDamageAuras = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE);    for (uint16 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)    {        SetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, std::accumulate(modDamageAuras.begin(), modDamageAuras.end(), 0, [i](int32 negativeMod, AuraEffect const* aurEff)        {            if (aurEff->GetAmount() < 0 && aurEff->GetMiscValue() & (1 << i))                negativeMod += aurEff->GetAmount();            return negativeMod;        }));        SetStatInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, SpellBaseDamageBonusDone(SpellSchoolMask(1 << i)) - GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i));    }    if (HasAuraType(SPELL_AURA_OVERRIDE_ATTACK_POWER_BY_SP_PCT))    {        UpdateAttackPowerAndDamage();        UpdateAttackPowerAndDamage(true);    }}

void Player::UpdateArmor(){    UnitMods unitMod = UNIT_MOD_ARMOR;    float value = GetModifierValue(unitMod, BASE_VALUE);    // base armor (from items)    value *= GetModifierValue(unitMod, BASE_PCT);           // armor percent from items    value += GetModifierValue(unitMod, TOTAL_VALUE);    //add dynamic flat mods    AuraEffectList const& mResbyIntellect = GetAuraEffectsByType(SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT);    for (AuraEffectList::const_iterator i = mResbyIntellect.begin(); i != mResbyIntellect.end(); ++i)    {        if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)            value += CalculatePct(GetStat(Stats((*i)->GetMiscValueB())), (*i)->GetAmount());    }    value *= GetModifierValue(unitMod, TOTAL_PCT);    SetArmor(int32(value));    Pet* pet = GetPet();    if (pet)        pet->UpdateArmor();    UpdateAttackPowerAndDamage();                           // armor dependent auras update for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR}

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;    /// @todo: remove this    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::UpdateSpellPenetrationRating(){    if (!m_owner || m_owner->GetTypeId() != TYPEID_PLAYER)        return;    AuraEffectList const& petSpellPenetrationAuras = GetAuraEffectsByType(SPELL_AURA_MOD_TARGET_RESISTANCE);    for (AuraEffectList::const_iterator i = petSpellPenetrationAuras.begin(); i != petSpellPenetrationAuras.end(); ++i)    {        if (sObjectMgr->isPetScalingSpell((*i)->GetId()))            (*i)->RecalculateAmount(true);    }}

void Player::UpdateMeleeHitChances(){ m_modMeleeHitChance = 0;AuraEffectList const & alist = GetAuraEffectsByType(SPELL_AURA_MOD_HIT_CHANCE);Item *weapon = this->GetWeaponForAttack(BASE_ATTACK);for (AuraEffectList::const_iterator itr = alist.begin(); itr != alist.end(); ++itr){if ((*itr)->GetSpellInfo()->EquippedItemSubClassMask && !weapon)continue;if (weapon && !weapon->IsFitToSpellRequirements((*itr)->GetSpellInfo()))continue;m_modMeleeHitChance += (*itr)->GetAmount();}SetFloatValue(PLAYER_FIELD_UI_HIT_MODIFIER, m_modMeleeHitChance);m_modMeleeHitChance += GetRatingBonusValue(CR_HIT_MELEE);;    SetFloatValue(PLAYER_FIELD_UI_HIT_MODIFIER, (float)GetTotalAuraModifier(SPELL_AURA_MOD_HIT_CHANCE));}

//.........这里部分代码省略.........    {        switch (getClass())        {            case CLASS_WARRIOR:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_PALADIN:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_DEATH_KNIGHT:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_ROGUE:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_HUNTER:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_SHAMAN:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_DRUID:            {                switch (GetShapeshiftForm())                {                    case FORM_CAT:                        val2 = GetStat(STAT_STRENGTH) * 2.0f + GetStat(STAT_AGILITY) - 20.0f + m_baseFeralAP;                        break;                    case FORM_BEAR:                    case FORM_DIREBEAR:                    case FORM_MOONKIN:                        val2 = GetStat(STAT_STRENGTH) * 2.0f - 20.0f + m_baseFeralAP;                        break;                    default:                        val2 = GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                        break;                }                break;            }            case CLASS_MAGE:                val2 =  GetStat(STAT_STRENGTH) - 10.0f;                break;            case CLASS_PRIEST:                val2 = GetStat(STAT_STRENGTH) - 10.0f;                break;            case CLASS_WARLOCK:                val2 = GetStat(STAT_STRENGTH) - 10.0f;                break;        }    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower  = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    //add dynamic flat mods    if (ranged)    {        if ((getClassMask() & CLASSMASK_WAND_USERS) == 0)        {            AuraEffectList const& mRAPbyStat = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_OF_STAT_PERCENT);            for (AuraEffectList::const_iterator i = mRAPbyStat.begin(); i != mRAPbyStat.end(); ++i)                attPowerMod += CalculatePctN(GetStat(Stats((*i)->GetMiscValue())), (*i)->GetAmount());        }    }    else    {        AuraEffectList const& mAPbyStat = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_STAT_PERCENT);        for (AuraEffectList::const_iterator i = mAPbyStat.begin(); i != mAPbyStat.end(); ++i)            attPowerMod += CalculatePctN(GetStat(Stats((*i)->GetMiscValue())), (*i)->GetAmount());        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)            // always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)            attPowerMod += int32(GetArmor() / (*iter)->GetAmount());    }    SetInt32Value(index, (uint32)base_attPower);            //UNIT_FIELD_(RANGED)_ATTACK_POWER field    Pet* pet = GetPet();                                //update pet's AP    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->isHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }}

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* chrEntry = sChrClassesStore.LookupEntry(getClass());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mod = UNIT_FIELD_ATTACK_POWER_MOD_POS;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        index_mod = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;        float rapPerAgi = std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f) * chrEntry->RAPPerAgility;        switch (getClass())        {            case CLASS_HUNTER: val2 = level * 2.0f + rapPerAgi; break;            case CLASS_ROGUE: val2 = level + rapPerAgi; break;            case CLASS_WARRIOR: val2 = level + rapPerAgi; break;            default: break;        }    }    else    {        float apPerAgi = std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f) * chrEntry->APPerAgility;        float apPerStr = std::max(GetStat(STAT_STRENGTH) - 10.0f, 0.0f) * chrEntry->APPerStrenth;        float levelmod;        switch (getClass())        {            case CLASS_WARRIOR:            case CLASS_PALADIN:            case CLASS_DEATH_KNIGHT:            case CLASS_DRUID:                levelmod = 3.0f;                break;            default:                levelmod = 2.0f;                break;        }        val2 = level * levelmod + apPerAgi + apPerStr;        // extracted from client        if (getClass() == CLASS_DRUID && GetShapeshiftForm())        {            if (SpellShapeshiftFormEntry const* const entry = sSpellShapeshiftFormStore.LookupEntry(uint32(GetShapeshiftForm())))                if (entry->flags1 & 0x20)                    val2 += std::max((GetStat(STAT_AGILITY) - 10.0f) * chrEntry->APPerStrenth * 2, 0.0f);        }    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    //add dynamic flat mods    if (!ranged)    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)            attPowerMod += int32(GetArmor() / (*iter)->GetAmount());    }    float attPowerMultiplier = GetModifierValue(unitMod, TOTAL_PCT) - 1.0f;    SetInt32Value(index, (uint32)base_attPower); // UNIT_FIELD_(RANGED)_ATTACK_POWER field    SetInt32Value(index_mod, (uint32)attPowerMod); // UNIT_FIELD_(RANGED)_ATTACK_POWER_MODS field    SetFloatValue(index_mult, attPowerMultiplier); // UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field    Pet* pet = GetPet();                                //update pet's AP    //automatically update weapon damage after attack power modification    if (ranged)        UpdateDamagePhysical(RANGED_ATTACK);    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();    }    RecalculatePetsScalingAttackPower();    RecalculatePetsScalingDamageDone();}

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* entry = sChrClassesStore.LookupEntry(getClass());    UnitMods unitMod_pos = ranged ? UNIT_MOD_ATTACK_POWER_RANGED_POS : UNIT_MOD_ATTACK_POWER_POS;    UnitMods unitMod_neg = ranged ? UNIT_MOD_ATTACK_POWER_RANGED_NEG : UNIT_MOD_ATTACK_POWER_NEG;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mod_pos = UNIT_FIELD_ATTACK_POWER_MOD_POS;    uint16 index_mod_neg = UNIT_FIELD_ATTACK_POWER_MOD_NEG;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        val2 = (level + std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f)) * entry->RAPPerAgility;        index_mod_pos = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS;        index_mod_neg = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;    }    else    {        // This is general.        float strengthValue = std::max((GetStat(STAT_STRENGTH) - 10.0f) * entry->APPerStrenth, 0.0f);        float agilityValue = std::max((GetStat(STAT_AGILITY) - 10.0f) * entry->APPerAgility, 0.0f);        // This is specific.        switch (getClass())        {        case CLASS_HUNTER: // in the case of Rogues, Hunters, and Shamans, each point of Agility will add 2 AP        case CLASS_ROGUE:        case CLASS_SHAMAN:            agilityValue = std::max(GetStat(STAT_AGILITY) * 2, 0.0f);            break;        case CLASS_WARRIOR: // Warriors, Paladins, and Death Knights will gain 2 AP from each point of Strength.        case CLASS_PALADIN:        case CLASS_DEATH_KNIGHT:            strengthValue = std::max(GetStat(STAT_STRENGTH) * 2, 0.0f);            break;        case CLASS_DRUID: //  Druids will gain 2 AP from Agility in Bear/Cat form. You have NO strenght in Bear form.            if (IsInFeralForm())                if (GetShapeshiftForm() == FORM_CAT || GetShapeshiftForm() == FORM_BEAR)                    agilityValue = std::max(GetStat(STAT_AGILITY) * 2, 0.0f);            break;        }        val2 = strengthValue + agilityValue;    }    SetModifierValue(unitMod_pos, BASE_VALUE, val2);    float base_attPower = (GetModifierValue(unitMod_pos, BASE_VALUE) - GetModifierValue(unitMod_neg, BASE_VALUE)) * (GetModifierValue(unitMod_pos, BASE_PCT) + (1 - GetModifierValue(unitMod_neg, BASE_PCT)));    float attPowerMod_pos = GetModifierValue(unitMod_pos, TOTAL_VALUE);    float attPowerMod_neg = GetModifierValue(unitMod_neg, TOTAL_VALUE);    //add dynamic flat mods    if (!ranged)    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)        {            // always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)            int32 attPowerMod = int32(GetArmor() / (*iter)->GetAmount());            if (attPowerMod > 0)                attPowerMod_pos += attPowerMod;            else                attPowerMod_neg -= attPowerMod;        }    }    float attPowerMultiplier = (GetModifierValue(unitMod_pos, TOTAL_PCT) + (1 - GetModifierValue(unitMod_neg, TOTAL_PCT))) - 1.0f;        SetInt32Value(index, (uint32)base_attPower); //UNIT_FIELD_(RANGED)_ATTACK_POWER field    SetInt32Value(index_mod_pos, (uint32) attPowerMod_pos);          //UNIT_FIELD_(RANGED)_ATTACK_POWER_MOD_POS field    SetInt32Value(index_mod_neg, (uint32) attPowerMod_neg);          //UNIT_FIELD_(RANGED)_ATTACK_POWER_MOD_NEG field    SetFloatValue(index_mult, attPowerMultiplier);          //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field    Pet* pet = GetPet();                                //update pet's AP    Guardian* guardian = GetGuardianPet();    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->IsHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At melee attack power change for DK pet            pet->UpdateAttackPowerAndDamage();//.........这里部分代码省略.........

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mod = UNIT_FIELD_ATTACK_POWER_MODS;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        index_mod = UNIT_FIELD_RANGED_ATTACK_POWER_MODS;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;        switch (getClass())        {            case CLASS_HUNTER:                val2 = level * 2.0f + GetStat(STAT_AGILITY) - 10.0f;                break;            case CLASS_ROGUE:                val2 = level + GetStat(STAT_AGILITY) - 10.0f;                break;            case CLASS_WARRIOR:                val2 = level + GetStat(STAT_AGILITY) - 10.0f;                break;            case CLASS_DRUID:                switch (GetShapeshiftForm())                {                    case FORM_CAT:                    case FORM_BEAR:                    case FORM_DIREBEAR:                        val2 = 0.0f; break;                    default:                        val2 = GetStat(STAT_AGILITY) - 10.0f; break;                }                break;            default: val2 = GetStat(STAT_AGILITY) - 10.0f; break;        }    }    else    {        switch (getClass())        {            case CLASS_WARRIOR:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_PALADIN:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_DEATH_KNIGHT:                val2 = level * 3.0f + GetStat(STAT_STRENGTH) * 2.0f - 20.0f;                break;            case CLASS_ROGUE:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_HUNTER:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_SHAMAN:                val2 = level * 2.0f + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20.0f;                break;            case CLASS_DRUID:            {                // Check if Predatory Strikes is skilled                float mLevelMult = 0.0f;                float weapon_bonus = 0.0f;                if (IsInFeralForm())                {                    Unit::AuraEffectList const& mDummy = GetAuraEffectsByType(SPELL_AURA_DUMMY);                    for (Unit::AuraEffectList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr)                    {                        AuraEffect* aurEff = *itr;                        if (aurEff->GetSpellInfo()->SpellIconID == 1563)                        {                            switch (aurEff->GetEffIndex())                            {                                case 0: // Predatory Strikes (effect 0)                                    mLevelMult = CalculatePct(1.0f, aurEff->GetAmount());                                    break;                                case 1: // Predatory Strikes (effect 1)                                    if (Item* mainHand = m_items[EQUIPMENT_SLOT_MAINHAND])                                    {                                        // also gains % attack power from equipped weapon                                        ItemTemplate const* proto = mainHand->GetTemplate();                                        if (!proto)                                            continue;                                        weapon_bonus = CalculatePct(float(proto->getFeralBonus()), aurEff->GetAmount());                                    }                                    break;                                default:                                    break;                            }                        }                    }                }//.........这里部分代码省略.........

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* entry = sChrClassesStore.LookupEntry(getClass());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;        val2 = (level + std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f)) * entry->RAPPerAgility;    }    else    {        float strengthValue = std::max((GetStat(STAT_STRENGTH) - 10.0f) * entry->APPerStrenth, 0.0f);        float agilityValue = std::max((GetStat(STAT_AGILITY) - 10.0f) * entry->APPerAgility, 0.0f);        if (GetShapeshiftForm() == FORM_CAT || GetShapeshiftForm() == FORM_BEAR)            agilityValue += std::max((GetStat(STAT_AGILITY) - 10.0f) * 2, 0.0f);        val2 = strengthValue + agilityValue;    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMultiplier = GetModifierValue(unitMod, TOTAL_PCT) - 1.0f;    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    //add dynamic flat mods    if (!ranged)    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)            attPowerMod += int32(GetArmor() / (*iter)->GetAmount());    }    SetInt32Value(index, uint32(base_attPower + attPowerMod));            // UNIT_FIELD_(RANGED)_ATTACK_POWER field    SetFloatValue(index_mult, attPowerMultiplier);          // UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field    Pet* pet = GetPet();                                //update pet's AP    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->isHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }}

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* entry = sChrClassesStore.AssertEntry(getClass());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mod = UNIT_FIELD_ATTACK_POWER_MOD_POS;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        index_mod = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;    }    if (!HasAuraType(SPELL_AURA_OVERRIDE_ATTACK_POWER_BY_SP_PCT))    {        if (!ranged)        {            float strengthValue = std::max(GetStat(STAT_STRENGTH) * entry->AttackPowerPerStrength, 0.0f);            float agilityValue = std::max(GetStat(STAT_AGILITY) * entry->AttackPowerPerAgility, 0.0f);            SpellShapeshiftFormEntry const* form = sSpellShapeshiftFormStore.LookupEntry(GetShapeshiftForm());            // Directly taken from client, SHAPESHIFT_FLAG_AP_FROM_STRENGTH ?            if (form && form->Flags & 0x20)                agilityValue += std::max(GetStat(STAT_AGILITY) * entry->AttackPowerPerStrength, 0.0f);            val2 = strengthValue + agilityValue;        }        else            val2 = (level + std::max(GetStat(STAT_AGILITY), 0.0f)) * entry->RangedAttackPowerPerAgility;    }    else    {        int32 minSpellPower = GetInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS);        for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)            minSpellPower = std::min(minSpellPower, GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i));        val2 = CalculatePct(float(minSpellPower), GetFloatValue(PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT));    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower  = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    float attPowerMultiplier = GetModifierValue(unitMod, TOTAL_PCT) - 1.0f;    //add dynamic flat mods    if (!ranged)    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)            // always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)            attPowerMod += int32(GetArmor() / (*iter)->GetAmount());    }    SetInt32Value(index, (uint32)base_attPower);            //UNIT_FIELD_(RANGED)_ATTACK_POWER field    SetInt32Value(index_mod, (uint32)attPowerMod);          //UNIT_FIELD_(RANGED)_ATTACK_POWER_MOD_POS field    SetFloatValue(index_mult, attPowerMultiplier);          //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field    Pet* pet = GetPet();                                //update pet's AP    Guardian* guardian = GetGuardianPet();    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->IsHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (Item* offhand = GetWeaponForAttack(OFF_ATTACK, true))            if (CanDualWield() || offhand->GetTemplate()->GetFlags3() & ITEM_FLAG3_ALWAYS_ALLOW_DUAL_WIELD)                UpdateDamagePhysical(OFF_ATTACK);        if (HasAuraType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER) ||            HasAuraType(SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER) ||            HasAuraType(SPELL_AURA_OVERRIDE_SPELL_POWER_BY_AP_PCT))            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At melee attack power change for DK pet            pet->UpdateAttackPowerAndDamage();        if (guardian && guardian->IsSpiritWolf()) // At melee attack power change for Shaman feral spirit            guardian->UpdateAttackPowerAndDamage();    }}

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* entry = sChrClassesStore.LookupEntry(getClass());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        val2 = (level + std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f)) * entry->RAPPerAgility;    }    else    {        float strengthValue = std::max((GetStat(STAT_STRENGTH) - 10.0f) * entry->APPerStrenth, 0.0f);        float agilityValue = std::max((GetStat(STAT_AGILITY) - 10.0f) * entry->APPerAgility, 0.0f);        SpellShapeshiftFormEntry const* form = sSpellShapeshiftFormStore.LookupEntry(GetShapeshiftForm());        // Directly taken from client, SHAPESHIFT_FLAG_AP_FROM_STRENGTH ?        if (form && form->flags1 & 0x20)            agilityValue += std::max((GetStat(STAT_AGILITY) - 10.0f) * entry->APPerStrenth, 0.0f);        val2 = strengthValue + agilityValue;    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower  = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    //add dynamic flat mods    if (!ranged)    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)            // always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)            attPowerMod += int32(GetArmor() / (*iter)->GetAmount());    }    SetInt32Value(index, (uint32)base_attPower);            //UNIT_FIELD_(RANGED)_ATTACK_POWER field    Pet* pet = GetPet();                                //update pet's AP    Guardian* guardian = GetGuardianPet();    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->IsHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At melee attack power change for DK pet            pet->UpdateAttackPowerAndDamage();        if (guardian && guardian->IsSpiritWolf()) // At melee attack power change for Shaman feral spirit            guardian->UpdateAttackPowerAndDamage();    }}

void Player::UpdateAttackPowerAndDamage(bool ranged){    float val2 = 0.0f;    float level = float(getLevel());    ChrClassesEntry const* entry = sChrClassesStore.LookupEntry(getClass());    UnitMods unitMod = ranged ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;    uint16 index = UNIT_FIELD_ATTACK_POWER;    uint16 index_mod_pos = UNIT_FIELD_ATTACK_POWER_MOD_POS;    uint16 index_mod_neg = UNIT_FIELD_ATTACK_POWER_MOD_NEG;    uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;    if (ranged)    {        index = UNIT_FIELD_RANGED_ATTACK_POWER;        index_mod_pos = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS;        index_mod_neg = UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG;        index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;        val2 = (level + std::max(GetStat(STAT_AGILITY) - 10.0f, 0.0f)) * entry->RAPPerAgility;    }    else    {        float strengthValue = std::max((GetStat(STAT_STRENGTH) - 10.0f) * entry->APPerStrenth, 0.0f);        float agilityValue = std::max((GetStat(STAT_AGILITY) - 10.0f) * entry->APPerAgility, 0.0f);        if (GetShapeshiftForm() == FORM_CAT || GetShapeshiftForm() == FORM_BEAR)            agilityValue += std::max((GetStat(STAT_AGILITY) - 10.0f) * 2, 0.0f);        val2 = strengthValue + agilityValue;    }    SetModifierValue(unitMod, BASE_VALUE, val2);    float base_attPower = GetModifierValue(unitMod, BASE_VALUE) * GetModifierValue(unitMod, BASE_PCT);    float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);    float attPowerMultiplier = GetModifierValue(unitMod, TOTAL_PCT) - 1.0f;    //add dynamic flat mods    if (!ranged && HasAuraType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR))    {        AuraEffectList const& mAPbyArmor = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);        for (AuraEffectList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)        {            // always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)            int32 temp = int32(GetArmor() / (*iter)->GetAmount());            if (temp > 0)                attPowerMod += temp;            else                attPowerMod -= temp;        }    }    if (HasAuraType(SPELL_AURA_OVERRIDE_AP_BY_SPELL_POWER_PCT))    {        int32 ApBySpellPct = 0;        int32 spellPower = ToPlayer()->GetBaseSpellPowerBonus();                    // SpellPower from Weapon        spellPower += std::max(0, int32(ToPlayer()->GetStat(STAT_INTELLECT)) - 10); // SpellPower from intellect        AuraEffectList const& mAPFromSpellPowerPct = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_AP_BY_SPELL_POWER_PCT);        for (AuraEffectList::const_iterator i = mAPFromSpellPowerPct.begin(); i != mAPFromSpellPowerPct.end(); ++i)            ApBySpellPct += CalculatePct(spellPower, (*i)->GetAmount());        if (ApBySpellPct > 0)        {            SetInt32Value(index, uint32(ApBySpellPct));     //UNIT_FIELD_(RANGED)_ATTACK_POWER field            SetFloatValue(index_mult, attPowerMultiplier);  //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field        }        else        {            SetInt32Value(index, uint32(base_attPower + attPowerMod));  //UNIT_FIELD_(RANGED)_ATTACK_POWER field            SetFloatValue(index_mult, attPowerMultiplier);              //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field        }    }    else    {        SetInt32Value(index, uint32(base_attPower + attPowerMod));  //UNIT_FIELD_(RANGED)_ATTACK_POWER field        SetFloatValue(index_mult, attPowerMultiplier);              //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field    }    Pet* pet = GetPet();                                //update pet's AP    //automatically update weapon damage after attack power modification    if (ranged)    {        UpdateDamagePhysical(RANGED_ATTACK);        if (pet && pet->isHunterPet()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }    else    {        UpdateDamagePhysical(BASE_ATTACK);        if (CanDualWield() && haveOffhandWeapon())           //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon            UpdateDamagePhysical(OFF_ATTACK);        if (getClass() == CLASS_SHAMAN || getClass() == CLASS_PALADIN)                      // mental quickness            UpdateSpellDamageAndHealingBonus();        if (pet && pet->IsPetGhoul()) // At ranged attack change for hunter pet            pet->UpdateAttackPowerAndDamage();    }}