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

void Pet::UpdateDamagePhysical(WeaponAttackType attType){    UnitMods unitMod;    if (attType == BASE_ATTACK)        unitMod  = UNIT_MOD_DAMAGE_MAINHAND;    else if (attType == RANGED_ATTACK)       unitMod  = UNIT_MOD_DAMAGE_RANGED;    else        return;    float att_speed = float(GetAttackTime(attType))/1000.0f;    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed;    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(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, 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;    if (attType == BASE_ATTACK)    {        SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);        SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);    }    else if (attType == RANGED_ATTACK)    {        SetStatFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, mindamage);        SetStatFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, maxdamage);    }}

void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, float& min_damage, float& max_damage){    UnitMods unitMod;    UnitMods attPower;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            attPower = UNIT_MOD_ATTACK_POWER;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            attPower = UNIT_MOD_ATTACK_POWER;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            attPower = UNIT_MOD_ATTACK_POWER_RANGED;            break;    }    float att_speed = GetAPMultiplier(attType,normalized);    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed;    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(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (IsInFeralForm())                                    //check if player is druid and in cat or bear forms    {        uint32 lvl = getLevel();        if (lvl > 60) lvl = 60;        weapon_mindamage = lvl*0.85f*att_speed;        weapon_maxdamage = lvl*1.25f*att_speed;    }    else if (!IsUseEquippedWeapon(attType == BASE_ATTACK))   //check if player not in form but still can't use weapon (broken/etc)    {        weapon_mindamage = BASE_MINDAMAGE;        weapon_maxdamage = BASE_MAXDAMAGE;    }    else if (attType == RANGED_ATTACK)                       //add ammo DPS to ranged damage    {        weapon_mindamage += GetAmmoDPS() * att_speed;        weapon_maxdamage += GetAmmoDPS() * att_speed;    }    if (attType == BASE_ATTACK)    {        int32 speed_mod = GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKSPEED);        base_pct *= 100.0f/(100.0f+float(speed_mod/2));    }    min_damage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    max_damage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;}

void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& min_damage, float& max_damage){    UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    float att_speed = GetAPMultiplier(attType, normalized);    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed;    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) : 1.0f;    float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (IsInFeralForm())                                    //check if player is druid and in cat or bear forms    {        uint8 lvl = getLevel();        if (lvl > 60)            lvl = 60;        weapon_mindamage = lvl*0.85f*att_speed;        weapon_maxdamage = lvl*1.25f*att_speed;    }    else if (!CanUseAttackType(attType))      //check if player not in form but still can't use (disarm case)    {        //cannot use ranged/off attack, set values to 0        if (attType != BASE_ATTACK)        {            min_damage = 0;            max_damage = 0;            return;        }        weapon_mindamage = BASE_MINDAMAGE;        weapon_maxdamage = BASE_MAXDAMAGE;    }    /*    TODO: Is this still needed after ammo has been removed?    else if (attType == RANGED_ATTACK)                       //add ammo DPS to ranged damage    {        weapon_mindamage += ammo * att_speed;        weapon_maxdamage += ammo * att_speed;    }*/    min_damage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    max_damage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;}

void Creature::UpdateDamagePhysical(WeaponAttackType attType){    UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    //float att_speed = float(GetAttackTime(attType))/1000.0f;    float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    /* difference in AP between current attack power and base value from DB */    // creature's damage in battleground is calculated in Creature::SelectLevel    // so don't change it with ap and dmg multipliers    float att_pwr_change = GetTotalAttackPowerValue(attType) - GetCreatureTemplate()->attackpower;    float base_value  = ((GetMap()->IsBattleground()) ? GetModifierValue(unitMod, BASE_VALUE) : (GetModifierValue(unitMod, BASE_VALUE) + (att_pwr_change * GetAPMultiplier(attType, false) / 14.0f)));    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = GetModifierValue(unitMod, TOTAL_PCT);    float dmg_multiplier = ((GetMap()->IsBattleground()) ? 1.0f : GetCreatureTemplate()->dmg_multiplier);    if (!CanUseAttackType(attType))    {        weapon_mindamage = 0;        weapon_maxdamage = 0;    }    float mindamage = ((base_value + weapon_mindamage) * dmg_multiplier * base_pct + total_value) * total_pct;    float maxdamage = ((base_value + weapon_maxdamage) * dmg_multiplier * base_pct + total_value) * total_pct;    switch (attType)    {        case BASE_ATTACK:        default:            SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);            break;        case OFF_ATTACK:            SetStatFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, maxdamage);            break;        case RANGED_ATTACK:            SetStatFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, maxdamage);            break;    }}

void 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 Creature::UpdateDamagePhysical(WeaponAttackType attType){    UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    //float att_speed = float(GetAttackTime(attType))/1000.0f;    float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    /* difference in AP between current attack power and base value from DB */    float att_pwr_change = GetTotalAttackPowerValue(attType) - GetCreatureTemplate()->attackpower;    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + (att_pwr_change * GetAPMultiplier(attType, false) / 14.0f);    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = GetModifierValue(unitMod, TOTAL_PCT);    float dmg_multiplier = GetCreatureTemplate()->dmg_multiplier;    if (!CanUseAttackType(attType))    {        weapon_mindamage = 0;        weapon_maxdamage = 0;    }    float mindamage = ((base_value + weapon_mindamage) * dmg_multiplier * base_pct + total_value) * total_pct;    float maxdamage = ((base_value + weapon_maxdamage) * dmg_multiplier * base_pct + total_value) * total_pct;    switch (attType)    {        case BASE_ATTACK:        default:            SetStatFloatValue(UNIT_FIELD_MIN_DAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAX_DAMAGE, maxdamage);            break;        case OFF_ATTACK:            SetStatFloatValue(UNIT_FIELD_MIN_OFF_HAND_DAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAX_OFF_HAND_DAMAGE, maxdamage);            break;        case RANGED_ATTACK:            SetStatFloatValue(UNIT_FIELD_MIN_RANGED_DAMAGE, mindamage);            SetStatFloatValue(UNIT_FIELD_MAX_RANGED_DAMAGE, maxdamage);            break;    }}

void Creature::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& minDamage, float& maxDamage){     UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    if (attType == OFF_ATTACK && !haveOffhandWeapon())    {        minDamage = 0.0f;        maxDamage = 0.0f;        return;    }    float weaponMinDamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weaponMaxDamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (!CanUseAttackType(attType)) // disarm case    {        weaponMinDamage = 0.0f;        weaponMaxDamage = 0.0f;    }	// pussywizard: subtract value from database till its fixed (the way it worked before creature_levelstats damage implementation)	float attackPower      = GetTotalAttackPowerValue(attType) - (attType == RANGED_ATTACK ? GetCreatureTemplate()->rangedattackpower : GetCreatureTemplate()->attackpower);    float baseValue        = GetModifierValue(unitMod, BASE_VALUE) + (attackPower * GetAPMultiplier(attType, normalized) / 14.0f);    float basePct          = GetModifierValue(unitMod, BASE_PCT);    float totalValue       = GetModifierValue(unitMod, TOTAL_VALUE);    float totalPct         = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) : 1.0f;    float dmgMultiplier    = GetCreatureTemplate()->dmg_multiplier; // = dmg_multiplier * _GetDamageMod(rank);    minDamage = ((weaponMinDamage + baseValue) * dmgMultiplier * basePct + totalValue) * totalPct;    maxDamage = ((weaponMaxDamage + baseValue) * dmgMultiplier * basePct + totalValue) * totalPct;	// pussywizard: crashfix (casting negative to uint => min > max => assertion in urand)	if (minDamage < 0.0f || minDamage > 1000000000.0f)		minDamage = 0.0f;	if (maxDamage < 0.0f || maxDamage > 1000000000.0f)		maxDamage = 0.0f;	if (minDamage > maxDamage)		minDamage = maxDamage;}

void Guardian::UpdateDamagePhysical(WeaponAttackType attType){     if (attType > BASE_ATTACK)        return;    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;    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;	if (mindamage < 0.0f || mindamage > 10000000.0f)		mindamage = BASE_MINDAMAGE;	if (maxdamage < 0.0f || maxdamage > 10000000.0f)		maxdamage = BASE_MAXDAMAGE;	if (mindamage > maxdamage)		mindamage = maxdamage;    //  Pet's base damage changes depending on happiness    if (IsHunterPet() && attType == BASE_ATTACK)    {        switch (ToPet()->GetHappinessState())        {            case HAPPY:                // 125% of normal damage                mindamage = mindamage * 1.25f;                maxdamage = maxdamage * 1.25f;                break;            case CONTENT:                // 100% of normal damage, nothing to modify                break;            case UNHAPPY:                // 75% of normal damage                mindamage = mindamage * 0.75f;                maxdamage = maxdamage * 0.75f;                break;        }    }    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Guardian::UpdateDamagePhysical(WeaponAttackType attType){    if (attType > BASE_ATTACK)        return;    float bonusDamage = 0.0f;    if (m_owner->GetTypeId() == TYPEID_PLAYER)    {        switch (GetEntry())        {            //force of nature            case 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;                break;            }            //greater fire elemental            case 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;                break;            }            default :                break;        }    }    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;    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& minDamage, float& maxDamage){    UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    float attackPowerMod = std::max(GetAPMultiplier(attType, normalized), 0.25f);    float baseValue  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType) / 3.5f * attackPowerMod;    float basePct    = GetModifierValue(unitMod, BASE_PCT);    float totalValue = GetModifierValue(unitMod, TOTAL_VALUE);    float totalPct   = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) : 1.0f;    float weaponMinDamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weaponMaxDamage = GetWeaponDamageRange(attType, MAXDAMAGE);    SpellShapeshiftFormEntry const* shapeshift = sSpellShapeshiftFormStore.LookupEntry(GetShapeshiftForm());    if (shapeshift && shapeshift->CombatRoundTime)    {        weaponMinDamage = weaponMinDamage * shapeshift->CombatRoundTime / 1000.0f / attackPowerMod;        weaponMaxDamage = weaponMaxDamage * shapeshift->CombatRoundTime / 1000.0f / attackPowerMod;    }    else if (!CanUseAttackType(attType)) // check if player not in form but still can't use (disarm case)    {        // cannot use ranged/off attack, set values to 0        if (attType != BASE_ATTACK)        {            minDamage = 0;            maxDamage = 0;            return;        }        weaponMinDamage = BASE_MINDAMAGE;        weaponMaxDamage = BASE_MAXDAMAGE;    }    minDamage = ((weaponMinDamage + baseValue) * basePct + totalValue) * totalPct;    maxDamage = ((weaponMaxDamage + baseValue) * basePct + totalValue) * totalPct;}

void Pet::UpdateDamagePhysical(WeaponAttackType attType){    if (attType > BASE_ATTACK)        return;    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;    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);    //  Pet's base damage changes depending on happiness    if (getPetType() == HUNTER_PET && attType == BASE_ATTACK)    {        switch(GetHappinessState())        {            case HAPPY:                // 125% of normal damage                total_pct *= 1.25f;                break;            case CONTENT:                // 100% of normal damage, nothing to modify                break;            case UNHAPPY:                // 75% of normal damage                total_pct *= 0.75f;                break;        }    }    else if (getPetType() == SUMMON_PET)    {            Unit* owner = GetOwner();        if (owner && owner->getClass() == CLASS_PRIEST)            total_value += 0.3f * owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW);    }    float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Creature::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& minDamage, float& maxDamage){    float variance = 1.0f;    UnitMods unitMod;    switch (attType)    {    case BASE_ATTACK:    default:        variance = GetCreatureTemplate()->BaseVariance;        unitMod = UNIT_MOD_DAMAGE_MAINHAND;        break;    case OFF_ATTACK:        variance = GetCreatureTemplate()->BaseVariance;        unitMod = UNIT_MOD_DAMAGE_OFFHAND;        break;    case RANGED_ATTACK:        variance = GetCreatureTemplate()->RangeVariance;        unitMod = UNIT_MOD_DAMAGE_RANGED;        break;    }    if (attType == OFF_ATTACK && !haveOffhandWeapon())    {        minDamage = 0.0f;        maxDamage = 0.0f;        return;    }    float weaponMinDamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weaponMaxDamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (!CanUseAttackType(attType)) // disarm case    {        weaponMinDamage = 0.0f;        weaponMaxDamage = 0.0f;    }    float attackPower      = GetTotalAttackPowerValue(attType);    float attackSpeedMulti = GetAPMultiplier(attType, normalized);    float baseValue        = GetModifierValue(unitMod, BASE_VALUE) + (attackPower / 14.0f) * variance;    float basePct          = GetModifierValue(unitMod, BASE_PCT) * attackSpeedMulti;    float totalValue       = GetModifierValue(unitMod, TOTAL_VALUE);    float totalPct         = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) : 1.0f;    float dmgMultiplier    = GetCreatureTemplate()->ModDamage; // = ModDamage * _GetDamageMod(rank);    minDamage = ((weaponMinDamage + baseValue) * dmgMultiplier * basePct + totalValue) * totalPct;    maxDamage = ((weaponMaxDamage + baseValue) * dmgMultiplier * basePct + totalValue) * totalPct;}

void Creature::UpdateDamagePhysical(WeaponAttackType attType){    if(attType > BASE_ATTACK)        return;    UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND;    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType);    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = GetModifierValue(unitMod, TOTAL_PCT);    float dmg_multiplier = GetCreatureInfo()->dmg_multiplier;    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 * dmg_multiplier;    float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct * dmg_multiplier;    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Guardian::UpdateDamagePhysical(WeaponAttackType attType){    if (attType > BASE_ATTACK)        return;    float bonusDamage = 0.0f;    if (Unit* owner = GetOwner())    {        //force of nature        if (GetEntry() == 1964)        {            int32 spellDmg = int32(owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE)) - owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE);            if (spellDmg > 0)                bonusDamage = spellDmg * 0.09f;        }        //greater fire elemental        else if (GetEntry() == 15438)        {            if (Unit* shaman = owner->GetOwner())            {                int32 spellDmg = int32(shaman->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - shaman->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);                if (spellDmg > 0)                    bonusDamage = spellDmg * 0.4f;            }        }        // shadowfiend 65.7% per 10 hits so 6.57 per hit        else if (GetEntry() == 19668)        {            if (Unit* owner = GetOwner())            {                int32 spellDmg = int32(owner->SpellBaseDamageBonus(SPELL_SCHOOL_MASK_SHADOW));                if (spellDmg > 0)                    bonusDamage = spellDmg * 0.0657f;            }        }    }    UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND;    float att_speed = float(GetAttackTime(BASE_ATTACK))/1000.0f;    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed  + bonusDamage;    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = GetModifierValue(unitMod, TOTAL_PCT);    float weapon_mindamage = GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE);    int32 speed_mod = GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKSPEED);    base_pct *= 100.0f/(100.0f+float(speed_mod/2));    float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;    //  Pet's base damage changes depending on happiness    if (isHunterPet() && attType == BASE_ATTACK)    {        switch (ToPet()->GetHappinessState())        {            case HAPPY:                // 125% of normal damage                mindamage = mindamage * 1.25f;                maxdamage = maxdamage * 1.25f;                break;            case CONTENT:                // 100% of normal damage, nothing to modify                break;            case UNHAPPY:                // 75% of normal damage                mindamage = mindamage * 0.75f;                maxdamage = maxdamage * 0.75f;                break;        }    }    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, float& min_damage, float& max_damage){    UnitMods unitMod;    UnitMods attPower;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            attPower = UNIT_MOD_ATTACK_POWER;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            attPower = UNIT_MOD_ATTACK_POWER;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            attPower = UNIT_MOD_ATTACK_POWER_RANGED;            break;    }    float att_speed = GetAPMultiplier(attType, normalized);    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType) / 14.0f * att_speed;    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(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (IsInFeralForm())                                    // check if player is druid and in cat or bear forms, non main hand attacks not allowed for this mode so not check attack type    {        float weaponSpeed = GetAttackTime(attType) / 1000.0f;        switch (GetShapeshiftForm())        {            case FORM_CAT:                weapon_mindamage = weapon_mindamage / weaponSpeed;                weapon_maxdamage = weapon_maxdamage / weaponSpeed;                break;            case FORM_BEAR:                weapon_mindamage = weapon_mindamage / weaponSpeed + weapon_mindamage / 2.5f;                weapon_maxdamage = weapon_maxdamage / weaponSpeed + weapon_maxdamage / 2.5f;                break;        }    }    else if (!CanUseEquippedWeapon(attType))                // check if player not in form but still can't use weapon (broken/etc)    {        weapon_mindamage = BASE_MINDAMAGE;        weapon_maxdamage = BASE_MAXDAMAGE;    }    else if (attType == RANGED_ATTACK)                      // add ammo DPS to ranged damage    {        weapon_mindamage += GetAmmoDPS() * att_speed;        weapon_maxdamage += GetAmmoDPS() * att_speed;    }    min_damage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    max_damage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;}

void Guardian::UpdateDamagePhysical(WeaponAttackType attType){    if (attType > BASE_ATTACK)        return;    float bonusDamage = 0.0f;    if (m_owner->GetTypeId() == TYPEID_PLAYER)    {        //force of nature        if (GetEntry() == ENTRY_TREANT)        {            int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE);            if (spellDmg > 0)                bonusDamage = spellDmg * 0.09f;        }        //greater fire elemental        else if (GetEntry() == ENTRY_FIRE_ELEMENTAL)        {            int32 spellDmg = int32(m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - m_owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);            if (spellDmg > 0)                bonusDamage = spellDmg * 0.4f;        }    }    UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND;    float att_speed = float(GetAttackTime(BASE_ATTACK))/1000.0f;    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed  + bonusDamage;    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = GetModifierValue(unitMod, TOTAL_PCT);    float weapon_mindamage = GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE);    float mindamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    float maxdamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;    //  Pet's base damage changes depending on happiness    if (isHunterPet() && attType == BASE_ATTACK)    {        switch(ToPet()->GetHappinessState())        {            case HAPPY:                // 125% of normal damage                mindamage = mindamage * 1.25f;                maxdamage = maxdamage * 1.25f;                break;            case CONTENT:                // 100% of normal damage, nothing to modify                break;            case UNHAPPY:                // 75% of normal damage                mindamage = mindamage * 0.75f;                maxdamage = maxdamage * 0.75f;                break;        }    }    Unit::AuraEffectList const& mDummy = GetAuraEffectsByType(SPELL_AURA_MOD_ATTACKSPEED);    for (Unit::AuraEffectList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr)    {        switch ((*itr)->GetSpellProto()->Id)        {            case 61682:            case 61683:                AddPctN(mindamage, -(*itr)->GetAmount());                AddPctN(maxdamage, -(*itr)->GetAmount());                break;            default:                break;        }    }    SetStatFloatValue(UNIT_FIELD_MINDAMAGE, mindamage);    SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, maxdamage);}

void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& min_damage, float& max_damage){    UnitMods unitMod;    switch (attType)    {        case BASE_ATTACK:        default:            unitMod = UNIT_MOD_DAMAGE_MAINHAND;            break;        case OFF_ATTACK:            unitMod = UNIT_MOD_DAMAGE_OFFHAND;            break;        case RANGED_ATTACK:            unitMod = UNIT_MOD_DAMAGE_RANGED;            break;    }    float att_speed = GetAPMultiplier(attType, normalized);    float base_value  = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType) / 14.0f * att_speed;    float base_pct    = GetModifierValue(unitMod, BASE_PCT);    float total_value = GetModifierValue(unitMod, TOTAL_VALUE);    float total_pct   = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) : 1.0f;    float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);    float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);    if (IsInFeralForm())                                    //check if player is druid and in cat or bear forms    {        float weaponSpeed = BASE_ATTACK_TIME / 1000.f;        // Maybe fix that in GetWeaponForAttack ?        if (Item* weapon = GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND))            if (weapon->GetTemplate()->Class == ITEM_CLASS_WEAPON)                weaponSpeed = float(0.001f * weapon->GetTemplate()->Delay);         if (GetShapeshiftForm() == FORM_CAT)        {            weapon_mindamage = weapon_mindamage / weaponSpeed;            weapon_maxdamage = weapon_maxdamage / weaponSpeed;        }        else if (GetShapeshiftForm() == FORM_BEAR)        {            weapon_mindamage = weapon_mindamage / weaponSpeed + weapon_mindamage / 2.5;            weapon_maxdamage = weapon_maxdamage / weaponSpeed + weapon_maxdamage / 2.5;        }    }    else if (!CanUseAttackType(attType))      //check if player not in form but still can't use (disarm case)    {        //cannot use ranged/off attack, set values to 0        if (attType != BASE_ATTACK)        {            min_damage = 0;            max_damage = 0;            return;        }        weapon_mindamage = BASE_MINDAMAGE;        weapon_maxdamage = BASE_MAXDAMAGE;    }    min_damage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;    max_damage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;}