aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rwxr-xr-xsrc/server/game/Entities/Unit/Unit.cpp1408
1 files changed, 697 insertions, 711 deletions
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index 98adbfe7ab5..ac993d93520 100755
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -368,7 +368,7 @@ void Unit::SendMonsterMoveWithSpeed(float x, float y, float z, uint32 transitTim
}
else
{
- Traveller<Creature> traveller(*this->ToCreature());
+ Traveller<Creature> traveller(*ToCreature());
transitTime = traveller.GetTotalTrevelTimeTo(x, y, z);
}
}
@@ -500,7 +500,7 @@ void Unit::SendMonsterMoveExitVehicle(Position const* newPos)
SendMessageToSet(&data, true);
}
-void Unit::SendMonsterMoveTransport(Unit *vehicleOwner)
+void Unit::SendMonsterMoveTransport(Unit* vehicleOwner)
{
// TODO: Turn into BuildMonsterMoveTransport packet and allow certain variables (for npc movement aboard vehicles)
WorldPacket data(SMSG_MONSTER_MOVE_TRANSPORT, GetPackGUID().size()+vehicleOwner->GetPackGUID().size() + 47);
@@ -528,7 +528,7 @@ void Unit::resetAttackTimer(WeaponAttackType type)
m_attackTimer[type] = uint32(GetAttackTime(type) * m_modAttackSpeedPct[type]);
}
-bool Unit::IsWithinCombatRange(const Unit *obj, float dist2compare) const
+bool Unit::IsWithinCombatRange(const Unit* obj, float dist2compare) const
{
if (!obj || !IsInMap(obj)) return false;
@@ -543,7 +543,7 @@ bool Unit::IsWithinCombatRange(const Unit *obj, float dist2compare) const
return distsq < maxdist * maxdist;
}
-bool Unit::IsWithinMeleeRange(const Unit *obj, float dist) const
+bool Unit::IsWithinMeleeRange(const Unit* obj, float dist) const
{
if (!obj || !IsInMap(obj)) return false;
@@ -598,9 +598,9 @@ bool Unit::HasAuraTypeWithFamilyFlags(AuraType auraType, uint32 familyName, uint
return false;
}
-void Unit::DealDamageMods(Unit *pVictim, uint32 &damage, uint32* absorb)
+void Unit::DealDamageMods(Unit* victim, uint32 &damage, uint32* absorb)
{
- if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (pVictim->GetTypeId() == TYPEID_UNIT && pVictim->ToCreature()->IsInEvadeMode()))
+ if (!victim->isAlive() || victim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
{
if (absorb)
*absorb += damage;
@@ -614,13 +614,13 @@ void Unit::DealDamageMods(Unit *pVictim, uint32 &damage, uint32* absorb)
*absorb += (originalDamage - damage);
}
-uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDamage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask, SpellEntry const *spellProto, bool durabilityLoss)
+uint32 Unit::DealDamage(Unit* victim, uint32 damage, CleanDamage const* cleanDamage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask, SpellEntry const* spellProto, bool durabilityLoss)
{
- if (pVictim->IsAIEnabled)
- pVictim->GetAI()->DamageTaken(this, damage);
+ if (victim->IsAIEnabled)
+ victim->GetAI()->DamageTaken(this, damage);
if (IsAIEnabled)
- GetAI()->DamageDealt(pVictim, damage, damagetype);
+ GetAI()->DamageDealt(victim, damage, damagetype);
if (damagetype != NODAMAGE)
{
@@ -628,19 +628,19 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
if (spellProto)
{
if (!(spellProto->AttributesEx4 & SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS))
- pVictim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, spellProto->Id);
+ victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, spellProto->Id);
}
else
- pVictim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, 0);
+ victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, 0);
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
- AuraEffectList vCopyDamageCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_SHARE_DAMAGE_PCT));
+ AuraEffectList vCopyDamageCopy(victim->GetAuraEffectsByType(SPELL_AURA_SHARE_DAMAGE_PCT));
// copy damage to casters of this aura
for (AuraEffectList::iterator i = vCopyDamageCopy.begin(); i != vCopyDamageCopy.end(); ++i)
{
// Check if aura was removed during iteration - we don't need to work on such auras
- if (!((*i)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID())))
+ if (!((*i)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
continue;
// check damage school mask
if (((*i)->GetMiscValue() & damageSchoolMask) == 0)
@@ -653,14 +653,14 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
uint32 share = CalculatePctN(damage, (*i)->GetAmount());
- // TODO: check packets if damage is done by pVictim, or by attacker of pVictim
+ // TODO: check packets if damage is done by victim, or by attacker of victim
DealDamageMods(shareDamageTarget, share, NULL);
DealDamage(shareDamageTarget, share, NULL, NODAMAGE, GetSpellSchoolMask(spell), spell, false);
}
}
// Rage from Damage made (only from direct weapon damage)
- if (cleanDamage && damagetype == DIRECT_DAMAGE && this != pVictim && getPowerType() == POWER_RAGE)
+ if (cleanDamage && damagetype == DIRECT_DAMAGE && this != victim && getPowerType() == POWER_RAGE)
{
uint32 weaponSpeedHitFactor;
uint32 rage_damage = damage + cleanDamage->absorbed_damage;
@@ -697,85 +697,85 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
if (!damage)
{
// Rage from absorbed damage
- if (cleanDamage && cleanDamage->absorbed_damage && pVictim->getPowerType() == POWER_RAGE)
- pVictim->RewardRage(cleanDamage->absorbed_damage, 0, false);
+ if (cleanDamage && cleanDamage->absorbed_damage && victim->getPowerType() == POWER_RAGE)
+ victim->RewardRage(cleanDamage->absorbed_damage, 0, false);
return 0;
}
sLog->outStaticDebug("DealDamageStart");
- uint32 health = pVictim->GetHealth();
+ uint32 health = victim->GetHealth();
sLog->outDetail("deal dmg:%d to health:%d ", damage, health);
// duel ends when player has 1 or less hp
bool duel_hasEnded = false;
- if (pVictim->GetTypeId() == TYPEID_PLAYER && pVictim->ToPlayer()->duel && damage >= (health-1))
+ if (victim->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->duel && damage >= (health-1))
{
// prevent kill only if killed in duel and killed by opponent or opponent controlled creature
- if (pVictim->ToPlayer()->duel->opponent == this || pVictim->ToPlayer()->duel->opponent->GetGUID() == GetOwnerGUID())
+ if (victim->ToPlayer()->duel->opponent == this || victim->ToPlayer()->duel->opponent->GetGUID() == GetOwnerGUID())
damage = health - 1;
duel_hasEnded = true;
}
- if (GetTypeId() == TYPEID_PLAYER && this != pVictim)
+ if (GetTypeId() == TYPEID_PLAYER && this != victim)
{
Player* killer = ToPlayer();
// in bg, count dmg if victim is also a player
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
+ if (victim->GetTypeId() == TYPEID_PLAYER)
if (Battleground *bg = killer->GetBattleground())
bg->UpdatePlayerScore(killer, SCORE_DAMAGE_DONE, damage);
- killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE, damage, 0, pVictim);
+ killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE, damage, 0, victim);
killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT, damage);
}
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
- pVictim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED, damage);
- else if (!pVictim->IsControlledByPlayer() || pVictim->IsVehicle())
+ if (victim->GetTypeId() == TYPEID_PLAYER)
+ victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED, damage);
+ else if (!victim->IsControlledByPlayer() || victim->IsVehicle())
{
- if (!pVictim->ToCreature()->hasLootRecipient())
- pVictim->ToCreature()->SetLootRecipient(this);
+ if (!victim->ToCreature()->hasLootRecipient())
+ victim->ToCreature()->SetLootRecipient(this);
if (IsControlledByPlayer())
- pVictim->ToCreature()->LowerPlayerDamageReq(health < damage ? health : damage);
+ victim->ToCreature()->LowerPlayerDamageReq(health < damage ? health : damage);
}
if (health <= damage)
{
sLog->outStaticDebug("DealDamage: victim just died");
- if (pVictim->GetTypeId() == TYPEID_PLAYER && pVictim != this)
+ if (victim->GetTypeId() == TYPEID_PLAYER && victim != this)
{
- pVictim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, health);
+ victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, health);
// call before auras are removed
if (Player* killer = GetCharmerOrOwnerPlayerOrPlayerItself())
- killer->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, 1, 0, pVictim);
+ killer->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, 1, 0, victim);
}
- Kill(pVictim, durabilityLoss);
+ Kill(victim, durabilityLoss);
}
else
{
sLog->outStaticDebug("DealDamageAlive");
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
- pVictim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, damage);
+ if (victim->GetTypeId() == TYPEID_PLAYER)
+ victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, damage);
- pVictim->ModifyHealth(- (int32)damage);
+ victim->ModifyHealth(- (int32)damage);
if (damagetype == DIRECT_DAMAGE || damagetype == SPELL_DIRECT_DAMAGE)
- pVictim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_DIRECT_DAMAGE, spellProto ? spellProto->Id : 0);
+ victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_DIRECT_DAMAGE, spellProto ? spellProto->Id : 0);
- if (pVictim->GetTypeId() != TYPEID_PLAYER)
+ if (victim->GetTypeId() != TYPEID_PLAYER)
{
if (spellProto && IsDamageToThreatSpell(spellProto))
- pVictim->AddThreat(this, damage * 2.0f, damageSchoolMask, spellProto);
+ victim->AddThreat(this, damage * 2.0f, damageSchoolMask, spellProto);
else
- pVictim->AddThreat(this, (float)damage, damageSchoolMask, spellProto);
+ victim->AddThreat(this, (float)damage, damageSchoolMask, spellProto);
}
else // victim is a player
{
@@ -783,15 +783,15 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
{
EquipmentSlots slot = EquipmentSlots(urand(0, EQUIPMENT_SLOT_END-1));
- pVictim->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
+ victim->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
}
}
// Rage from damage received
- if (this != pVictim && pVictim->getPowerType() == POWER_RAGE)
+ if (this != victim && victim->getPowerType() == POWER_RAGE)
{
uint32 rage_damage = damage + (cleanDamage ? cleanDamage->absorbed_damage : 0);
- pVictim->RewardRage(rage_damage, 0, false);
+ victim->RewardRage(rage_damage, 0, false);
}
if (GetTypeId() == TYPEID_PLAYER)
@@ -806,24 +806,24 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
if (damagetype != NODAMAGE && damage)
{
- if (pVictim != this && pVictim->GetTypeId() == TYPEID_PLAYER) // does not support creature push_back
+ if (victim != this && victim->GetTypeId() == TYPEID_PLAYER) // does not support creature push_back
{
if (damagetype != DOT)
{
- if (Spell* spell = pVictim->m_currentSpells[CURRENT_GENERIC_SPELL])
+ if (Spell* spell = victim->m_currentSpells[CURRENT_GENERIC_SPELL])
{
if (spell->getState() == SPELL_STATE_PREPARING)
{
uint32 interruptFlags = spell->m_spellInfo->InterruptFlags;
if (interruptFlags & SPELL_INTERRUPT_FLAG_ABORT_ON_DMG)
- pVictim->InterruptNonMeleeSpells(false);
+ victim->InterruptNonMeleeSpells(false);
else if (interruptFlags & SPELL_INTERRUPT_FLAG_PUSH_BACK)
spell->Delayed();
}
}
}
- if (Spell* spell = pVictim->m_currentSpells[CURRENT_CHANNELED_SPELL])
+ if (Spell* spell = victim->m_currentSpells[CURRENT_CHANNELED_SPELL])
{
if (spell->getState() == SPELL_STATE_CASTING)
{
@@ -838,8 +838,8 @@ uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDa
// last damage from duel opponent
if (duel_hasEnded)
{
- ASSERT(pVictim->GetTypeId() == TYPEID_PLAYER);
- Player* he = pVictim->ToPlayer();
+ ASSERT(victim->GetTypeId() == TYPEID_PLAYER);
+ Player* he = victim->ToPlayer();
ASSERT(he->duel);
@@ -865,7 +865,7 @@ void Unit::CastStop(uint32 except_spellid)
InterruptSpell(CurrentSpellTypes(i), false);
}
-void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
+void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
{
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
@@ -878,7 +878,7 @@ void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered, Item *castIte
CastSpell(Victim, spellInfo, triggered, castItem, triggeredByAura, originalCaster);
}
-void Unit::CastSpell(Unit* Victim, SpellEntry const *spellInfo, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
+void Unit::CastSpell(Unit* Victim, SpellEntry const* spellInfo, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
{
if (!spellInfo)
{
@@ -905,7 +905,7 @@ void Unit::CastSpell(Unit* Victim, SpellEntry const *spellInfo, bool triggered,
spell->prepare(&targets, triggeredByAura);
}
-void Unit::CastCustomSpell(Unit* target, uint32 spellId, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
+void Unit::CastCustomSpell(Unit* target, uint32 spellId, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
{
CustomSpellValues values;
if (bp0)
@@ -917,14 +917,14 @@ void Unit::CastCustomSpell(Unit* target, uint32 spellId, int32 const* bp0, int32
CastCustomSpell(spellId, values, target, triggered, castItem, triggeredByAura, originalCaster);
}
-void Unit::CastCustomSpell(uint32 spellId, SpellValueMod mod, int32 value, Unit* target, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
+void Unit::CastCustomSpell(uint32 spellId, SpellValueMod mod, int32 value, Unit* target, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
{
CustomSpellValues values;
values.AddSpellMod(mod, value);
CastCustomSpell(spellId, values, target, triggered, castItem, triggeredByAura, originalCaster);
}
-void Unit::CastCustomSpell(uint32 spellId, CustomSpellValues const &value, Unit* Victim, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
+void Unit::CastCustomSpell(uint32 spellId, CustomSpellValues const& value, Unit* Victim, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster)
{
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
@@ -954,7 +954,7 @@ void Unit::CastCustomSpell(uint32 spellId, CustomSpellValues const &value, Unit*
}
// used for scripting
-void Unit::CastSpell(float x, float y, float z, uint32 spellId, bool triggered, Item *castItem, AuraEffect const* triggeredByAura, uint64 originalCaster, Unit* OriginalVictim)
+void Unit::CastSpell(float x, float y, float z, uint32 spellId, bool triggered, Item* castItem, AuraEffect const* triggeredByAura, uint64 originalCaster, Unit* OriginalVictim)
{
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
@@ -981,7 +981,7 @@ void Unit::CastSpell(float x, float y, float z, uint32 spellId, bool triggered,
}
// used for scripting
-void Unit::CastSpell(GameObject *go, uint32 spellId, bool triggered, Item *castItem, AuraEffect* triggeredByAura, uint64 originalCaster)
+void Unit::CastSpell(GameObject *go, uint32 spellId, bool triggered, Item* castItem, AuraEffect* triggeredByAura, uint64 originalCaster)
{
if (!go)
return;
@@ -1009,11 +1009,11 @@ void Unit::CastSpell(GameObject *go, uint32 spellId, bool triggered, Item *castI
}
// Obsolete func need remove, here only for comotability vs another patches
-uint32 Unit::SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID, uint32 damage)
+uint32 Unit::SpellNonMeleeDamageLog(Unit* victim, uint32 spellID, uint32 damage)
{
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellID);
- SpellNonMeleeDamage damageInfo(this, pVictim, spellInfo->Id, spellInfo->SchoolMask);
- damage = SpellDamageBonus(pVictim, spellInfo, damage, SPELL_DIRECT_DAMAGE);
+ SpellNonMeleeDamage damageInfo(this, victim, spellInfo->Id, spellInfo->SchoolMask);
+ damage = SpellDamageBonus(victim, spellInfo, damage, SPELL_DIRECT_DAMAGE);
CalculateSpellDamageTaken(&damageInfo, damage, spellInfo);
DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
SendSpellNonMeleeDamageLog(&damageInfo);
@@ -1021,7 +1021,7 @@ uint32 Unit::SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID, uint32 damage
return damageInfo.damage;
}
-void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage *damageInfo, int32 damage, SpellEntry const *spellInfo, WeaponAttackType attackType, bool crit)
+void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage *damageInfo, int32 damage, SpellEntry const* spellInfo, WeaponAttackType attackType, bool crit)
{
if (damage < 0)
return;
@@ -1032,15 +1032,15 @@ void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage *damageInfo, int32 dama
return;
}
- Unit* pVictim = damageInfo->target;
- if (!pVictim || !pVictim->isAlive())
+ Unit* victim = damageInfo->target;
+ if (!victim || !victim->isAlive())
return;
SpellSchoolMask damageSchoolMask = SpellSchoolMask(damageInfo->schoolMask);
- uint32 crTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 crTypeMask = victim->GetCreatureTypeMask();
if (IsDamageReducedByArmor(damageSchoolMask, spellInfo))
- damage = CalcArmorReducedDamage(pVictim, damage, spellInfo, attackType);
+ damage = CalcArmorReducedDamage(victim, damage, spellInfo, attackType);
bool blocked = false;
// Per-school calc
@@ -1049,79 +1049,81 @@ void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage *damageInfo, int32 dama
// Melee and Ranged Spells
case SPELL_DAMAGE_CLASS_RANGED:
case SPELL_DAMAGE_CLASS_MELEE:
+ {
+ // Physical Damage
+ if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
{
- // Physical Damage
- if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
- {
- // Get blocked status
- blocked = isSpellBlocked(pVictim, spellInfo, attackType);
- }
+ // Get blocked status
+ blocked = isSpellBlocked(victim, spellInfo, attackType);
+ }
- if (crit)
- {
- damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
-
- // Calculate crit bonus
- uint32 crit_bonus = damage;
- // Apply crit_damage bonus for melee spells
- if (Player* modOwner = GetSpellModOwner())
- modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
- damage += crit_bonus;
-
- // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
- int32 critPctDamageMod = 0;
- if (attackType == RANGED_ATTACK)
- critPctDamageMod += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
- else
- {
- critPctDamageMod += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
- critPctDamageMod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE);
- }
- // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
- critPctDamageMod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
+ if (crit)
+ {
+ damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
- if (critPctDamageMod != 0)
- AddPctN(damage, critPctDamageMod);
- }
+ // Calculate crit bonus
+ uint32 crit_bonus = damage;
+ // Apply crit_damage bonus for melee spells
+ if (Player* modOwner = GetSpellModOwner())
+ modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
+ damage += crit_bonus;
- // Spell weapon based damage CAN BE crit & blocked at same time
- if (blocked)
+ // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
+ int32 critPctDamageMod = 0;
+ if (attackType == RANGED_ATTACK)
+ critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
+ else
{
- damageInfo->blocked = pVictim->GetShieldBlockValue();
- // double blocked amount if block is critical
- if (pVictim->isBlockCritical())
- damageInfo->blocked += damageInfo->blocked;
- if (damage < int32(damageInfo->blocked))
- damageInfo->blocked = uint32(damage);
- damage -= damageInfo->blocked;
+ critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
+ critPctDamageMod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE);
}
+ // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
+ critPctDamageMod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
- if (attackType != RANGED_ATTACK)
- ApplyResilience(pVictim, NULL, &damage, crit, CR_CRIT_TAKEN_MELEE);
- else
- ApplyResilience(pVictim, NULL, &damage, crit, CR_CRIT_TAKEN_RANGED);
+ if (critPctDamageMod != 0)
+ AddPctN(damage, critPctDamageMod);
+ }
+
+ // Spell weapon based damage CAN BE crit & blocked at same time
+ if (blocked)
+ {
+ damageInfo->blocked = victim->GetShieldBlockValue();
+ // double blocked amount if block is critical
+ if (victim->isBlockCritical())
+ damageInfo->blocked += damageInfo->blocked;
+ if (damage < int32(damageInfo->blocked))
+ damageInfo->blocked = uint32(damage);
+ damage -= damageInfo->blocked;
}
+
+ if (attackType != RANGED_ATTACK)
+ ApplyResilience(victim, NULL, &damage, crit, CR_CRIT_TAKEN_MELEE);
+ else
+ ApplyResilience(victim, NULL, &damage, crit, CR_CRIT_TAKEN_RANGED);
break;
+ }
// Magical Attacks
case SPELL_DAMAGE_CLASS_NONE:
case SPELL_DAMAGE_CLASS_MAGIC:
+ {
+ // If crit add critical bonus
+ if (crit)
{
- // If crit add critical bonus
- if (crit)
- {
- damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
- damage = SpellCriticalDamageBonus(spellInfo, damage, pVictim);
- }
-
- ApplyResilience(pVictim, NULL, &damage, crit, CR_CRIT_TAKEN_SPELL);
+ damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
+ damage = SpellCriticalDamageBonus(spellInfo, damage, victim);
}
+
+ ApplyResilience(victim, NULL, &damage, crit, CR_CRIT_TAKEN_SPELL);
+ break;
+ }
+ default:
break;
}
// Calculate absorb resist
if (damage > 0)
{
- CalcAbsorbResist(pVictim, damageSchoolMask, SPELL_DIRECT_DAMAGE, damage, &damageInfo->absorb, &damageInfo->resist, spellInfo);
+ CalcAbsorbResist(victim, damageSchoolMask, SPELL_DIRECT_DAMAGE, damage, &damageInfo->absorb, &damageInfo->resist, spellInfo);
damage -= damageInfo->absorb + damageInfo->resist;
}
else
@@ -1135,12 +1137,12 @@ void Unit::DealSpellDamage(SpellNonMeleeDamage *damageInfo, bool durabilityLoss)
if (damageInfo == 0)
return;
- Unit* pVictim = damageInfo->target;
+ Unit* victim = damageInfo->target;
- if (!pVictim)
+ if (!victim)
return;
- if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (pVictim->HasUnitState(UNIT_STAT_ONVEHICLE) && pVictim->GetVehicleBase() != this) || (pVictim->GetTypeId() == TYPEID_UNIT && pVictim->ToCreature()->IsInEvadeMode()))
+ if (!victim->isAlive() || victim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (victim->HasUnitState(UNIT_STAT_ONVEHICLE) && victim->GetVehicleBase() != this) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
return;
SpellEntry const* spellProto = sSpellStore.LookupEntry(damageInfo->SpellID);
@@ -1152,14 +1154,14 @@ void Unit::DealSpellDamage(SpellNonMeleeDamage *damageInfo, bool durabilityLoss)
// Call default DealDamage
CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb, BASE_ATTACK, MELEE_HIT_NORMAL);
- DealDamage(pVictim, damageInfo->damage, &cleanDamage, SPELL_DIRECT_DAMAGE, SpellSchoolMask(damageInfo->schoolMask), spellProto, durabilityLoss);
+ DealDamage(victim, damageInfo->damage, &cleanDamage, SPELL_DIRECT_DAMAGE, SpellSchoolMask(damageInfo->schoolMask), spellProto, durabilityLoss);
}
// TODO for melee need create structure as in
-void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *damageInfo, WeaponAttackType attackType)
+void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo *damageInfo, WeaponAttackType attackType)
{
damageInfo->attacker = this;
- damageInfo->target = pVictim;
+ damageInfo->target = victim;
damageInfo->damageSchoolMask = GetMeleeDamageSchoolMask();
damageInfo->attackType = attackType;
damageInfo->damage = 0;
@@ -1175,9 +1177,9 @@ void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *da
damageInfo->procEx = PROC_EX_NONE;
damageInfo->hitOutCome = MELEE_HIT_EVADE;
- if (!pVictim)
+ if (!victim)
return;
- if (!isAlive() || !pVictim->isAlive())
+ if (!isAlive() || !victim->isAlive())
return;
// Select HitInfo/procAttacker/procVictim flag based on attack type
@@ -1227,55 +1229,49 @@ void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *da
switch (damageInfo->hitOutCome)
{
case MELEE_HIT_EVADE:
- {
- damageInfo->HitInfo |= HITINFO_MISS|HITINFO_SWINGNOHITSOUND;
- damageInfo->TargetState = VICTIMSTATE_EVADES;
-
- damageInfo->procEx|=PROC_EX_EVADE;
- damageInfo->damage = 0;
- damageInfo->cleanDamage = 0;
- }
+ damageInfo->HitInfo |= HITINFO_MISS|HITINFO_SWINGNOHITSOUND;
+ damageInfo->TargetState = VICTIMSTATE_EVADES;
+ damageInfo->procEx|=PROC_EX_EVADE;
+ damageInfo->damage = 0;
+ damageInfo->cleanDamage = 0;
return;
case MELEE_HIT_MISS:
- {
- damageInfo->HitInfo |= HITINFO_MISS;
- damageInfo->TargetState = VICTIMSTATE_INTACT;
-
- damageInfo->procEx |= PROC_EX_MISS;
- damageInfo->damage = 0;
- damageInfo->cleanDamage = 0;
- }
+ damageInfo->HitInfo |= HITINFO_MISS;
+ damageInfo->TargetState = VICTIMSTATE_INTACT;
+ damageInfo->procEx |= PROC_EX_MISS;
+ damageInfo->damage = 0;
+ damageInfo->cleanDamage = 0;
break;
case MELEE_HIT_NORMAL:
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->procEx|=PROC_EX_NORMAL_HIT;
break;
case MELEE_HIT_CRIT:
- {
- damageInfo->HitInfo |= HITINFO_CRITICALHIT;
- damageInfo->TargetState = VICTIMSTATE_HIT;
+ {
+ damageInfo->HitInfo |= HITINFO_CRITICALHIT;
+ damageInfo->TargetState = VICTIMSTATE_HIT;
- damageInfo->procEx |= PROC_EX_CRITICAL_HIT;
- // Crit bonus calc
- damageInfo->damage += damageInfo->damage;
- int32 mod = 0;
- // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
- if (damageInfo->attackType == RANGED_ATTACK)
- mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
- else
- {
- mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
- mod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE);
- }
+ damageInfo->procEx |= PROC_EX_CRITICAL_HIT;
+ // Crit bonus calc
+ damageInfo->damage += damageInfo->damage;
+ int32 mod = 0;
+ // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
+ if (damageInfo->attackType == RANGED_ATTACK)
+ mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
+ else
+ {
+ mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
+ mod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE);
+ }
- uint32 crTypeMask = damageInfo->target->GetCreatureTypeMask();
+ uint32 crTypeMask = damageInfo->target->GetCreatureTypeMask();
- // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
- mod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
- if (mod != 0)
- AddPctN(damageInfo->damage, mod);
- }
+ // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
+ mod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
+ if (mod != 0)
+ AddPctN(damageInfo->damage, mod);
break;
+ }
case MELEE_HIT_PARRY:
damageInfo->TargetState = VICTIMSTATE_PARRY;
damageInfo->procEx |= PROC_EX_PARRY;
@@ -1289,57 +1285,53 @@ void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *da
damageInfo->damage = 0;
break;
case MELEE_HIT_BLOCK:
+ damageInfo->TargetState = VICTIMSTATE_HIT;
+ damageInfo->HitInfo |= HITINFO_BLOCK;
+ damageInfo->procEx |= PROC_EX_BLOCK;
+ damageInfo->blocked_amount = damageInfo->target->GetShieldBlockValue();
+ // double blocked amount if block is critical
+ if (damageInfo->target->isBlockCritical())
+ damageInfo->blocked_amount+=damageInfo->blocked_amount;
+ if (damageInfo->blocked_amount >= damageInfo->damage)
{
- damageInfo->TargetState = VICTIMSTATE_HIT;
- damageInfo->HitInfo |= HITINFO_BLOCK;
- damageInfo->procEx |= PROC_EX_BLOCK;
- damageInfo->blocked_amount = damageInfo->target->GetShieldBlockValue();
- // double blocked amount if block is critical
- if (damageInfo->target->isBlockCritical())
- damageInfo->blocked_amount+=damageInfo->blocked_amount;
- if (damageInfo->blocked_amount >= damageInfo->damage)
- {
- damageInfo->TargetState = VICTIMSTATE_BLOCKS;
- damageInfo->blocked_amount = damageInfo->damage;
- damageInfo->procEx |= PROC_EX_FULL_BLOCK;
- }
- else
- damageInfo->procEx |= PROC_EX_NORMAL_HIT;
- damageInfo->damage -= damageInfo->blocked_amount;
- damageInfo->cleanDamage += damageInfo->blocked_amount;
+ damageInfo->TargetState = VICTIMSTATE_BLOCKS;
+ damageInfo->blocked_amount = damageInfo->damage;
+ damageInfo->procEx |= PROC_EX_FULL_BLOCK;
}
+ else
+ damageInfo->procEx |= PROC_EX_NORMAL_HIT;
+ damageInfo->damage -= damageInfo->blocked_amount;
+ damageInfo->cleanDamage += damageInfo->blocked_amount;
break;
case MELEE_HIT_GLANCING:
- {
- damageInfo->HitInfo |= HITINFO_GLANCING;
- damageInfo->TargetState = VICTIMSTATE_HIT;
- damageInfo->procEx |= PROC_EX_NORMAL_HIT;
- int32 leveldif = int32(pVictim->getLevel()) - int32(getLevel());
- if (leveldif > 3)
- leveldif = 3;
- float reducePercent = 1 - leveldif * 0.1f;
- damageInfo->cleanDamage += damageInfo->damage-uint32(reducePercent * damageInfo->damage);
- damageInfo->damage = uint32(reducePercent * damageInfo->damage);
- }
+ {
+ damageInfo->HitInfo |= HITINFO_GLANCING;
+ damageInfo->TargetState = VICTIMSTATE_HIT;
+ damageInfo->procEx |= PROC_EX_NORMAL_HIT;
+ int32 leveldif = int32(victim->getLevel()) - int32(getLevel());
+ if (leveldif > 3)
+ leveldif = 3;
+ float reducePercent = 1 - leveldif * 0.1f;
+ damageInfo->cleanDamage += damageInfo->damage-uint32(reducePercent * damageInfo->damage);
+ damageInfo->damage = uint32(reducePercent * damageInfo->damage);
break;
+ }
case MELEE_HIT_CRUSHING:
- {
- damageInfo->HitInfo |= HITINFO_CRUSHING;
- damageInfo->TargetState = VICTIMSTATE_HIT;
- damageInfo->procEx |= PROC_EX_NORMAL_HIT;
- // 150% normal damage
- damageInfo->damage += (damageInfo->damage / 2);
- }
- break;
+ damageInfo->HitInfo |= HITINFO_CRUSHING;
+ damageInfo->TargetState = VICTIMSTATE_HIT;
+ damageInfo->procEx |= PROC_EX_NORMAL_HIT;
+ // 150% normal damage
+ damageInfo->damage += (damageInfo->damage / 2);
+ break;
default:
break;
}
int32 resilienceReduction = damageInfo->damage;
if (attackType != RANGED_ATTACK)
- ApplyResilience(pVictim, NULL, &resilienceReduction, (damageInfo->hitOutCome == MELEE_HIT_CRIT), CR_CRIT_TAKEN_MELEE);
+ ApplyResilience(victim, NULL, &resilienceReduction, (damageInfo->hitOutCome == MELEE_HIT_CRIT), CR_CRIT_TAKEN_MELEE);
else
- ApplyResilience(pVictim, NULL, &resilienceReduction, (damageInfo->hitOutCome == MELEE_HIT_CRIT), CR_CRIT_TAKEN_RANGED);
+ ApplyResilience(victim, NULL, &resilienceReduction, (damageInfo->hitOutCome == MELEE_HIT_CRIT), CR_CRIT_TAKEN_RANGED);
resilienceReduction = damageInfo->damage - resilienceReduction;
damageInfo->damage -= resilienceReduction;
damageInfo->cleanDamage += resilienceReduction;
@@ -1365,67 +1357,67 @@ void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *da
void Unit::DealMeleeDamage(CalcDamageInfo *damageInfo, bool durabilityLoss)
{
- Unit* pVictim = damageInfo->target;
+ Unit* victim = damageInfo->target;
- if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (pVictim->HasUnitState(UNIT_STAT_ONVEHICLE) && pVictim->GetVehicleBase() != this) || (pVictim->GetTypeId() == TYPEID_UNIT && pVictim->ToCreature()->IsInEvadeMode()))
+ if (!victim->isAlive() || victim->HasUnitState(UNIT_STAT_IN_FLIGHT) || (victim->HasUnitState(UNIT_STAT_ONVEHICLE) && victim->GetVehicleBase() != this) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
return;
// Hmmmm dont like this emotes client must by self do all animations
if (damageInfo->HitInfo & HITINFO_CRITICALHIT)
- pVictim->HandleEmoteCommand(EMOTE_ONESHOT_WOUNDCRITICAL);
+ victim->HandleEmoteCommand(EMOTE_ONESHOT_WOUNDCRITICAL);
if (damageInfo->blocked_amount && damageInfo->TargetState != VICTIMSTATE_BLOCKS)
- pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYSHIELD);
+ victim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYSHIELD);
if (damageInfo->TargetState == VICTIMSTATE_PARRY)
{
// Get attack timers
- float offtime = float(pVictim->getAttackTimer(OFF_ATTACK));
- float basetime = float(pVictim->getAttackTimer(BASE_ATTACK));
+ float offtime = float(victim->getAttackTimer(OFF_ATTACK));
+ float basetime = float(victim->getAttackTimer(BASE_ATTACK));
// Reduce attack time
- if (pVictim->haveOffhandWeapon() && offtime < basetime)
+ if (victim->haveOffhandWeapon() && offtime < basetime)
{
- float percent20 = pVictim->GetAttackTime(OFF_ATTACK) * 0.20f;
+ float percent20 = victim->GetAttackTime(OFF_ATTACK) * 0.20f;
float percent60 = 3.0f * percent20;
if (offtime > percent20 && offtime <= percent60)
- pVictim->setAttackTimer(OFF_ATTACK, uint32(percent20));
+ victim->setAttackTimer(OFF_ATTACK, uint32(percent20));
else if (offtime > percent60)
{
offtime -= 2.0f * percent20;
- pVictim->setAttackTimer(OFF_ATTACK, uint32(offtime));
+ victim->setAttackTimer(OFF_ATTACK, uint32(offtime));
}
}
else
{
- float percent20 = pVictim->GetAttackTime(BASE_ATTACK) * 0.20f;
+ float percent20 = victim->GetAttackTime(BASE_ATTACK) * 0.20f;
float percent60 = 3.0f * percent20;
if (basetime > percent20 && basetime <= percent60)
- pVictim->setAttackTimer(BASE_ATTACK, uint32(percent20));
+ victim->setAttackTimer(BASE_ATTACK, uint32(percent20));
else if (basetime > percent60)
{
basetime -= 2.0f * percent20;
- pVictim->setAttackTimer(BASE_ATTACK, uint32(basetime));
+ victim->setAttackTimer(BASE_ATTACK, uint32(basetime));
}
}
}
// Call default DealDamage
CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb, damageInfo->attackType, damageInfo->hitOutCome);
- DealDamage(pVictim, damageInfo->damage, &cleanDamage, DIRECT_DAMAGE, SpellSchoolMask(damageInfo->damageSchoolMask), NULL, durabilityLoss);
+ DealDamage(victim, damageInfo->damage, &cleanDamage, DIRECT_DAMAGE, SpellSchoolMask(damageInfo->damageSchoolMask), NULL, durabilityLoss);
// If this is a creature and it attacks from behind it has a probability to daze it's victim
if ((damageInfo->hitOutCome == MELEE_HIT_CRIT || damageInfo->hitOutCome == MELEE_HIT_CRUSHING || damageInfo->hitOutCome == MELEE_HIT_NORMAL || damageInfo->hitOutCome == MELEE_HIT_GLANCING) &&
- GetTypeId() != TYPEID_PLAYER && !ToCreature()->IsControlledByPlayer() && !pVictim->HasInArc(M_PI, this)
- && (pVictim->GetTypeId() == TYPEID_PLAYER || !pVictim->ToCreature()->isWorldBoss()))
+ GetTypeId() != TYPEID_PLAYER && !ToCreature()->IsControlledByPlayer() && !victim->HasInArc(M_PI, this)
+ && (victim->GetTypeId() == TYPEID_PLAYER || !victim->ToCreature()->isWorldBoss()))
{
// -probability is between 0% and 40%
// 20% base chance
float Probability = 20.0f;
// there is a newbie protection, at level 10 just 7% base chance; assuming linear function
- if (pVictim->getLevel() < 30)
- Probability = 0.65f * pVictim->getLevel() + 0.5f;
+ if (victim->getLevel() < 30)
+ Probability = 0.65f * victim->getLevel() + 0.5f;
- uint32 VictimDefense=pVictim->GetDefenseSkillValue();
+ uint32 VictimDefense=victim->GetDefenseSkillValue();
uint32 AttackerMeleeSkill=GetUnitMeleeSkill();
Probability *= AttackerMeleeSkill/(float)VictimDefense;
@@ -1434,32 +1426,32 @@ void Unit::DealMeleeDamage(CalcDamageInfo *damageInfo, bool durabilityLoss)
Probability = 40.0f;
if (roll_chance_f(Probability))
- CastSpell(pVictim, 1604, true);
+ CastSpell(victim, 1604, true);
}
if (GetTypeId() == TYPEID_PLAYER)
- ToPlayer()->CastItemCombatSpell(pVictim, damageInfo->attackType, damageInfo->procVictim, damageInfo->procEx);
+ ToPlayer()->CastItemCombatSpell(victim, damageInfo->attackType, damageInfo->procVictim, damageInfo->procEx);
// Do effect if any damage done to target
if (damageInfo->damage)
{
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
- AuraEffectList vDamageShieldsCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_DAMAGE_SHIELD));
+ AuraEffectList vDamageShieldsCopy(victim->GetAuraEffectsByType(SPELL_AURA_DAMAGE_SHIELD));
for (AuraEffectList::const_iterator dmgShieldItr = vDamageShieldsCopy.begin(); dmgShieldItr != vDamageShieldsCopy.end(); ++dmgShieldItr)
{
SpellEntry const* i_spellProto = (*dmgShieldItr)->GetSpellProto();
// Damage shield can be resisted...
- if (SpellMissInfo missInfo = pVictim->SpellHitResult(this, i_spellProto , false))
+ if (SpellMissInfo missInfo = victim->SpellHitResult(this, i_spellProto , false))
{
- pVictim->SendSpellMiss(this, i_spellProto->Id, missInfo);
+ victim->SendSpellMiss(this, i_spellProto->Id, missInfo);
continue;
}
// ...or immuned
if (IsImmunedToDamage(i_spellProto))
{
- pVictim->SendSpellDamageImmune(this, i_spellProto->Id);
+ victim->SendSpellDamageImmune(this, i_spellProto->Id);
continue;
}
@@ -1469,20 +1461,20 @@ void Unit::DealMeleeDamage(CalcDamageInfo *damageInfo, bool durabilityLoss)
damage = caster->SpellDamageBonus(this, i_spellProto, damage, SPELL_DIRECT_DAMAGE);
// No Unit::CalcAbsorbResist here - opcode doesn't send that data - this damage is probably not affected by that
- pVictim->DealDamageMods(this, damage, NULL);
+ victim->DealDamageMods(this, damage, NULL);
// TODO: Move this to a packet handler
WorldPacket data(SMSG_SPELLDAMAGESHIELD, (8+8+4+4+4+4));
- data << uint64(pVictim->GetGUID());
+ data << uint64(victim->GetGUID());
data << uint64(GetGUID());
data << uint32(i_spellProto->Id);
data << uint32(damage); // Damage
int32 overkill = int32(damage) - int32(GetHealth());
data << uint32(overkill > 0 ? overkill : 0); // Overkill
data << uint32(i_spellProto->SchoolMask);
- pVictim->SendMessageToSet(&data, true);
+ victim->SendMessageToSet(&data, true);
- pVictim->DealDamage(this, damage, 0, SPELL_DIRECT_DAMAGE, GetSpellSchoolMask(i_spellProto), i_spellProto, true);
+ victim->DealDamage(this, damage, 0, SPELL_DIRECT_DAMAGE, GetSpellSchoolMask(i_spellProto), i_spellProto, true);
}
}
}
@@ -1495,7 +1487,7 @@ void Unit::HandleEmoteCommand(uint32 anim_id)
SendMessageToSet(&data, true);
}
-bool Unit::IsDamageReducedByArmor(SpellSchoolMask schoolMask, SpellEntry const *spellInfo, uint8 effIndex)
+bool Unit::IsDamageReducedByArmor(SpellSchoolMask schoolMask, SpellEntry const* spellInfo, uint8 effIndex)
{
// only physical spells damage gets reduced by armor
if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0)
@@ -1514,10 +1506,10 @@ bool Unit::IsDamageReducedByArmor(SpellSchoolMask schoolMask, SpellEntry const *
return true;
}
-uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage, SpellEntry const *spellInfo, WeaponAttackType /*attackType*/)
+uint32 Unit::CalcArmorReducedDamage(Unit* victim, const uint32 damage, SpellEntry const* spellInfo, WeaponAttackType /*attackType*/)
{
uint32 newdamage = 0;
- float armor = float(pVictim->GetArmor());
+ float armor = float(victim->GetArmor());
// Ignore enemy armor by SPELL_AURA_MOD_TARGET_RESISTANCE aura
armor += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, SPELL_SCHOOL_MASK_NORMAL);
@@ -1553,7 +1545,7 @@ uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage, SpellEnt
continue;
}
- // item dependent spell - check curent weapons
+ // item dependent spell - check current weapons
for (int i = 0; i < MAX_ATTACK; ++i)
{
Item* weapon = ToPlayer()->GetWeaponForAttack(WeaponAttackType(i), true);
@@ -1572,9 +1564,9 @@ uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage, SpellEnt
{
float maxArmorPen = 0;
if (getLevel() < 60)
- maxArmorPen = float(400 + 85 * pVictim->getLevel());
+ maxArmorPen = float(400 + 85 * victim->getLevel());
else
- maxArmorPen = 400 + 85 * pVictim->getLevel() + 4.5f * 85 * (pVictim->getLevel() - 59);
+ maxArmorPen = 400 + 85 * victim->getLevel() + 4.5f * 85 * (victim->getLevel() - 59);
// Cap armor penetration to this number
maxArmorPen = std::min((armor + maxArmorPen) / 3, armor);
// Figure out how much armor do we ignore
@@ -1603,17 +1595,17 @@ uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage, SpellEnt
return (newdamage > 1) ? newdamage : 1;
}
-void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEffectType damagetype, const uint32 damage, uint32 *absorb, uint32 *resist, SpellEntry const *spellInfo)
+void Unit::CalcAbsorbResist(Unit* victim, SpellSchoolMask schoolMask, DamageEffectType damagetype, const uint32 damage, uint32 *absorb, uint32 *resist, SpellEntry const* spellInfo)
{
- if (!pVictim || !pVictim->isAlive() || !damage)
+ if (!victim || !victim->isAlive() || !damage)
return;
- DamageInfo dmgInfo = DamageInfo(this, pVictim, damage, spellInfo, schoolMask, damagetype);
+ DamageInfo dmgInfo = DamageInfo(this, victim, damage, spellInfo, schoolMask, damagetype);
// Magic damage, check for resists
if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0)
{
- float baseVictimResistance = float(pVictim->GetResistance(GetFirstSchoolInMask(schoolMask)));
+ float baseVictimResistance = float(victim->GetResistance(GetFirstSchoolInMask(schoolMask)));
float ignoredResistance = float(GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
if (Player* player = ToPlayer())
ignoredResistance += float(player->GetSpellPenetrationItemMod());
@@ -1692,7 +1684,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
- AuraEffectList vSchoolAbsorbCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_ABSORB));
+ AuraEffectList vSchoolAbsorbCopy(victim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_ABSORB));
vSchoolAbsorbCopy.sort(Trinity::AbsorbAuraOrderPred());
// absorb without mana cost
@@ -1700,7 +1692,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
{
AuraEffect* absorbAurEff = *itr;
// Check if aura was removed during iteration - we don't need to work on such auras
- AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(pVictim->GetGUID());
+ AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
if (!aurApp)
continue;
if (!(absorbAurEff->GetMiscValue() & schoolMask))
@@ -1745,12 +1737,12 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
}
// absorb by mana cost
- AuraEffectList vManaShieldCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_MANA_SHIELD));
+ AuraEffectList vManaShieldCopy(victim->GetAuraEffectsByType(SPELL_AURA_MANA_SHIELD));
for (AuraEffectList::const_iterator itr = vManaShieldCopy.begin(); (itr != vManaShieldCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
{
AuraEffect* absorbAurEff = *itr;
// Check if aura was removed during iteration - we don't need to work on such auras
- AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(pVictim->GetGUID());
+ AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
if (!aurApp)
continue;
// check damage school mask
@@ -1784,7 +1776,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
if (float manaMultiplier = SpellMgr::CalculateSpellEffectValueMultiplier(absorbAurEff->GetSpellProto(), absorbAurEff->GetEffIndex(), absorbAurEff->GetCaster()))
manaReduction = int32(float(manaReduction) * manaMultiplier);
- int32 manaTaken = -pVictim->ModifyPower(POWER_MANA, -manaReduction);
+ int32 manaTaken = -victim->ModifyPower(POWER_MANA, -manaReduction);
// take case when mana has ended up into account
currentAbsorb = currentAbsorb ? int32(float(currentAbsorb) * (float(manaTaken) / float(manaReduction))) : 0;
@@ -1804,15 +1796,15 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
}
// split damage auras - only when not damaging self
- if (pVictim != this)
+ if (victim != this)
{
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
- AuraEffectList vSplitDamageFlatCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_FLAT));
+ AuraEffectList vSplitDamageFlatCopy(victim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_FLAT));
for (AuraEffectList::iterator itr = vSplitDamageFlatCopy.begin(); (itr != vSplitDamageFlatCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
{
// Check if aura was removed during iteration - we don't need to work on such auras
- if (!((*itr)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID())))
+ if (!((*itr)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
continue;
// check damage school mask
if (!((*itr)->GetMiscValue() & schoolMask))
@@ -1820,7 +1812,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
// Damage can be splitted only if aura has an alive caster
Unit* caster = (*itr)->GetCaster();
- if (!caster || (caster == pVictim) || !caster->IsInWorld() || !caster->isAlive())
+ if (!caster || (caster == victim) || !caster->IsInWorld() || !caster->isAlive())
continue;
int32 splitDamage = (*itr)->GetAmount();
@@ -1842,11 +1834,11 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
- AuraEffectList vSplitDamagePctCopy(pVictim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_PCT));
+ AuraEffectList vSplitDamagePctCopy(victim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_PCT));
for (AuraEffectList::iterator itr = vSplitDamagePctCopy.begin(), next; (itr != vSplitDamagePctCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
{
// Check if aura was removed during iteration - we don't need to work on such auras
- if (!((*itr)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID())))
+ if (!((*itr)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
continue;
// check damage school mask
if (!((*itr)->GetMiscValue() & schoolMask))
@@ -1854,7 +1846,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
// Damage can be splitted only if aura has an alive caster
Unit* caster = (*itr)->GetCaster();
- if (!caster || (caster == pVictim) || !caster->IsInWorld() || !caster->isAlive())
+ if (!caster || (caster == victim) || !caster->IsInWorld() || !caster->isAlive())
continue;
int32 splitDamage = CalculatePctN(dmgInfo.GetDamage(), (*itr)->GetAmount());
@@ -1879,7 +1871,7 @@ void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEff
*absorb = dmgInfo.GetAbsorb();
}
-void Unit::CalcHealAbsorb(Unit *pVictim, const SpellEntry *healSpell, uint32 &healAmount, uint32 &absorb)
+void Unit::CalcHealAbsorb(Unit* victim, const SpellEntry *healSpell, uint32 &healAmount, uint32 &absorb)
{
if (!healAmount)
return;
@@ -1890,7 +1882,7 @@ void Unit::CalcHealAbsorb(Unit *pVictim, const SpellEntry *healSpell, uint32 &he
bool existExpired = false;
// absorb without mana cost
- AuraEffectList const& vHealAbsorb = pVictim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_HEAL_ABSORB);
+ AuraEffectList const& vHealAbsorb = victim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_HEAL_ABSORB);
for (AuraEffectList::const_iterator i = vHealAbsorb.begin(); i != vHealAbsorb.end() && RemainingHeal > 0; ++i)
{
if (!((*i)->GetMiscValue() & healSpell->SchoolMask))
@@ -1929,9 +1921,9 @@ void Unit::CalcHealAbsorb(Unit *pVictim, const SpellEntry *healSpell, uint32 &he
++i;
if (auraEff->GetAmount() <= 0)
{
- uint32 removedAuras = pVictim->m_removedAurasCount;
+ uint32 removedAuras = victim->m_removedAurasCount;
auraEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
- if (removedAuras+1 < pVictim->m_removedAurasCount)
+ if (removedAuras+1 < victim->m_removedAurasCount)
i = vHealAbsorb.begin();
}
}
@@ -1941,18 +1933,18 @@ void Unit::CalcHealAbsorb(Unit *pVictim, const SpellEntry *healSpell, uint32 &he
healAmount = RemainingHeal;
}
-void Unit::AttackerStateUpdate (Unit *pVictim, WeaponAttackType attType, bool extra)
+void Unit::AttackerStateUpdate (Unit* victim, WeaponAttackType attType, bool extra)
{
if (HasUnitState(UNIT_STAT_CANNOT_AUTOATTACK) || HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
return;
- if (!pVictim->isAlive())
+ if (!victim->isAlive())
return;
- if ((attType == BASE_ATTACK || attType == OFF_ATTACK) && !IsWithinLOSInMap(pVictim))
+ if ((attType == BASE_ATTACK || attType == OFF_ATTACK) && !IsWithinLOSInMap(victim))
return;
- CombatStart(pVictim);
+ CombatStart(victim);
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MELEE_ATTACK);
uint32 hitInfo;
@@ -1969,12 +1961,12 @@ void Unit::AttackerStateUpdate (Unit *pVictim, WeaponAttackType attType, bool ex
else
{
// attack can be redirected to another target
- pVictim = SelectMagnetTarget(pVictim);
+ victim = SelectMagnetTarget(victim);
CalcDamageInfo damageInfo;
- CalculateMeleeDamage(pVictim, 0, &damageInfo, attType);
+ CalculateMeleeDamage(victim, 0, &damageInfo, attType);
// Send log damage message to client
- DealDamageMods(pVictim, damageInfo.damage, &damageInfo.absorb);
+ DealDamageMods(victim, damageInfo.damage, &damageInfo.absorb);
SendAttackStateUpdate(&damageInfo);
//TriggerAurasProcOnEvent(damageInfo);
@@ -1984,55 +1976,55 @@ void Unit::AttackerStateUpdate (Unit *pVictim, WeaponAttackType attType, bool ex
if (GetTypeId() == TYPEID_PLAYER)
sLog->outStaticDebug("AttackerStateUpdate: (Player) %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
- GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(), damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount, damageInfo.resist);
+ GetGUIDLow(), victim->GetGUIDLow(), victim->GetTypeId(), damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount, damageInfo.resist);
else
sLog->outStaticDebug("AttackerStateUpdate: (NPC) %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
- GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(), damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount, damageInfo.resist);
+ GetGUIDLow(), victim->GetGUIDLow(), victim->GetTypeId(), damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount, damageInfo.resist);
}
if (!extra && m_extraAttacks)
{
while(m_extraAttacks)
{
- AttackerStateUpdate(pVictim, BASE_ATTACK, true);
+ AttackerStateUpdate(victim, BASE_ATTACK, true);
if (m_extraAttacks > 0)
--m_extraAttacks;
}
}
}
-MeleeHitOutcome Unit::RollMeleeOutcomeAgainst(const Unit *pVictim, WeaponAttackType attType) const
+MeleeHitOutcome Unit::RollMeleeOutcomeAgainst(const Unit* victim, WeaponAttackType attType) const
{
// This is only wrapper
// Miss chance based on melee
- //float miss_chance = MeleeMissChanceCalc(pVictim, attType);
- float miss_chance = MeleeSpellMissChance(pVictim, attType, int32(GetWeaponSkillValue(attType, pVictim)) - int32(pVictim->GetDefenseSkillValue(this)), 0);
+ //float miss_chance = MeleeMissChanceCalc(victim, attType);
+ float miss_chance = MeleeSpellMissChance(victim, attType, int32(GetWeaponSkillValue(attType, victim)) - int32(victim->GetDefenseSkillValue(this)), 0);
// Critical hit chance
- float crit_chance = GetUnitCriticalChance(attType, pVictim);
+ float crit_chance = GetUnitCriticalChance(attType, victim);
// stunned target cannot dodge and this is check in GetUnitDodgeChance() (returned 0 in this case)
- float dodge_chance = pVictim->GetUnitDodgeChance();
- float block_chance = pVictim->GetUnitBlockChance();
- float parry_chance = pVictim->GetUnitParryChance();
+ float dodge_chance = victim->GetUnitDodgeChance();
+ float block_chance = victim->GetUnitBlockChance();
+ float parry_chance = victim->GetUnitParryChance();
// Useful if want to specify crit & miss chances for melee, else it could be removed
sLog->outStaticDebug("MELEE OUTCOME: miss %f crit %f dodge %f parry %f block %f", miss_chance, crit_chance, dodge_chance, parry_chance, block_chance);
- return RollMeleeOutcomeAgainst(pVictim, attType, int32(crit_chance*100), int32(miss_chance*100), int32(dodge_chance*100), int32(parry_chance*100), int32(block_chance*100));
+ return RollMeleeOutcomeAgainst(victim, attType, int32(crit_chance*100), int32(miss_chance*100), int32(dodge_chance*100), int32(parry_chance*100), int32(block_chance*100));
}
-MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance) const
+MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit* victim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance) const
{
- if (pVictim->GetTypeId() == TYPEID_UNIT && pVictim->ToCreature()->IsInEvadeMode())
+ if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode())
return MELEE_HIT_EVADE;
- int32 attackerMaxSkillValueForLevel = GetMaxSkillValueForLevel(pVictim);
- int32 victimMaxSkillValueForLevel = pVictim->GetMaxSkillValueForLevel(this);
+ int32 attackerMaxSkillValueForLevel = GetMaxSkillValueForLevel(victim);
+ int32 victimMaxSkillValueForLevel = victim->GetMaxSkillValueForLevel(this);
- int32 attackerWeaponSkill = GetWeaponSkillValue(attType, pVictim);
- int32 victimDefenseSkill = pVictim->GetDefenseSkillValue(this);
+ int32 attackerWeaponSkill = GetWeaponSkillValue(attType, victim);
+ int32 victimDefenseSkill = victim->GetDefenseSkillValue(this);
// bonus from skills is 0.04%
int32 skillBonus = 4 * (attackerWeaponSkill - victimMaxSkillValueForLevel);
@@ -2052,7 +2044,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
}
// always crit against a sitting target (except 0 crit chance)
- if (pVictim->GetTypeId() == TYPEID_PLAYER && crit_chance > 0 && !pVictim->IsStandState())
+ if (victim->GetTypeId() == TYPEID_PLAYER && crit_chance > 0 && !victim->IsStandState())
{
sLog->outStaticDebug ("RollMeleeOutcomeAgainst: CRIT (sitting victim)");
return MELEE_HIT_CRIT;
@@ -2061,7 +2053,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
// Dodge chance
// only players can't dodge if attacker is behind
- if (pVictim->GetTypeId() == TYPEID_PLAYER && !pVictim->HasInArc(M_PI, this) && !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
+ if (victim->GetTypeId() == TYPEID_PLAYER && !victim->HasInArc(M_PI, this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
sLog->outStaticDebug ("RollMeleeOutcomeAgainst: attack came from behind and victim was a player.");
}
@@ -2090,7 +2082,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
// parry & block chances
// check if attack comes from behind, nobody can parry or block if attacker is behind
- if (!pVictim->HasInArc(M_PI, this) && !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
+ if (!victim->HasInArc(M_PI, this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
sLog->outStaticDebug ("RollMeleeOutcomeAgainst: attack came from behind.");
else
{
@@ -2100,7 +2092,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
else
parry_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
- if (pVictim->GetTypeId() == TYPEID_PLAYER || !(pVictim->ToCreature()->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY))
+ if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY))
{
int32 tmp2 = int32(parry_chance);
if (tmp2 > 0 // check if unit _can_ parry
@@ -2112,7 +2104,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
}
}
- if (pVictim->GetTypeId() == TYPEID_PLAYER || !(pVictim->ToCreature()->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK))
+ if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK))
{
tmp = block_chance;
if (tmp > 0 // check if unit _can_ block
@@ -2140,8 +2132,8 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
// Max 40% chance to score a glancing blow against mobs that are higher level (can do only players and pets and not with ranged weapon)
if (attType != RANGED_ATTACK &&
(GetTypeId() == TYPEID_PLAYER || ToCreature()->isPet()) &&
- pVictim->GetTypeId() != TYPEID_PLAYER && !pVictim->ToCreature()->isPet() &&
- getLevel() < pVictim->getLevelForTarget(this))
+ victim->GetTypeId() != TYPEID_PLAYER && !victim->ToCreature()->isPet() &&
+ getLevel() < victim->getLevelForTarget(this))
{
// cap possible value (with bonuses > max skill)
int32 skill = attackerWeaponSkill;
@@ -2158,7 +2150,7 @@ MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttack
}
// mobs can score crushing blows if they're 4 or more levels above victim
- if (getLevelForTarget(pVictim) >= pVictim->getLevelForTarget(this) + 4 &&
+ if (getLevelForTarget(victim) >= victim->getLevelForTarget(this) + 4 &&
// can be from by creature (if can) or from controlled player that considered as creature
!IsControlledByPlayer() &&
!(GetTypeId() == TYPEID_UNIT && ToCreature()->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRUSH))
@@ -2241,11 +2233,11 @@ float Unit::CalculateLevelPenalty(SpellEntry const* spellProto) const
return AddPctF(LvlFactor, -LvlPenalty);
}
-void Unit::SendMeleeAttackStart(Unit* pVictim)
+void Unit::SendMeleeAttackStart(Unit* victim)
{
WorldPacket data(SMSG_ATTACKSTART, 8 + 8);
data << uint64(GetGUID());
- data << uint64(pVictim->GetGUID());
+ data << uint64(victim->GetGUID());
SendMessageToSet(&data, true);
sLog->outStaticDebug("WORLD: Sent SMSG_ATTACKSTART");
@@ -2313,7 +2305,7 @@ int32 Unit::GetMechanicResistChance(const SpellEntry *spell)
}
// Melee based spells hit result calculations
-SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
+SpellMissInfo Unit::MeleeSpellHitResult(Unit* victim, SpellEntry const* spell)
{
// Spells with SPELL_ATTR3_IGNORE_HIT_RESULT will additionally fully ignore
// resist and deflect chances
@@ -2333,14 +2325,14 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
attackerWeaponSkill = getLevel() * 5;
// bonus from skills is 0.04% per skill Diff
else
- attackerWeaponSkill = int32(GetWeaponSkillValue(attType, pVictim));
+ attackerWeaponSkill = int32(GetWeaponSkillValue(attType, victim));
- int32 skillDiff = attackerWeaponSkill - int32(pVictim->GetMaxSkillValueForLevel(this));
- int32 fullSkillDiff = attackerWeaponSkill - int32(pVictim->GetDefenseSkillValue(this));
+ int32 skillDiff = attackerWeaponSkill - int32(victim->GetMaxSkillValueForLevel(this));
+ int32 fullSkillDiff = attackerWeaponSkill - int32(victim->GetDefenseSkillValue(this));
uint32 roll = urand (0, 10000);
- uint32 missChance = uint32(MeleeSpellMissChance(pVictim, attType, fullSkillDiff, spell->Id) * 100.0f);
+ uint32 missChance = uint32(MeleeSpellMissChance(victim, attType, fullSkillDiff, spell->Id) * 100.0f);
// Roll miss
uint32 tmp = missChance;
if (roll < tmp)
@@ -2354,7 +2346,7 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
int32 effect_mech = GetEffectMechanic(spell, eff);
if (effect_mech)
{
- int32 temp = pVictim->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
+ int32 temp = victim->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
if (resist_mech < temp*100)
resist_mech = temp*100;
}
@@ -2373,7 +2365,7 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
return SPELL_MISS_NONE;
// Chance resist mechanic
- int32 resist_chance = pVictim->GetMechanicResistChance(spell) * 100;
+ int32 resist_chance = victim->GetMechanicResistChance(spell) * 100;
tmp += resist_chance;
if (roll < tmp)
return SPELL_MISS_RESIST;
@@ -2382,9 +2374,9 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (attType == RANGED_ATTACK)
{
// only if in front
- if (pVictim->HasInArc(M_PI, this) || pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
+ if (victim->HasInArc(M_PI, this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
- int32 deflect_chance = pVictim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
+ int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
tmp+=deflect_chance;
if (roll < tmp)
return SPELL_MISS_DEFLECT;
@@ -2393,19 +2385,19 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
}
// Check for attack from behind
- if (!pVictim->HasInArc(M_PI, this) && !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
+ if (!victim->HasInArc(M_PI, this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
// Can`t dodge from behind in PvP (but its possible in PvE)
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
+ if (victim->GetTypeId() == TYPEID_PLAYER)
canDodge = false;
// Can`t parry or block
canParry = false;
canBlock = false;
}
// Check creatures flags_extra for disable parry
- if (pVictim->GetTypeId() == TYPEID_UNIT)
+ if (victim->GetTypeId() == TYPEID_UNIT)
{
- uint32 flagEx = pVictim->ToCreature()->GetCreatureInfo()->flags_extra;
+ uint32 flagEx = victim->ToCreature()->GetCreatureInfo()->flags_extra;
if (flagEx & CREATURE_FLAG_EXTRA_NO_PARRY)
canParry = false;
// Check creatures flags_extra for disable block
@@ -2432,7 +2424,7 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (canDodge)
{
// Roll dodge
- int32 dodgeChance = int32(pVictim->GetUnitDodgeChance() * 100.0f) - skillDiff * 4;
+ int32 dodgeChance = int32(victim->GetUnitDodgeChance() * 100.0f) - skillDiff * 4;
// Reduce enemy dodge chance by SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
dodgeChance += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
dodgeChance = int32(float(dodgeChance) * GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
@@ -2451,7 +2443,7 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (canParry)
{
// Roll parry
- int32 parryChance = int32(pVictim->GetUnitParryChance() * 100.0f) - skillDiff * 4;
+ int32 parryChance = int32(victim->GetUnitParryChance() * 100.0f) - skillDiff * 4;
// Reduce parry chance by attacker expertise rating
if (GetTypeId() == TYPEID_PLAYER)
parryChance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
@@ -2467,7 +2459,7 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (canBlock)
{
- int32 blockChance = int32(pVictim->GetUnitBlockChance() * 100.0f) - skillDiff * 4;
+ int32 blockChance = int32(victim->GetUnitBlockChance() * 100.0f) - skillDiff * 4;
if (blockChance < 0)
blockChance = 0;
tmp += blockChance;
@@ -2480,19 +2472,19 @@ SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
}
// TODO need use unit spell resistances in calculations
-SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
+SpellMissInfo Unit::MagicSpellHitResult(Unit* victim, SpellEntry const* spell)
{
// Can`t miss on dead target (on skinning for example)
- if (!pVictim->isAlive() && pVictim->GetTypeId() != TYPEID_PLAYER)
+ if (!victim->isAlive() && victim->GetTypeId() != TYPEID_PLAYER)
return SPELL_MISS_NONE;
SpellSchoolMask schoolMask = GetSpellSchoolMask(spell);
// PvP - PvE spell misschances per leveldif > 2
- int32 lchance = pVictim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
- int32 thisLevel = getLevelForTarget(pVictim);
+ int32 lchance = victim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
+ int32 thisLevel = getLevelForTarget(victim);
if (GetTypeId() == TYPEID_UNIT && ToCreature()->isTrigger())
thisLevel = std::max<int32>(thisLevel, spell->spellLevel);
- int32 leveldif = int32(pVictim->getLevelForTarget(this)) - thisLevel;
+ int32 leveldif = int32(victim->getLevelForTarget(this)) - thisLevel;
// Base hit chance from attacker and victim levels
int32 modHitChance;
@@ -2512,14 +2504,14 @@ SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (!(spell->AttributesEx3 & SPELL_ATTR3_IGNORE_HIT_RESULT))
{
// Chance hit from victim SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE auras
- modHitChance += pVictim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
+ modHitChance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
// Reduce spell hit chance for Area of effect spells from victim SPELL_AURA_MOD_AOE_AVOIDANCE aura
if (IsAreaOfEffectSpell(spell))
- modHitChance -= pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_AOE_AVOIDANCE);
+ modHitChance -= victim->GetTotalAuraModifier(SPELL_AURA_MOD_AOE_AVOIDANCE);
// Decrease hit chance from victim rating bonus
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
- modHitChance -= int32(pVictim->ToPlayer()->GetRatingBonusValue(CR_HIT_TAKEN_SPELL));
+ if (victim->GetTypeId() == TYPEID_PLAYER)
+ modHitChance -= int32(victim->ToPlayer()->GetRatingBonusValue(CR_HIT_TAKEN_SPELL));
}
int32 HitChance = modHitChance * 100;
@@ -2544,7 +2536,7 @@ SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
return SPELL_MISS_NONE;
// Chance resist mechanic (select max value from every mechanic spell effect)
- int32 resist_chance = pVictim->GetMechanicResistChance(spell) * 100;
+ int32 resist_chance = victim->GetMechanicResistChance(spell) * 100;
tmp += resist_chance;
// Chance resist debuff
@@ -2562,8 +2554,8 @@ SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
if (bNegativeAura)
{
- tmp += pVictim->GetMaxPositiveAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel)) * 100;
- tmp += pVictim->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel)) * 100;
+ tmp += victim->GetMaxPositiveAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel)) * 100;
+ tmp += victim->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel)) * 100;
}
}
@@ -2572,9 +2564,9 @@ SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
return SPELL_MISS_RESIST;
// cast by caster in front of victim
- if (pVictim->HasInArc(M_PI, this) || pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
+ if (victim->HasInArc(M_PI, this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
- int32 deflect_chance = pVictim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
+ int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
tmp += deflect_chance;
if (rand < tmp)
return SPELL_MISS_DEFLECT;
@@ -2591,40 +2583,40 @@ SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
// Parry
// For spells
// Resist
-SpellMissInfo Unit::SpellHitResult(Unit *pVictim, SpellEntry const *spell, bool CanReflect)
+SpellMissInfo Unit::SpellHitResult(Unit* victim, SpellEntry const* spell, bool CanReflect)
{
// Check for immune
- if (pVictim->IsImmunedToSpell(spell))
+ if (victim->IsImmunedToSpell(spell))
return SPELL_MISS_IMMUNE;
// All positive spells can`t miss
// TODO: client not show miss log for this spells - so need find info for this in dbc and use it!
if (IsPositiveSpell(spell->Id)
- &&(!IsHostileTo(pVictim))) // prevent from affecting enemy by "positive" spell
+ &&(!IsHostileTo(victim))) // prevent from affecting enemy by "positive" spell
return SPELL_MISS_NONE;
// Check for immune
- if (pVictim->IsImmunedToDamage(spell))
+ if (victim->IsImmunedToDamage(spell))
return SPELL_MISS_IMMUNE;
- if (this == pVictim)
+ if (this == victim)
return SPELL_MISS_NONE;
// Return evade for units in evade mode
- if (pVictim->GetTypeId() == TYPEID_UNIT && pVictim->ToCreature()->IsInEvadeMode())
+ if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode())
return SPELL_MISS_EVADE;
// Try victim reflect spell
if (CanReflect)
{
- int32 reflectchance = pVictim->GetTotalAuraModifier(SPELL_AURA_REFLECT_SPELLS);
- Unit::AuraEffectList const& mReflectSpellsSchool = pVictim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
+ int32 reflectchance = victim->GetTotalAuraModifier(SPELL_AURA_REFLECT_SPELLS);
+ Unit::AuraEffectList const& mReflectSpellsSchool = victim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
for (Unit::AuraEffectList::const_iterator i = mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end(); ++i)
if ((*i)->GetMiscValue() & GetSpellSchoolMask(spell))
reflectchance += (*i)->GetAmount();
if (reflectchance > 0 && roll_chance_i(reflectchance))
{
// Start triggers for remove charges if need (trigger only for victim, and mark as active spell)
- ProcDamageAndSpell(pVictim, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, spell);
+ ProcDamageAndSpell(victim, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, spell);
return SPELL_MISS_REFLECT;
}
}
@@ -2633,11 +2625,11 @@ SpellMissInfo Unit::SpellHitResult(Unit *pVictim, SpellEntry const *spell, bool
{
case SPELL_DAMAGE_CLASS_RANGED:
case SPELL_DAMAGE_CLASS_MELEE:
- return MeleeSpellHitResult(pVictim, spell);
+ return MeleeSpellHitResult(victim, spell);
case SPELL_DAMAGE_CLASS_NONE:
return SPELL_MISS_NONE;
case SPELL_DAMAGE_CLASS_MAGIC:
- return MagicSpellHitResult(pVictim, spell);
+ return MagicSpellHitResult(victim, spell);
}
return SPELL_MISS_NONE;
}
@@ -2737,7 +2729,7 @@ float Unit::GetUnitBlockChance() const
}
}
-float Unit::GetUnitCriticalChance(WeaponAttackType attackType, const Unit *pVictim) const
+float Unit::GetUnitCriticalChance(WeaponAttackType attackType, const Unit* victim) const
{
float crit;
@@ -2769,25 +2761,25 @@ float Unit::GetUnitCriticalChance(WeaponAttackType attackType, const Unit *pVict
// flat aura mods
if (attackType == RANGED_ATTACK)
- crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
+ crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
else
- crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
+ crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
- crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
+ crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
// reduce crit chance from Rating for players
if (attackType != RANGED_ATTACK)
{
- ApplyResilience(pVictim, &crit, NULL, false, CR_CRIT_TAKEN_MELEE);
+ ApplyResilience(victim, &crit, NULL, false, CR_CRIT_TAKEN_MELEE);
// Glyph of barkskin
- if (pVictim->HasAura(63057) && pVictim->HasAura(22812))
+ if (victim->HasAura(63057) && victim->HasAura(22812))
crit -= 25.0f;
}
else
- ApplyResilience(pVictim, &crit, NULL, false, CR_CRIT_TAKEN_RANGED);
+ ApplyResilience(victim, &crit, NULL, false, CR_CRIT_TAKEN_RANGED);
// Apply crit chance from defence skill
- crit += (int32(GetMaxSkillValueForLevel(pVictim)) - int32(pVictim->GetDefenseSkillValue(this))) * 0.04f;
+ crit += (int32(GetMaxSkillValueForLevel(victim)) - int32(victim->GetDefenseSkillValue(this))) * 0.04f;
if (crit < 0.0f)
crit = 0.0f;
@@ -3241,7 +3233,7 @@ void Unit::_AddAura(UnitAura* aura, Unit* caster)
// creates aura application instance and registers it in lists
// aura application effects are handled separately to prevent aura list corruption
-AuraApplication * Unit::_CreateAuraApplication(Aura * aura, uint8 effMask)
+AuraApplication * Unit::_CreateAuraApplication(Aura* aura, uint8 effMask)
{
// can't apply aura on unit which is going to be deleted - to not create a memory leak
ASSERT(!m_cleanupDone);
@@ -3277,7 +3269,7 @@ AuraApplication * Unit::_CreateAuraApplication(Aura * aura, uint8 effMask)
return aurApp;
}
-void Unit::_ApplyAuraEffect(Aura * aura, uint8 effIndex)
+void Unit::_ApplyAuraEffect(Aura* aura, uint8 effIndex)
{
ASSERT(aura);
ASSERT(aura->HasEffect(effIndex));
@@ -3423,7 +3415,7 @@ void Unit::_UnapplyAura(AuraApplication * aurApp, AuraRemoveMode removeMode)
ASSERT(false);
}
-void Unit::_RemoveNoStackAuraApplicationsDueToAura(Aura * aura)
+void Unit::_RemoveNoStackAuraApplicationsDueToAura(Aura* aura)
{
// dynobj auras can stack infinite number of times
if (aura->GetType() == DYNOBJ_AURA_TYPE)
@@ -3456,7 +3448,7 @@ void Unit::_RemoveNoStackAuraApplicationsDueToAura(Aura * aura)
}
}
-void Unit::_RemoveNoStackAurasDueToAura(Aura * aura)
+void Unit::_RemoveNoStackAurasDueToAura(Aura* aura)
{
SpellEntry const* spellProto = aura->GetSpellProto();
@@ -3485,7 +3477,7 @@ void Unit::_RemoveNoStackAurasDueToAura(Aura * aura)
}
}
-bool Unit::_IsNoStackAuraDueToAura(Aura * appliedAura, Aura * existingAura) const
+bool Unit::_IsNoStackAuraDueToAura(Aura* appliedAura, Aura* existingAura) const
{
SpellEntry const* spellProto = appliedAura->GetSpellProto();
// Do not check already applied aura
@@ -3532,7 +3524,7 @@ bool Unit::_IsNoStackAuraDueToAura(Aura * appliedAura, Aura * existingAura) cons
return true;
}
-void Unit::_RegisterAuraEffect(AuraEffect * aurEff, bool apply)
+void Unit::_RegisterAuraEffect(AuraEffect* aurEff, bool apply)
{
if (apply)
m_modAuras[aurEff->GetAuraType()].push_back(aurEff);
@@ -3574,7 +3566,7 @@ void Unit::RemoveOwnedAura(uint32 spellId, uint64 caster, uint8 reqEffMask, Aura
++itr;
}
-void Unit::RemoveOwnedAura(Aura * aura, AuraRemoveMode removeMode)
+void Unit::RemoveOwnedAura(Aura* aura, AuraRemoveMode removeMode)
{
if (aura->IsRemoved())
return;
@@ -3591,7 +3583,7 @@ void Unit::RemoveOwnedAura(Aura * aura, AuraRemoveMode removeMode)
ASSERT(false);
}
-Aura * Unit::GetOwnedAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask, Aura* except) const
+Aura* Unit::GetOwnedAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask, Aura* except) const
{
for (AuraMap::const_iterator itr = m_ownedAuras.lower_bound(spellId); itr != m_ownedAuras.upper_bound(spellId); ++itr)
if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask) && (!casterGUID || itr->second->GetCasterGUID() == casterGUID) && (!itemCasterGUID || itr->second->GetCastItemGUID() == itemCasterGUID) && (!except || except != itr->second))
@@ -3660,7 +3652,7 @@ void Unit::RemoveAura(AuraApplication * aurApp, AuraRemoveMode mode)
}
}
-void Unit::RemoveAura(Aura * aura, AuraRemoveMode mode)
+void Unit::RemoveAura(Aura* aura, AuraRemoveMode mode)
{
if (aura->IsRemoved())
return;
@@ -3793,7 +3785,7 @@ void Unit::RemoveAurasDueToSpellByDispel(uint32 spellId, uint64 casterGUID, Unit
}
}
-void Unit::RemoveAurasDueToSpellBySteal(uint32 spellId, uint64 casterGUID, Unit *stealer)
+void Unit::RemoveAurasDueToSpellBySteal(uint32 spellId, uint64 casterGUID, Unit* stealer)
{
for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId); iter != m_ownedAuras.upper_bound(spellId);)
{
@@ -3881,7 +3873,7 @@ void Unit::RemoveAurasDueToItemSpell(Item* castItem, uint32 spellId)
}
}
-void Unit::RemoveAurasByType(AuraType auraType, uint64 casterGUID, Aura * except, bool negative, bool positive)
+void Unit::RemoveAurasByType(AuraType auraType, uint64 casterGUID, Aura* except, bool negative, bool positive)
{
for (AuraEffectList::iterator iter = m_modAuras[auraType].begin(); iter != m_modAuras[auraType].end();)
{
@@ -4183,7 +4175,7 @@ void Unit::_ApplyAllAuraStatMods()
(*i).second->GetBase()->HandleAllEffects(i->second, AURA_EFFECT_HANDLE_STAT, true);
}
-AuraEffect * Unit::GetAuraEffect(uint32 spellId, uint8 effIndex, uint64 caster) const
+AuraEffect* Unit::GetAuraEffect(uint32 spellId, uint8 effIndex, uint64 caster) const
{
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.lower_bound(spellId); itr != m_appliedAuras.upper_bound(spellId); ++itr)
if (itr->second->HasEffect(effIndex) && (!caster || itr->second->GetBase()->GetCasterGUID() == caster))
@@ -4191,7 +4183,7 @@ AuraEffect * Unit::GetAuraEffect(uint32 spellId, uint8 effIndex, uint64 caster)
return NULL;
}
-AuraEffect * Unit::GetAuraEffectOfRankedSpell(uint32 spellId, uint8 effIndex, uint64 caster) const
+AuraEffect* Unit::GetAuraEffectOfRankedSpell(uint32 spellId, uint8 effIndex, uint64 caster) const
{
uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
while (true)
@@ -4248,7 +4240,7 @@ AuraApplication * Unit::GetAuraApplication(uint32 spellId, uint64 casterGUID, ui
return NULL;
}
-Aura * Unit::GetAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask) const
+Aura* Unit::GetAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask) const
{
AuraApplication * aurApp = GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask);
return aurApp ? aurApp->GetBase() : NULL;
@@ -4270,7 +4262,7 @@ AuraApplication * Unit::GetAuraApplicationOfRankedSpell(uint32 spellId, uint64 c
return NULL;
}
-Aura * Unit::GetAuraOfRankedSpell(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask) const
+Aura* Unit::GetAuraOfRankedSpell(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask) const
{
AuraApplication * aurApp = GetAuraApplicationOfRankedSpell(spellId, casterGUID, itemCasterGUID, reqEffMask);
return aurApp ? aurApp->GetBase() : NULL;
@@ -4385,7 +4377,7 @@ bool Unit::HasAuraWithMechanic(uint32 mechanicMask)
return false;
}
-AuraEffect * Unit::IsScriptOverriden(SpellEntry const* spell, int32 script) const
+AuraEffect* Unit::IsScriptOverriden(SpellEntry const* spell, int32 script) const
{
AuraEffectList const& auras = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
@@ -4843,15 +4835,15 @@ void Unit::SendSpellNonMeleeDamageLog(Unit* target, uint32 SpellID, uint32 Damag
SendSpellNonMeleeDamageLog(&log);
}
-void Unit::ProcDamageAndSpell(Unit *pVictim, uint32 procAttacker, uint32 procVictim, uint32 procExtra, uint32 amount, WeaponAttackType attType, SpellEntry const *procSpell, SpellEntry const* procAura)
+void Unit::ProcDamageAndSpell(Unit* victim, uint32 procAttacker, uint32 procVictim, uint32 procExtra, uint32 amount, WeaponAttackType attType, SpellEntry const* procSpell, SpellEntry const* procAura)
{
// Not much to do if no flags are set.
if (procAttacker)
- ProcDamageAndSpellFor(false, pVictim, procAttacker, procExtra, attType, procSpell, amount, procAura);
+ ProcDamageAndSpellFor(false, victim, procAttacker, procExtra, attType, procSpell, amount, procAura);
// Now go on with a victim's events'n'auras
// Not much to do if no flags are set or there is no victim
- if (pVictim && pVictim->isAlive() && procVictim)
- pVictim->ProcDamageAndSpellFor(true, this, procVictim, procExtra, attType, procSpell, amount, procAura);
+ if (victim && victim->isAlive() && procVictim)
+ victim->ProcDamageAndSpellFor(true, this, procVictim, procExtra, attType, procSpell, amount, procAura);
}
void Unit::SendPeriodicAuraLog(SpellPeriodicAuraLogInfo *pInfo)
@@ -5012,7 +5004,7 @@ void Unit::SendAttackStateUpdate(uint32 HitInfo, Unit* target, uint8 /*SwingType
SendAttackStateUpdate(&dmgInfo);
}
-bool Unit::HandleHasteAuraProc(Unit *pVictim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
+bool Unit::HandleHasteAuraProc(Unit* victim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const* hasteSpell = triggeredByAura->GetSpellProto();
@@ -5020,7 +5012,7 @@ bool Unit::HandleHasteAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
uint32 triggered_spell_id = 0;
- Unit* target = pVictim;
+ Unit* target = victim;
int32 basepoints0 = 0;
switch(hasteSpell->SpellFamilyName)
@@ -5034,7 +5026,7 @@ bool Unit::HandleHasteAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 33735:
{
target = SelectNearbyTarget();
- if (!target || target == pVictim)
+ if (!target || target == victim)
return false;
basepoints0 = damage;
triggered_spell_id = 22482;
@@ -5075,7 +5067,7 @@ bool Unit::HandleHasteAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
return true;
}
-bool Unit::HandleSpellCritChanceAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
+bool Unit::HandleSpellCritChanceAuraProc(Unit* victim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const* triggeredByAuraSpell = triggeredByAura->GetSpellProto();
@@ -5083,7 +5075,7 @@ bool Unit::HandleSpellCritChanceAuraProc(Unit *pVictim, uint32 /*damage*/, AuraE
? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
uint32 triggered_spell_id = 0;
- Unit* target = pVictim;
+ Unit* target = victim;
int32 basepoints0 = 0;
switch(triggeredByAuraSpell->SpellFamilyName)
@@ -5137,7 +5129,7 @@ bool Unit::HandleSpellCritChanceAuraProc(Unit *pVictim, uint32 /*damage*/, AuraE
return true;
}
-bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const* procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown)
+bool Unit::HandleDummyAuraProc(Unit* victim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const* procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown)
{
SpellEntry const* dummySpell = triggeredByAura->GetSpellProto();
uint32 effIndex = triggeredByAura->GetEffIndex();
@@ -5149,7 +5141,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
uint32 triggered_spell_id = 0;
uint32 cooldown_spell_id = 0; // for random trigger, will be one of the triggered spell to avoid repeatable triggers
// otherwise, it's the triggered_spell_id by default
- Unit* target = pVictim;
+ Unit* target = victim;
int32 basepoints0 = 0;
uint64 originalCaster = 0;
@@ -5164,7 +5156,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
{
if (Unit* owner = GetOwner())
{
- basepoints0 = int32(damage*1.50);
+ basepoints0 = int32(damage * 1.50f);
target = owner;
triggered_spell_id = 50454;
break;
@@ -5501,11 +5493,11 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 31872:
{
// Roll chane
- if (!pVictim || !pVictim->isAlive() || !roll_chance_i(triggerAmount))
+ if (!victim || !victim->isAlive() || !roll_chance_i(triggerAmount))
return false;
// Remove any stun effect on target
- pVictim->RemoveAurasWithMechanic(1<<MECHANIC_STUN, AURA_REMOVE_BY_ENEMY_SPELL);
+ victim->RemoveAurasWithMechanic(1<<MECHANIC_STUN, AURA_REMOVE_BY_ENEMY_SPELL);
return true;
}
// Glyph of Life Tap
@@ -5621,19 +5613,19 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Item - Shadowmourne Legendary
case 71903:
{
- if (!pVictim || !pVictim->isAlive() || HasAura(73422)) // cant collect shards while under effect of Chaos Bane buff
+ if (!victim || !victim->isAlive() || HasAura(73422)) // cant collect shards while under effect of Chaos Bane buff
return false;
CastSpell(this, 71905, true, NULL, triggeredByAura);
- // this can't be handled in AuraScript because we need to know pVictim
+ // this can't be handled in AuraScript because we need to know victim
Aura const* dummy = GetAura(71905);
if (!dummy || dummy->GetStackAmount() < 10)
return false;
RemoveAurasDueToSpell(71905);
triggered_spell_id = 71904;
- target = pVictim;
+ target = victim;
break;
}
// Shadow's Fate (Shadowmourne questline)
@@ -5690,7 +5682,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
}
case 65032: // Boom aura (321 Boombot)
{
- if (pVictim->GetEntry() != 33343) // Scrapbot
+ if (victim->GetEntry() != 33343) // Scrapbot
return false;
InstanceScript* instance = GetInstanceScript();
@@ -5834,7 +5826,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
}
triggered_spell_id = 12654;
- basepoints0 += pVictim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
+ basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
break;
}
// Glyph of Ice Block
@@ -5860,7 +5852,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 64411:
{
basepoints0 = int32(CalculatePctN(damage, 15));
- if (AuraEffect* aurEff = pVictim->GetAuraEffect(64413, 0, GetGUID()))
+ if (AuraEffect* aurEff = victim->GetAuraEffect(64413, 0, GetGUID()))
{
// The shield can grow to a maximum size of 20, 000 damage absorbtion
aurEff->SetAmount(std::max<int32>(aurEff->GetAmount() + basepoints0, 20000));
@@ -5869,7 +5861,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
aurEff->GetBase()->RefreshDuration();
return true;
}
- target = pVictim;
+ target = victim;
triggered_spell_id = 64413;
break;
}
@@ -5923,7 +5915,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (dummySpell->SpellFamilyFlags[1] & 0x8)
{
// check attack comes not from behind
- if (!HasInArc(M_PI, pVictim))
+ if (!HasInArc(M_PI, victim))
return false;
triggered_spell_id = 22858;
@@ -5933,7 +5925,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (dummySpell->SpellIconID == 1697)
{
// only for spells and hit/crit (trigger start always) and not start from self casted spells (5530 Mace Stun Effect for example)
- if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == pVictim)
+ if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == victim)
return false;
// Need stun or root mechanic
if (!(GetAllSpellMechanicMask(procSpell) & ((1<<MECHANIC_ROOT)|(1<<MECHANIC_STUN))))
@@ -5969,11 +5961,11 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Glyph of Sunder Armor
if (dummySpell->Id == 58387)
{
- if (!pVictim || !pVictim->isAlive() || !procSpell)
+ if (!victim || !victim->isAlive() || !procSpell)
return false;
target = SelectNearbyTarget();
- if (!target || target == pVictim)
+ if (!target || target == victim)
return false;
CastSpell(target, 58567, true);
@@ -6141,18 +6133,18 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Vampiric Touch
if (dummySpell->SpellFamilyFlags[1] & 0x00000400)
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
if (effIndex != 0)
return false;
- // pVictim is caster of aura
- if (triggeredByAura->GetCasterGUID() != pVictim->GetGUID())
+ // victim is caster of aura
+ if (triggeredByAura->GetCasterGUID() != victim->GetGUID())
return false;
// Energize 0.25% of max. mana
- pVictim->CastSpell(pVictim, 57669, true, castItem, triggeredByAura);
+ victim->CastSpell(victim, 57669, true, castItem, triggeredByAura);
return true; // no hidden cooldown
}
// Divine Aegis
@@ -6174,7 +6166,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (dummySpell->SpellIconID == 2218)
{
// Proc only from Abolish desease on self cast
- if (procSpell->Id != 552 || pVictim != this || !roll_chance_i(triggerAmount))
+ if (procSpell->Id != 552 || victim != this || !roll_chance_i(triggerAmount))
return false;
triggered_spell_id = 64136;
target = this;
@@ -6185,7 +6177,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Vampiric Embrace
case 15286:
{
- if (!pVictim || !pVictim->isAlive() || procSpell->SpellFamilyFlags[1] & 0x80000)
+ if (!victim || !victim->isAlive() || procSpell->SpellFamilyFlags[1] & 0x80000)
return false;
// heal amount
@@ -6393,7 +6385,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Glyph of Rejuvenation
case 54754:
{
- if (!pVictim || !pVictim->HealthBelowPct(uint32(triggerAmount)))
+ if (!victim || !victim->HealthBelowPct(uint32(triggerAmount)))
return false;
basepoints0 = CalculatePctN(int32(damage), triggerAmount);
triggered_spell_id = 54755;
@@ -6465,7 +6457,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
return false;
basepoints0 = CalculatePctN(int32(damage), triggerAmount) / (GetSpellMaxDuration(triggeredSpell) / triggeredSpell->EffectAmplitude[0]);
// Add remaining ticks to damage done
- basepoints0 += pVictim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
+ basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
}
break;
}
@@ -6479,10 +6471,10 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
Player* caster = ToPlayer();
if (!caster)
return false;
- if (!caster->GetGroup() && pVictim == this)
+ if (!caster->GetGroup() && victim == this)
return false;
- CastCustomSpell(70691, SPELLVALUE_BASE_POINT0, damage, pVictim, true);
+ CastCustomSpell(70691, SPELLVALUE_BASE_POINT0, damage, victim, true);
return true;
}
}
@@ -6551,7 +6543,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 32748:
{
// Prevent cast Deadly Throw Interrupt on self from last effect (apply dummy) of Deadly Throw
- if (this == pVictim)
+ if (this == victim)
return false;
triggered_spell_id = 32747;
@@ -6609,7 +6601,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Explosive Shot
if (procSpell->SpellFamilyFlags[2] & 0x200)
{
- if (AuraEffect const* pEff = pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DUMMY, SPELLFAMILY_HUNTER, 0x0, 0x80000000, 0x0, GetGUID()))
+ if (AuraEffect const* pEff = victim->GetAuraEffect(SPELL_AURA_PERIODIC_DUMMY, SPELLFAMILY_HUNTER, 0x0, 0x80000000, 0x0, GetGUID()))
basepoints0 = CalculatePowerCost(pEff->GetSpellProto(), this, SpellSchoolMask(pEff->GetSpellProto()->SchoolMask)) * 4/10/3;
}
else
@@ -6674,7 +6666,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Glyph of Mend Pet
if (dummySpell->Id == 57870)
{
- pVictim->CastSpell(pVictim, 57894, true, NULL, NULL, GetGUID());
+ victim->CastSpell(victim, 57894, true, NULL, NULL, GetGUID());
return true;
}
break;
@@ -6689,7 +6681,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
triggered_spell_id = 25742;
float ap = GetTotalAttackPowerValue(BASE_ATTACK);
int32 holy = SpellBaseDamageBonus(SPELL_SCHOOL_MASK_HOLY) +
- SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_HOLY, pVictim);
+ SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_HOLY, victim);
basepoints0 = (int32)GetAttackTime(BASE_ATTACK) * int32(ap * 0.022f + 0.044f * holy) / 1000;
break;
}
@@ -6703,9 +6695,9 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (beaconTarget == this)
return false;
// check if it was heal by paladin which casted this beacon of light
- if (beaconTarget->GetAura(53563, pVictim->GetGUID()))
+ if (beaconTarget->GetAura(53563, victim->GetGUID()))
{
- if (beaconTarget->IsWithinLOSInMap(pVictim))
+ if (beaconTarget->IsWithinLOSInMap(victim))
{
basepoints0 = damage;
triggered_spell_id = 53654;
@@ -6744,7 +6736,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
basepoints0 = damage / 12;
if (basepoints0)
- CastCustomSpell(this, 66922, &basepoints0, NULL, NULL, true, 0, triggeredByAura, pVictim->GetGUID());
+ CastCustomSpell(this, 66922, &basepoints0, NULL, NULL, true, 0, triggeredByAura, victim->GetGUID());
return true;
}
@@ -6769,7 +6761,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
basepoints0 = triggerAmount * damage / 400;
triggered_spell_id = 61840;
// Add remaining ticks to damage done
- basepoints0 += pVictim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
+ basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
break;
}
// Sheath of Light
@@ -6796,29 +6788,29 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 20185:
{
// 2% of base mana
- basepoints0 = int32(pVictim->CountPctFromMaxHealth(2));
- pVictim->CastCustomSpell(pVictim, 20267, &basepoints0, 0, 0, true, 0, triggeredByAura);
+ basepoints0 = int32(victim->CountPctFromMaxHealth(2));
+ victim->CastCustomSpell(victim, 20267, &basepoints0, 0, 0, true, 0, triggeredByAura);
return true;
}
// Judgement of Wisdom
case 20186:
{
- if (pVictim && pVictim->isAlive() && pVictim->getPowerType() == POWER_MANA)
+ if (victim && victim->isAlive() && victim->getPowerType() == POWER_MANA)
{
// 2% of base mana
- basepoints0 = int32(CalculatePctN(pVictim->GetCreateMana(), 2));
- pVictim->CastCustomSpell(pVictim, 20268, &basepoints0, NULL, NULL, true, 0, triggeredByAura);
+ basepoints0 = int32(CalculatePctN(victim->GetCreateMana(), 2));
+ victim->CastCustomSpell(victim, 20268, &basepoints0, NULL, NULL, true, 0, triggeredByAura);
}
return true;
}
// Holy Power (Redemption Armor set)
case 28789:
{
- if (!pVictim)
+ if (!victim)
return false;
// Set class defined buff
- switch (pVictim->getClass())
+ switch (victim->getClass())
{
case CLASS_PALADIN:
case CLASS_PRIEST:
@@ -6873,13 +6865,13 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
triggered_spell_id = 31803;
// On target with 5 stacks of Holy Vengeance direct damage is done
- if (Aura* aur = pVictim->GetAura(triggered_spell_id, GetGUID()))
+ if (Aura* aur = victim->GetAura(triggered_spell_id, GetGUID()))
{
if (aur->GetStackAmount() == 5)
{
if (stacker)
aur->RefreshDuration();
- CastSpell(pVictim, 42463, true);
+ CastSpell(victim, 42463, true);
return true;
}
}
@@ -6905,13 +6897,13 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
triggered_spell_id = 53742;
// On target with 5 stacks of Blood Corruption direct damage is done
- if (Aura* aur = pVictim->GetAura(triggered_spell_id, GetGUID()))
+ if (Aura* aur = victim->GetAura(triggered_spell_id, GetGUID()))
{
if (aur->GetStackAmount() == 5)
{
if (stacker)
aur->RefreshDuration();
- CastSpell(pVictim, 53739, true);
+ CastSpell(victim, 53739, true);
return true;
}
}
@@ -6924,8 +6916,8 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 31785:
case 33776:
{
- // if healed by another unit (pVictim)
- if (this == pVictim)
+ // if healed by another unit (victim)
+ if (this == victim)
return false;
// heal amount
@@ -6981,7 +6973,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 71406: // Tiny Abomination in a Jar
case 71545: // Tiny Abomination in a Jar (Heroic)
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
CastSpell(this, 71432, true, NULL, triggeredByAura);
@@ -6996,7 +6988,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (Player const* player = ToPlayer())
if (player->GetWeaponForAttack(OFF_ATTACK, true) && urand(0, 1))
triggered_spell_id = 71434;
- target = pVictim;
+ target = victim;
break;
}
// Item - Icecrown 25 Normal Dagger Proc
@@ -7081,11 +7073,11 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Totemic Power (The Earthshatterer set)
case 28823:
{
- if (!pVictim)
+ if (!victim)
return false;
// Set class defined buff
- switch (pVictim->getClass())
+ switch (victim->getClass())
{
case CLASS_PALADIN:
case CLASS_PRIEST:
@@ -7120,7 +7112,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 33757:
{
Player* plr = ToPlayer();
- if (!plr || !castItem || !castItem->IsEquipped() || !pVictim || !pVictim->isAlive())
+ if (!plr || !castItem || !castItem->IsEquipped() || !victim || !victim->isAlive())
return false;
// custom cooldown processing case
@@ -7175,7 +7167,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
return false;
}
- int32 extra_attack_power = CalculateSpellDamage(pVictim, windfurySpellEntry, 1);
+ int32 extra_attack_power = CalculateSpellDamage(victim, windfurySpellEntry, 1);
// Value gained from additional AP
basepoints0 = int32(extra_attack_power / 14.0f * GetAttackTime(BASE_ATTACK) / 1000);
@@ -7187,7 +7179,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Attack Twice
for (uint32 i = 0; i < 2; ++i)
- CastCustomSpell(pVictim, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
+ CastCustomSpell(victim, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
return true;
}
@@ -7226,7 +7218,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
case 55440:
{
// Not proc from self heals
- if (this == pVictim)
+ if (this == victim)
return false;
basepoints0 = CalculatePctN(int32(damage), triggerAmount);
target = this;
@@ -7408,13 +7400,13 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Flametongue Weapon (Passive)
if (dummySpell->SpellFamilyFlags[0] & 0x200000)
{
- if (GetTypeId() != TYPEID_PLAYER || !pVictim || !pVictim->isAlive() || !castItem || !castItem->IsEquipped())
+ if (GetTypeId() != TYPEID_PLAYER || !victim || !victim->isAlive() || !castItem || !castItem->IsEquipped())
return false;
float fire_onhit = float(CalculatePctF(SpellMgr::CalculateSpellEffectAmount(dummySpell, 0), 1.0f));
float add_spellpower = (float)(SpellBaseDamageBonus(SPELL_SCHOOL_MASK_FIRE)
- + SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_FIRE, pVictim));
+ + SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_FIRE, victim));
// 1.3speed = 5%, 2.6speed = 10%, 4.0 speed = 15%, so, 1.0speed = 3.84%
ApplyPctF(add_spellpower, 3.84f);
@@ -7443,7 +7435,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
else
return false;
- CastCustomSpell(pVictim, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
+ CastCustomSpell(victim, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
return true;
}
// Improved Water Shield
@@ -7474,7 +7466,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Lightning Overload
if (dummySpell->SpellIconID == 2018) // only this spell have SpellFamily Shaman SpellIconID == 2018 and dummy aura
{
- if (!procSpell || GetTypeId() != TYPEID_PLAYER || !pVictim)
+ if (!procSpell || GetTypeId() != TYPEID_PLAYER || !victim)
return false;
// custom cooldown processing case
@@ -7528,7 +7520,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
ToPlayer()->RemoveSpellCooldown(spellId);
}
- CastSpell(pVictim, spellId, true, castItem, triggeredByAura);
+ CastSpell(victim, spellId, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER)
ToPlayer()->AddSpellCooldown(dummySpell->Id, 0, time(NULL) + cooldown);
@@ -7623,7 +7615,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
AddPctN(basepoints0, glyph->GetAmount());
triggered_spell_id = 50536;
- basepoints0 += pVictim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
+ basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
break;
}
// Vendetta
@@ -7701,7 +7693,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
if (dummySpell->Id == 61257)
{
// only for spells and hit/crit (trigger start always) and not start from self casted spells
- if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == pVictim)
+ if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == victim)
return false;
// Need snare or root mechanic
if (!(GetAllSpellMechanicMask(procSpell) & ((1<<MECHANIC_ROOT)|(1<<MECHANIC_SNARE))))
@@ -7713,7 +7705,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Wandering Plague
if (dummySpell->SpellIconID == 1614)
{
- if (!roll_chance_f(GetUnitCriticalChance(BASE_ATTACK, pVictim)))
+ if (!roll_chance_f(GetUnitCriticalChance(BASE_ATTACK, victim)))
return false;
basepoints0 = CalculatePctN(int32(damage), triggerAmount);
triggered_spell_id = 50526;
@@ -7758,10 +7750,9 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
// Item - Death Knight T10 Melee 4P Bonus
if (dummySpell->Id == 70656)
{
- if (GetTypeId() != TYPEID_PLAYER)
- return false;
-
Player* player = ToPlayer();
+ if (!player)
+ return false;
for (uint32 i = 0; i < MAX_RUNES; ++i)
if (player->GetRuneCooldown(i) == 0)
@@ -7807,7 +7798,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
triggered_spell_id = 54445;
target = this;
float addThreat = float(CalculatePctN(SpellMgr::CalculateSpellEffectAmount(procSpell, 0, this), triggerAmount));
- pVictim->AddThreat(this, addThreat);
+ victim->AddThreat(this, addThreat);
break;
}
// Silverback
@@ -7857,7 +7848,7 @@ bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, AuraEffect* trigger
return true;
}
-bool Unit::HandleObsModEnergyAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
+bool Unit::HandleObsModEnergyAuraProc(Unit* victim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const* dummySpell = triggeredByAura->GetSpellProto();
//uint32 effIndex = triggeredByAura->GetEffIndex();
@@ -7867,7 +7858,7 @@ bool Unit::HandleObsModEnergyAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffe
? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
uint32 triggered_spell_id = 0;
- Unit* target = pVictim;
+ Unit* target = victim;
int32 basepoints0 = 0;
switch(dummySpell->SpellFamilyName)
@@ -7914,7 +7905,7 @@ bool Unit::HandleObsModEnergyAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffe
ToPlayer()->AddSpellCooldown(triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
-bool Unit::HandleModDamagePctTakenAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
+bool Unit::HandleModDamagePctTakenAuraProc(Unit* victim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* /*procSpell*/, uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const* dummySpell = triggeredByAura->GetSpellProto();
//uint32 effIndex = triggeredByAura->GetEffIndex();
@@ -7924,7 +7915,7 @@ bool Unit::HandleModDamagePctTakenAuraProc(Unit *pVictim, uint32 /*damage*/, Aur
? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
uint32 triggered_spell_id = 0;
- Unit* target = pVictim;
+ Unit* target = victim;
int32 basepoints0 = 0;
switch(dummySpell->SpellFamilyName)
@@ -7976,7 +7967,7 @@ bool Unit::HandleModDamagePctTakenAuraProc(Unit *pVictim, uint32 /*damage*/, Aur
// Used in case when access to whole aura is needed
// All procs should be handled like this...
-bool Unit::HandleAuraProc(Unit* pVictim, uint32 damage, Aura * triggeredByAura, SpellEntry const* procSpell, uint32 /*procFlag*/, uint32 procEx, uint32 cooldown, bool * handled)
+bool Unit::HandleAuraProc(Unit* victim, uint32 damage, Aura* triggeredByAura, SpellEntry const* procSpell, uint32 /*procFlag*/, uint32 procEx, uint32 cooldown, bool * handled)
{
SpellEntry const* dummySpell = triggeredByAura->GetSpellProto();
@@ -8024,13 +8015,13 @@ bool Unit::HandleAuraProc(Unit* pVictim, uint32 damage, Aura * triggeredByAura,
if (procSpell->SpellFamilyFlags[0] & 0x40000000 && procSpell->SpellIconID == 242)
{
*handled = true;
- if (pVictim->HasAura(53601))
+ if (victim->HasAura(53601))
{
int32 bp0 = CalculatePctN(int32(damage / 12), SpellMgr::CalculateSpellEffectAmount(dummySpell, 2));
// Item - Paladin T9 Holy 4P Bonus
if (AuraEffect const* aurEff = GetAuraEffect(67191, 0))
AddPctN(bp0, aurEff->GetAmount());
- CastCustomSpell(pVictim, 66922, &bp0, NULL, NULL, true);
+ CastCustomSpell(victim, 66922, &bp0, NULL, NULL, true);
return true;
}
}
@@ -8045,7 +8036,7 @@ bool Unit::HandleAuraProc(Unit* pVictim, uint32 damage, Aura * triggeredByAura,
*handled = true;
if (procSpell->Category == SPELLCATEGORY_JUDGEMENT)
{
- CastSpell(pVictim, 68055, true);
+ CastSpell(victim, 68055, true);
return true;
}
}
@@ -8054,7 +8045,7 @@ bool Unit::HandleAuraProc(Unit* pVictim, uint32 damage, Aura * triggeredByAura,
{
*handled = true;
// Check if we are the target and prevent mana gain
- if (triggeredByAura->GetCasterGUID() == pVictim->GetGUID())
+ if (triggeredByAura->GetCasterGUID() == victim->GetGUID())
return false;
// Lookup base amount mana restore
for (uint8 i = 0; i<MAX_SPELL_EFFECTS; i++)
@@ -8204,7 +8195,7 @@ bool Unit::HandleAuraProc(Unit* pVictim, uint32 damage, Aura * triggeredByAura,
return false;
}
-bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const *procSpell, uint32 procFlags, uint32 procEx, uint32 cooldown)
+bool Unit::HandleProcTriggerSpell(Unit* victim, uint32 damage, AuraEffect* triggeredByAura, SpellEntry const* procSpell, uint32 procFlags, uint32 procEx, uint32 cooldown)
{
// Get triggered aura spell info
SpellEntry const* auraSpellInfo = triggeredByAura->GetSpellProto();
@@ -8240,8 +8231,8 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
break;
case 43820: // Charm of the Witch Doctor (Amani Charm of the Witch Doctor trinket)
// Pct value stored in dummy
- basepoints0 = pVictim->GetCreateHealth() * SpellMgr::CalculateSpellEffectAmount(auraSpellInfo, 1) / 100;
- target = pVictim;
+ basepoints0 = victim->GetCreateHealth() * SpellMgr::CalculateSpellEffectAmount(auraSpellInfo, 1) / 100;
+ target = victim;
break;
case 57345: // Darkmoon Card: Greatness
{
@@ -8290,8 +8281,8 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// On successful melee or ranged attack gain $29471s1 mana and if possible drain $27526s1 mana from the target.
if (this && isAlive())
CastSpell(this, 29471, true, castItem, triggeredByAura);
- if (pVictim && pVictim->isAlive())
- CastSpell(pVictim, 27526, true, castItem, triggeredByAura);
+ if (victim && victim->isAlive())
+ CastSpell(victim, 27526, true, castItem, triggeredByAura);
return true;
}
}
@@ -8444,7 +8435,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
return false;
basepoints0 = CalculatePctN(int32(damage), triggerAmount) / (GetSpellMaxDuration(TriggerPS) / TriggerPS->EffectAmplitude[0]);
- basepoints0 += pVictim->GetRemainingPeriodicAmount(GetGUID(), trigger_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
+ basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), trigger_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
break;
}
break;
@@ -8470,7 +8461,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// Lightning Capacitor
case 37657:
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
// stacking
CastSpell(this, 37658, true, NULL, triggeredByAura);
@@ -8482,13 +8473,13 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
RemoveAurasDueToSpell(37658);
trigger_spell_id = 37661;
- target = pVictim;
+ target = victim;
break;
}
// Thunder Capacitor
case 54841:
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
// stacking
CastSpell(this, 54842, true, NULL, triggeredByAura);
@@ -8501,13 +8492,13 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
RemoveAurasDueToSpell(54842);
trigger_spell_id = 54843;
- target = pVictim;
+ target = victim;
break;
}
//Item - Coliseum 25 Normal Caster Trinket
case 67712:
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
// stacking
CastSpell(this, 67713, true, NULL, triggeredByAura);
@@ -8519,13 +8510,13 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
RemoveAurasDueToSpell(67713);
trigger_spell_id = 67714;
- target = pVictim;
+ target = victim;
break;
}
//Item - Coliseum 25 Heroic Caster Trinket
case 67758:
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
// stacking
CastSpell(this, 67759, true, NULL, triggeredByAura);
@@ -8537,7 +8528,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
RemoveAurasDueToSpell(67759);
trigger_spell_id = 67760;
- target = pVictim;
+ target = victim;
break;
}
default:
@@ -8589,7 +8580,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 23551:
{
trigger_spell_id = 23552;
- target = pVictim;
+ target = victim;
break;
}
// Damage from Lightning Shield (The Ten Storms set)
@@ -8622,8 +8613,8 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
if (!HealthBelowPctDamaged(30, damage))
return false;
- if (pVictim && pVictim->isAlive())
- pVictim->getThreatManager().modifyThreatPercent(this, -10);
+ if (victim && victim->isAlive())
+ victim->getThreatManager().modifyThreatPercent(this, -10);
basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
trigger_spell_id = 31616;
@@ -8692,14 +8683,14 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 26467:
{
basepoints0 = int32(CalculatePctN(damage, 15));
- target = pVictim;
+ target = victim;
trigger_spell_id = 26470;
break;
}
// Unyielding Knights (item exploit 29108\29109)
case 38164:
{
- if (!pVictim || pVictim->GetEntry() != 19457) // Proc only if your target is Grillok
+ if (!victim || victim->GetEntry() != 19457) // Proc only if your target is Grillok
return false;
break;
}
@@ -8723,7 +8714,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 31255:
{
// whenever you deal damage to a target who is below 20% health.
- if (!pVictim || !pVictim->isAlive() || pVictim->HealthAbovePct(20))
+ if (!victim || !victim->isAlive() || victim->HealthAbovePct(20))
return false;
target = this;
@@ -8732,14 +8723,14 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// Greater Heal Refund (Avatar Raiment set)
case 37594:
{
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
// Not give if target already have full health
- if (pVictim->IsFullHealth())
+ if (victim->IsFullHealth())
return false;
// If your Greater Heal brings the target to full health, you gain $37595s1 mana.
- if (pVictim->GetHealth() + damage < pVictim->GetMaxHealth())
+ if (victim->GetHealth() + damage < victim->GetMaxHealth())
return false;
break;
}
@@ -8747,7 +8738,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 40971:
{
// If your target is below $s1% health
- if (!pVictim || !pVictim->isAlive() || pVictim->HealthAbovePct(triggerAmount))
+ if (!victim || !victim->isAlive() || victim->HealthAbovePct(triggerAmount))
return false;
break;
}
@@ -8764,7 +8755,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 63156:
case 63158:
// Can proc only if target has hp below 35%
- if (!pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, procSpell, this))
+ if (!victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, procSpell, this))
return false;
break;
// Deathbringer Saurfang - Rune of Blood
@@ -8772,7 +8763,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// can proc only if target is marked with rune
// this should be handled by targetAuraSpell, but because 72408 is not passive
// one failed proc will remove the entire aura
- if (!pVictim->HasAura(72410))
+ if (!victim->HasAura(72410))
return false;
break;
// Deathbringer Saurfang - Blood Beast's Blood Link
@@ -8792,13 +8783,13 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
if ((procSpell->Id != 58381) || !roll_chance_i(50))
return false;
- target = pVictim;
+ target = victim;
break;
}
// Professor Putricide - Ooze Spell Tank Protection
case 71770:
- if (pVictim)
- pVictim->CastSpell(pVictim, trigger_spell_id, true); // EffectImplicitTarget is self
+ if (victim)
+ victim->CastSpell(victim, trigger_spell_id, true); // EffectImplicitTarget is self
return true;
case 45057: // Evasive Maneuvers (Commendation of Kael`thas trinket)
case 71634: // Item - Icecrown 25 Normal Tank Trinket 1
@@ -8826,7 +8817,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// this required for attacks like Mortal Strike
plr->RemoveSpellCooldown(procSpell->Id);
- CastSpell(pVictim, procSpell->Id, true);
+ CastSpell(victim, procSpell->Id, true);
if (cooldown)
plr->AddSpellCooldown(16459, 0, time(NULL) + cooldown);
@@ -8886,14 +8877,14 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 29494: // Temptation
case 20233: // Improved Lay on Hands (cast on target)
{
- target = pVictim;
+ target = victim;
break;
}
// Combo points add triggers (need add combopoint only for main target, and after possible combopoints reset)
case 15250: // Rogue Setup
{
// applied only for main target
- if (!pVictim || (GetTypeId() == TYPEID_PLAYER && pVictim != ToPlayer()->GetSelectedUnit()))
+ if (!victim || (GetTypeId() == TYPEID_PLAYER && victim != ToPlayer()->GetSelectedUnit()))
return false;
break; // continue normal case
}
@@ -8901,7 +8892,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
case 14189: // Seal Fate (Netherblade set)
case 14157: // Ruthlessness
{
- if (!pVictim || pVictim == this)
+ if (!victim || victim == this)
return false;
// Need add combopoint AFTER finish movie (or they dropped in finish phase)
break;
@@ -8976,7 +8967,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// Astral Shift
case 52179:
{
- if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == pVictim)
+ if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == victim)
return false;
// Need stun, fear or silence mechanic
@@ -9053,26 +9044,26 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
Player* player = ToPlayer();
if (player->GetQuestStatus(24749) == QUEST_STATUS_INCOMPLETE) // Unholy Infusion
{
- if (!player->HasAura(71516) || pVictim->GetEntry() != 36678) // Shadow Infusion && Professor Putricide
+ if (!player->HasAura(71516) || victim->GetEntry() != 36678) // Shadow Infusion && Professor Putricide
return false;
}
else if (player->GetQuestStatus(24756) == QUEST_STATUS_INCOMPLETE) // Blood Infusion
{
- if (!player->HasAura(72154) || pVictim->GetEntry() != 37955) // Thirst Quenched && Blood-Queen Lana'thel
+ if (!player->HasAura(72154) || victim->GetEntry() != 37955) // Thirst Quenched && Blood-Queen Lana'thel
return false;
}
else if (player->GetQuestStatus(24757) == QUEST_STATUS_INCOMPLETE) // Frost Infusion
{
- if (!player->HasAura(72290) || pVictim->GetEntry() != 36853) // Frost-Imbued Blade && Sindragosa
+ if (!player->HasAura(72290) || victim->GetEntry() != 36853) // Frost-Imbued Blade && Sindragosa
return false;
}
else if (player->GetQuestStatus(24547) != QUEST_STATUS_INCOMPLETE) // A Feast of Souls
return false;
- if (pVictim->GetTypeId() != TYPEID_UNIT)
+ if (victim->GetTypeId() != TYPEID_UNIT)
return false;
// critters are not allowed
- if (pVictim->GetCreatureType() == CREATURE_TYPE_CRITTER)
+ if (victim->GetCreatureType() == CREATURE_TYPE_CRITTER)
return false;
break;
}
@@ -9083,7 +9074,7 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
// try detect target manually if not set
if (target == NULL)
- target = !(procFlags & (PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS)) && IsPositiveSpell(trigger_spell_id) ? this : pVictim;
+ target = !(procFlags & (PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS)) && IsPositiveSpell(trigger_spell_id) ? this : victim;
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry)) || (target && target != this && !target->isAlive()))
@@ -9100,11 +9091,11 @@ bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, AuraEffect* trig
return true;
}
-bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, uint32 /*damage*/, AuraEffect *triggeredByAura, SpellEntry const *procSpell, uint32 cooldown)
+bool Unit::HandleOverrideClassScriptAuraProc(Unit* victim, uint32 /*damage*/, AuraEffect* triggeredByAura, SpellEntry const* procSpell, uint32 cooldown)
{
int32 scriptId = triggeredByAura->GetMiscValue();
- if (!pVictim || !pVictim->isAlive())
+ if (!victim || !victim->isAlive())
return false;
Item* castItem = triggeredByAura->GetBase()->GetCastItemGUID() && GetTypeId() == TYPEID_PLAYER
@@ -9141,7 +9132,7 @@ bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, uint32 /*damage*/, A
if (!roll_chance_i(50))
return false;
- switch (pVictim->getPowerType())
+ switch (victim->getPowerType())
{
case POWER_MANA: triggered_spell_id = 28722; break;
case POWER_RAGE: triggered_spell_id = 28723; break;
@@ -9163,7 +9154,7 @@ bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, uint32 /*damage*/, A
{
if (!roll_chance_i(triggeredByAura->GetAmount()))
return false;
- switch(pVictim->getPowerType())
+ switch(victim->getPowerType())
{
case POWER_MANA: triggered_spell_id = 48542; break;
case POWER_RAGE: triggered_spell_id = 48541; break;
@@ -9194,7 +9185,7 @@ bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, uint32 /*damage*/, A
if (cooldown && GetTypeId() == TYPEID_PLAYER && ToPlayer()->HasSpellCooldown(triggered_spell_id))
return false;
- CastSpell(pVictim, triggered_spell_id, true, castItem, triggeredByAura);
+ CastSpell(victim, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER)
ToPlayer()->AddSpellCooldown(triggered_spell_id, 0, time(NULL) + cooldown);
@@ -9327,7 +9318,7 @@ bool Unit::IsHostileTo(Unit const* unit) const
if (pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP) && pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
return true;
- //= PvP states
+ // = PvP states
// Green/Blue (can't attack)
if (!pTester->HasAuraType(SPELL_AURA_MOD_FACTION) && !pTarget->HasAuraType(SPELL_AURA_MOD_FACTION))
{
@@ -9442,7 +9433,7 @@ bool Unit::IsFriendlyTo(Unit const* unit) const
if (pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP) && pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
return false;
- //= PvP states
+ // = PvP states
// Green/Blue (non-attackable)
if (!pTester->HasAuraType(SPELL_AURA_MOD_FACTION) && !pTarget->HasAuraType(SPELL_AURA_MOD_FACTION))
{
@@ -9685,7 +9676,7 @@ bool Unit::isAttackingPlayer() const
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
if (m_SummonSlot[i])
- if (Creature *summon = GetMap()->GetCreature(m_SummonSlot[i]))
+ if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
if (summon->isAttackingPlayer())
return true;
@@ -9774,7 +9765,7 @@ uint32 Unit::BuildAuraStateUpdateForTarget(Unit* target) const
return auraStates;
}
-bool Unit::HasAuraState(AuraState flag, SpellEntry const *spellProto, Unit const* Caster) const
+bool Unit::HasAuraState(AuraState flag, SpellEntry const* spellProto, Unit const* Caster) const
{
if (Caster)
{
@@ -9799,7 +9790,7 @@ bool Unit::HasAuraState(AuraState flag, SpellEntry const *spellProto, Unit const
return HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
}
-Unit *Unit::GetOwner() const
+Unit* Unit::GetOwner() const
{
if (uint64 ownerid = GetOwnerGUID())
{
@@ -9808,7 +9799,7 @@ Unit *Unit::GetOwner() const
return NULL;
}
-Unit *Unit::GetCharmer() const
+Unit* Unit::GetCharmer() const
{
if (uint64 charmerid = GetCharmerGUID())
return ObjectAccessor::GetUnit(*this, charmerid);
@@ -9989,7 +9980,7 @@ void Unit::SetMinion(Minion *minion, bool apply)
{
if (RemoveUInt64Value(UNIT_FIELD_SUMMON, minion->GetGUID()))
{
- //Check if there is another minion
+ // Check if there is another minion
for (ControlList::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
{
// do not use this check, creature do not have charm guid
@@ -10119,46 +10110,46 @@ void Unit::SetCharm(Unit* charm, bool apply)
}
}
-int32 Unit::DealHeal(Unit *pVictim, uint32 addhealth)
+int32 Unit::DealHeal(Unit* victim, uint32 addhealth)
{
int32 gain = 0;
- if (pVictim->IsAIEnabled)
- pVictim->GetAI()->HealReceived(this, addhealth);
+ if (victim->IsAIEnabled)
+ victim->GetAI()->HealReceived(this, addhealth);
if (IsAIEnabled)
- GetAI()->HealDone(pVictim, addhealth);
+ GetAI()->HealDone(victim, addhealth);
if (addhealth)
- gain = pVictim->ModifyHealth(int32(addhealth));
+ gain = victim->ModifyHealth(int32(addhealth));
Unit* unit = this;
if (GetTypeId() == TYPEID_UNIT && ToCreature()->isTotem())
unit = GetOwner();
- if (unit->GetTypeId() == TYPEID_PLAYER)
+ if (Player* player = unit->ToPlayer())
{
- if (Battleground *bg = unit->ToPlayer()->GetBattleground())
- bg->UpdatePlayerScore((Player*)unit, SCORE_HEALING_DONE, gain);
+ if (Battleground* bg = player->GetBattleground())
+ bg->UpdatePlayerScore(player, SCORE_HEALING_DONE, gain);
// use the actual gain, as the overheal shall not be counted, skip gain 0 (it ignored anyway in to criteria)
if (gain)
- unit->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE, gain, 0, pVictim);
+ player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE, gain, 0, victim);
- unit->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED, addhealth);
+ player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED, addhealth);
}
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
+ if (Player* player = victim->ToPlayer())
{
- pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED, gain);
- pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED, addhealth);
+ player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED, gain);
+ player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED, addhealth);
}
return gain;
}
-Unit* Unit::SelectMagnetTarget(Unit* victim, SpellEntry const *spellInfo)
+Unit* Unit::SelectMagnetTarget(Unit* victim, SpellEntry const* spellInfo)
{
if (!victim)
return NULL;
@@ -10328,17 +10319,17 @@ void Unit::UnsummonAllTotems()
if (!m_SummonSlot[i])
continue;
- if (Creature *OldTotem = GetMap()->GetCreature(m_SummonSlot[i]))
+ if (Creature* OldTotem = GetMap()->GetCreature(m_SummonSlot[i]))
if (OldTotem->isSummon())
OldTotem->ToTempSummon()->UnSummon();
}
}
-void Unit::SendHealSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, uint32 OverHeal, uint32 Absorb, bool critical)
+void Unit::SendHealSpellLog(Unit* victim, uint32 SpellID, uint32 Damage, uint32 OverHeal, uint32 Absorb, bool critical)
{
// we guess size
WorldPacket data(SMSG_SPELLHEALLOG, (8+8+4+4+4+4+1+1));
- data.append(pVictim->GetPackGUID());
+ data.append(victim->GetPackGUID());
data.append(GetPackGUID());
data << uint32(SpellID);
data << uint32(Damage);
@@ -10349,21 +10340,21 @@ void Unit::SendHealSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, uint32
SendMessageToSet(&data, true);
}
-int32 Unit::HealBySpell(Unit* pVictim, SpellEntry const* spellInfo, uint32 addHealth, bool critical)
+int32 Unit::HealBySpell(Unit* victim, SpellEntry const* spellInfo, uint32 addHealth, bool critical)
{
uint32 absorb = 0;
// calculate heal absorb and reduce healing
- CalcHealAbsorb(pVictim, spellInfo, addHealth, absorb);
+ CalcHealAbsorb(victim, spellInfo, addHealth, absorb);
- int32 gain = DealHeal(pVictim, addHealth);
- SendHealSpellLog(pVictim, spellInfo->Id, addHealth, uint32(addHealth - gain), absorb, critical);
+ int32 gain = DealHeal(victim, addHealth);
+ SendHealSpellLog(victim, spellInfo->Id, addHealth, uint32(addHealth - gain), absorb, critical);
return gain;
}
-void Unit::SendEnergizeSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, Powers powertype)
+void Unit::SendEnergizeSpellLog(Unit* victim, uint32 SpellID, uint32 Damage, Powers powertype)
{
WorldPacket data(SMSG_SPELLENERGIZELOG, (8+8+4+4+4+1));
- data.append(pVictim->GetPackGUID());
+ data.append(victim->GetPackGUID());
data.append(GetPackGUID());
data << uint32(SpellID);
data << uint32(powertype);
@@ -10371,22 +10362,22 @@ void Unit::SendEnergizeSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, Po
SendMessageToSet(&data, true);
}
-void Unit::EnergizeBySpell(Unit *pVictim, uint32 SpellID, uint32 Damage, Powers powertype)
+void Unit::EnergizeBySpell(Unit* victim, uint32 SpellID, uint32 Damage, Powers powertype)
{
- SendEnergizeSpellLog(pVictim, SpellID, Damage, powertype);
+ SendEnergizeSpellLog(victim, SpellID, Damage, powertype);
// needs to be called after sending spell log
- pVictim->ModifyPower(powertype, Damage);
+ victim->ModifyPower(powertype, Damage);
}
-uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint32 pdamage, DamageEffectType damagetype, uint32 stack)
+uint32 Unit::SpellDamageBonus(Unit* victim, SpellEntry const* spellProto, uint32 pdamage, DamageEffectType damagetype, uint32 stack)
{
- if (!spellProto || !pVictim || damagetype == DIRECT_DAMAGE)
+ if (!spellProto || !victim || damagetype == DIRECT_DAMAGE)
return pdamage;
// For totems get damage bonus from owner
if (GetTypeId() == TYPEID_UNIT && ToCreature()->isTotem())
if (Unit* owner = GetOwner())
- return owner->SpellDamageBonus(pVictim, spellProto, pdamage, damagetype);
+ return owner->SpellDamageBonus(victim, spellProto, pdamage, damagetype);
// Taken/Done total percent damage auras
float DoneTotalMod = 1.0f;
@@ -10399,29 +10390,24 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
if (GetTypeId() == TYPEID_UNIT && !ToCreature()->isPet())
DoneTotalMod *= ToCreature()->GetSpellDamageMod(ToCreature()->GetCreatureInfo()->rank);
- if (spellProto)
- {
- AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
- for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
- if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
+ AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
+ for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
+ if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
+ {
+ if ((*i)->GetSpellProto()->EquippedItemClass == -1)
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
+ else if (!((*i)->GetSpellProto()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK))
{
- if ((*i)->GetSpellProto()->EquippedItemClass == -1)
- {
- AddPctN(DoneTotalMod, (*i)->GetAmount());
- }
- else if (!((*i)->GetSpellProto()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK))
- {
- if ((*i)->GetSpellProto()->EquippedItemClass & spellProto->EquippedItemClass)
- if (((*i)->GetSpellProto()->EquippedItemSubClassMask == 0) ||
- ((*i)->GetSpellProto()->EquippedItemSubClassMask & spellProto->EquippedItemSubClassMask))
- AddPctN(DoneTotalMod, (*i)->GetAmount());
- }
- else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
- AddPctN(DoneTotalMod, (*i)->GetAmount());
+ if ((*i)->GetSpellProto()->EquippedItemClass & spellProto->EquippedItemClass)
+ if (((*i)->GetSpellProto()->EquippedItemSubClassMask == 0) ||
+ ((*i)->GetSpellProto()->EquippedItemSubClassMask & spellProto->EquippedItemSubClassMask))
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
}
- }
+ else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
+ }
- uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 creatureTypeMask = victim->GetCreatureTypeMask();
// Add flat bonus from spell damage versus
DoneTotal += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS, creatureTypeMask);
AuraEffectList const& mDamageDoneVersus = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
@@ -10432,7 +10418,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// bonus against aurastate
AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
- if (pVictim->HasAuraState(AuraState((*i)->GetMiscValue())))
+ if (victim->HasAuraState(AuraState((*i)->GetMiscValue())))
AddPctN(DoneTotalMod, (*i)->GetAmount());
// done scripted mod (take it from owner)
@@ -10451,7 +10437,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
case 6926:
case 6928:
{
- if (pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
+ if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -10465,7 +10451,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
int32 stepPercent = CalculateSpellDamage(this, (*i)->GetSpellProto(), 0);
// count affliction effects and calc additional damage in percentage
int32 modPercent = 0;
- AuraApplicationMap const& victimAuras = pVictim->GetAppliedAuras();
+ AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
{
Aura const* aura = itr->second->GetBase();
@@ -10490,7 +10476,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
break;
case 5481: // Starfire Bonus
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x200002, 0, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x200002, 0, 0))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -10513,14 +10499,14 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Merciless Combat
if ((*i)->GetSpellProto()->SpellIconID == 2656)
{
- if (!pVictim->HealthAbovePct(35))
+ if (!victim->HealthAbovePct(35))
AddPctN(DoneTotalMod, (*i)->GetAmount());
}
// Tundra Stalker
else
{
// Frost Fever (target debuff)
- if (pVictim->HasAura(55095))
+ if (victim->HasAura(55095))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -10529,7 +10515,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Rage of Rivendare
case 7293:
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
{
if (SpellChainNode const* chain = sSpellMgr->GetSpellChainNode((*i)->GetId()))
AddPctF(DoneTotalMod, chain->rank * 2.0f);
@@ -10539,7 +10525,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Twisted Faith
case 7377:
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -10550,7 +10536,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
case 7601:
case 7602:
{
- if (pVictim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -10564,10 +10550,10 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Ice Lance
if (spellProto->SpellIconID == 186)
{
- if (pVictim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
+ if (victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
{
// Glyph of Ice Lance
- if (owner->HasAura(56377) && pVictim->getLevel() > owner->getLevel())
+ if (owner->HasAura(56377) && victim->getLevel() > owner->getLevel())
DoneTotalMod *= 4.0f;
else
DoneTotalMod *= 3.0f;
@@ -10576,7 +10562,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Torment the weak
if (spellProto->SpellFamilyFlags[0] & 0x20600021 || spellProto->SpellFamilyFlags[1] & 0x9000)
- if (pVictim->HasAuraWithMechanic((1<<MECHANIC_SNARE)|(1<<MECHANIC_SLOW_ATTACK)))
+ if (victim->HasAuraWithMechanic((1<<MECHANIC_SNARE)|(1<<MECHANIC_SLOW_ATTACK)))
{
AuraEffectList const& mDumyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDumyAuras.begin(); i != mDumyAuras.end(); ++i)
@@ -10594,13 +10580,13 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Glyph of Shadow Word: Pain
if (AuraEffect* aurEff = GetAuraEffect(55687, 0))
// Increase Mind Flay damage if Shadow Word: Pain present on target
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
AddPctN(DoneTotalMod, aurEff->GetAmount());
// Twisted Faith - Mind Flay part
if (AuraEffect* aurEff = GetAuraEffect(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELLFAMILY_PRIEST, 2848, 1))
// Increase Mind Flay damage if Shadow Word: Pain present on target
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
AddPctN(DoneTotalMod, aurEff->GetAmount());
}
// Smite
@@ -10608,7 +10594,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
{
// Glyph of Smite
if (AuraEffect* aurEff = GetAuraEffect(55692, 0))
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x100000, 0, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x100000, 0, 0, GetGUID()))
AddPctN(DoneTotalMod, aurEff->GetAmount());
}
break;
@@ -10618,7 +10604,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
{
// Get stack of Holy Vengeance/Blood Corruption on the target added by caster
uint32 stacks = 0;
- Unit::AuraEffectList const& auras = pVictim->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
+ Unit::AuraEffectList const& auras = victim->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
if (((*itr)->GetId() == 31803 || (*itr)->GetId() == 53742) && (*itr)->GetCasterGUID() == GetGUID())
{
@@ -10642,7 +10628,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
case SPELLFAMILY_WARLOCK:
// Fire and Brimstone
if (spellProto->SpellFamilyFlags[1] & 0x00020040)
- if (pVictim->HasAuraState(AURA_STATE_CONFLAGRATE))
+ if (victim->HasAuraState(AURA_STATE_CONFLAGRATE))
{
AuraEffectList const& mDumyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDumyAuras.begin(); i != mDumyAuras.end(); ++i)
@@ -10658,14 +10644,14 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
DoneTotalMod *= 4;
// Shadow Bite (15% increase from each dot)
if (spellProto->SpellFamilyFlags[1] & 0x00400000 && isPet())
- if (uint8 count = pVictim->GetDoTsByCaster(GetOwnerGUID()))
+ if (uint8 count = victim->GetDoTsByCaster(GetOwnerGUID()))
AddPctN(DoneTotalMod, 15 * count);
break;
case SPELLFAMILY_HUNTER:
// Steady Shot
if (spellProto->SpellFamilyFlags[1] & 0x1)
if (AuraEffect* aurEff = GetAuraEffect(56826, 0)) // Glyph of Steady Shot
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_HUNTER, 0x00004000, 0, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_HUNTER, 0x00004000, 0, 0, GetGUID()))
AddPctN(DoneTotalMod, aurEff->GetAmount());
break;
case SPELLFAMILY_DEATHKNIGHT:
@@ -10682,7 +10668,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Glacier Rot
if (spellProto->SpellFamilyFlags[0] & 0x2 || spellProto->SpellFamilyFlags[1] & 0x6)
if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0))
- if (pVictim->GetDiseasesByCaster(owner->GetGUID()) > 0)
+ if (victim->GetDiseasesByCaster(owner->GetGUID()) > 0)
AddPctN(DoneTotalMod, aurEff->GetAmount());
// Impurity (dummy effect)
@@ -10714,7 +10700,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// ..taken
int32 maxPositiveMod = 0; // max of the positive amount aura (that increase the damage taken)
int32 sumNegativeMod = 0; // sum the negative amount aura (that reduce the damage taken)
- AuraEffectList const& mModDamagePercentTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
+ AuraEffectList const& mModDamagePercentTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
for (AuraEffectList::const_iterator i = mModDamagePercentTaken.begin(); i != mModDamagePercentTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
{
@@ -10728,7 +10714,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
}
// .. taken pct: dummy auras
- AuraEffectList const& mDummyAuras = pVictim->GetAuraEffectsByType(SPELL_AURA_DUMMY);
+ AuraEffectList const& mDummyAuras = victim->GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
{
switch((*i)->GetSpellProto()->SpellIconID)
@@ -10737,9 +10723,9 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
case 2109:
if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
{
- if (pVictim->GetTypeId() != TYPEID_PLAYER)
+ if (victim->GetTypeId() != TYPEID_PLAYER)
continue;
- float mod = pVictim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE) * (-8.0f);
+ float mod = victim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE) * (-8.0f);
if (mod < (*i)->GetAmount())
mod = (float)(*i)->GetAmount();
sumNegativeMod += int32(mod);
@@ -10757,7 +10743,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
}
// From caster spells
- AuraEffectList const& mOwnerTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
+ AuraEffectList const& mOwnerTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
if ((*i)->GetCasterGUID() == GetGUID() && (*i)->IsAffectedOnSpell(spellProto))
sumNegativeMod += (*i)->GetAmount();
@@ -10765,7 +10751,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Mod damage from spell mechanic
if (uint32 mechanicMask = GetAllSpellMechanicMask(spellProto))
{
- AuraEffectList const& mDamageDoneMechanic = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
+ AuraEffectList const& mDamageDoneMechanic = victim->GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin(); i != mDamageDoneMechanic.end(); ++i)
if (mechanicMask & uint32(1<<((*i)->GetMiscValue())))
sumNegativeMod += (*i)->GetAmount();
@@ -10775,7 +10761,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
// Taken/Done fixed damage bonus auras
int32 DoneAdvertisedBenefit = SpellBaseDamageBonus(GetSpellSchoolMask(spellProto));
- int32 TakenAdvertisedBenefit = SpellBaseDamageBonusForVictim(GetSpellSchoolMask(spellProto), pVictim);
+ int32 TakenAdvertisedBenefit = SpellBaseDamageBonusForVictim(GetSpellSchoolMask(spellProto), victim);
// Pets just add their bonus damage to their spell damage
// note that their spell damage is just gain of their own auras
if (HasUnitTypeMask(UNIT_MASK_GUARDIAN))
@@ -10792,7 +10778,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
if (bonus->ap_dot_bonus > 0)
{
WeaponAttackType attType = (IsRangedWeaponSpell(spellProto) && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK;
- float APbonus = (float) pVictim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
+ float APbonus = (float) victim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
APbonus += GetTotalAttackPowerValue(attType);
DoneTotal += int32(bonus->ap_dot_bonus * stack * ApCoeffMod * APbonus);
}
@@ -10803,7 +10789,7 @@ uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint3
if (bonus->ap_bonus > 0)
{
WeaponAttackType attType = (IsRangedWeaponSpell(spellProto) && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK;
- float APbonus = (float) pVictim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
+ float APbonus = (float) victim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
APbonus += GetTotalAttackPowerValue(attType);
DoneTotal += int32(bonus->ap_bonus * stack * ApCoeffMod * APbonus);
}
@@ -10937,9 +10923,9 @@ int32 Unit::SpellBaseDamageBonus(SpellSchoolMask schoolMask)
return DoneAdvertisedBenefit > 0 ? DoneAdvertisedBenefit : 0;
}
-int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim)
+int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit* victim)
{
- uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 creatureTypeMask = victim->GetCreatureTypeMask();
int32 TakenAdvertisedBenefit = 0;
// ..done (for creature type by mask) in taken
@@ -10949,7 +10935,7 @@ int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit *pVic
TakenAdvertisedBenefit += (*i)->GetAmount();
// ..taken
- AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
+ AuraEffectList const& mDamageTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
if (((*i)->GetMiscValue() & schoolMask) != 0)
TakenAdvertisedBenefit += (*i)->GetAmount();
@@ -10957,7 +10943,7 @@ int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit *pVic
return TakenAdvertisedBenefit > 0 ? TakenAdvertisedBenefit : 0;
}
-bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType) const
+bool Unit::isSpellCrit(Unit* victim, SpellEntry const* spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType) const
{
// Mobs can't crit with spells.
if (IS_CREATURE_GUID(GetGUID()))
@@ -10986,15 +10972,15 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
}
// taken
- if (pVictim)
+ if (victim)
{
if (!IsPositiveSpell(spellProto->Id))
{
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
- crit_chance += pVictim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
+ crit_chance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
- crit_chance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
- ApplyResilience(pVictim, &crit_chance, NULL, false, CR_CRIT_TAKEN_SPELL);
+ crit_chance += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
+ ApplyResilience(victim, &crit_chance, NULL, false, CR_CRIT_TAKEN_SPELL);
}
// scripted (increase crit chance ... against ... target by x%
AuraEffectList const& mOverrideClassScript = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
@@ -11009,23 +10995,23 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
case 911: modChance+= 16;
case 910: modChance+= 17;
case 849: modChance+= 17;
- if (!pVictim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
+ if (!victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
break;
crit_chance+=modChance;
break;
case 7917: // Glyph of Shadowburn
- if (pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
+ if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
crit_chance+=(*i)->GetAmount();
break;
case 7997: // Renewed Hope
case 7998:
- if (pVictim->HasAura(6788))
+ if (victim->HasAura(6788))
crit_chance+=(*i)->GetAmount();
break;
case 21: // Test of Faith
case 6935:
case 6918:
- if (pVictim->HealthBelowPct(50))
+ if (victim->HealthBelowPct(50))
crit_chance+=(*i)->GetAmount();
break;
default:
@@ -11037,7 +11023,7 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
{
case SPELLFAMILY_DRUID:
// Improved Faerie Fire
- if (pVictim->HasAuraState(AURA_STATE_FAERIE_FIRE))
+ if (victim->HasAuraState(AURA_STATE_FAERIE_FIRE))
if (AuraEffect const* aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 109, 0))
crit_chance += aurEff->GetAmount();
@@ -11048,7 +11034,7 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
{
// Improved Insect Swarm
if (AuraEffect const* aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 1771, 0))
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00000002, 0, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00000002, 0, 0))
crit_chance += aurEff->GetAmount();
break;
}
@@ -11063,14 +11049,14 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
if (spellProto->SpellFamilyFlags[0] & 0x40000000)
{
// Sacred Shield
- if (AuraEffect const* aura = pVictim->GetAuraEffect(58597, 1, GetGUID()))
+ if (AuraEffect const* aura = victim->GetAuraEffect(58597, 1, GetGUID()))
crit_chance += aura->GetAmount();
break;
}
// Exorcism
else if (spellProto->Category == 19)
{
- if (pVictim->GetCreatureTypeMask() & CREATURE_TYPEMASK_DEMON_OR_UNDEAD)
+ if (victim->GetCreatureTypeMask() & CREATURE_TYPEMASK_DEMON_OR_UNDEAD)
return true;
break;
}
@@ -11079,8 +11065,8 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
// Lava Burst
if (spellProto->SpellFamilyFlags[1] & 0x00001000)
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, 0x10000000, 0, 0, GetGUID()))
- if (pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE) > -100)
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, 0x10000000, 0, 0, GetGUID()))
+ if (victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE) > -100)
return true;
break;
}
@@ -11090,7 +11076,7 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
break;
}
case SPELL_DAMAGE_CLASS_MELEE:
- if (pVictim)
+ if (victim)
{
// Custom crit by class
switch(spellProto->SpellFamilyName)
@@ -11099,7 +11085,7 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
// Rend and Tear - bonus crit chance for Ferocious Bite on bleeding targets
if (spellProto->SpellFamilyFlags[0] & 0x00800000
&& spellProto->SpellIconID == 1680
- && pVictim->HasAuraState(AURA_STATE_BLEEDING))
+ && victim->HasAuraState(AURA_STATE_BLEEDING))
{
if (AuraEffect const* rendAndTear = GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 1))
crit_chance += rendAndTear->GetAmount();
@@ -11120,9 +11106,9 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
}
case SPELL_DAMAGE_CLASS_RANGED:
{
- if (pVictim)
+ if (victim)
{
- crit_chance += GetUnitCriticalChance(attackType, pVictim);
+ crit_chance += GetUnitCriticalChance(attackType, victim);
crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
}
break;
@@ -11141,7 +11127,7 @@ bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolM
return false;
}
-uint32 Unit::SpellCriticalDamageBonus(SpellEntry const *spellProto, uint32 damage, Unit *pVictim)
+uint32 Unit::SpellCriticalDamageBonus(SpellEntry const* spellProto, uint32 damage, Unit* victim)
{
// Calculate critical bonus
int32 crit_bonus;
@@ -11161,9 +11147,9 @@ uint32 Unit::SpellCriticalDamageBonus(SpellEntry const *spellProto, uint32 damag
if (Player* modOwner = GetSpellModOwner())
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
- if (pVictim)
+ if (victim)
{
- uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 creatureTypeMask = victim->GetCreatureTypeMask();
crit_bonus = int32(crit_bonus * GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, creatureTypeMask));
}
@@ -11173,7 +11159,7 @@ uint32 Unit::SpellCriticalDamageBonus(SpellEntry const *spellProto, uint32 damag
return damage;
}
-uint32 Unit::SpellCriticalHealingBonus(SpellEntry const *spellProto, uint32 damage, Unit *pVictim)
+uint32 Unit::SpellCriticalHealingBonus(SpellEntry const* spellProto, uint32 damage, Unit* victim)
{
// Calculate critical bonus
int32 crit_bonus;
@@ -11189,9 +11175,9 @@ uint32 Unit::SpellCriticalHealingBonus(SpellEntry const *spellProto, uint32 dama
break;
}
- if (pVictim)
+ if (victim)
{
- uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 creatureTypeMask = victim->GetCreatureTypeMask();
crit_bonus = int32(crit_bonus * GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, creatureTypeMask));
}
@@ -11203,12 +11189,12 @@ uint32 Unit::SpellCriticalHealingBonus(SpellEntry const *spellProto, uint32 dama
return damage;
}
-uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint32 healamount, DamageEffectType damagetype, uint32 stack)
+uint32 Unit::SpellHealingBonus(Unit* victim, SpellEntry const* spellProto, uint32 healamount, DamageEffectType damagetype, uint32 stack)
{
// For totems get healing bonus from owner (statue isn't totem in fact)
if (GetTypeId() == TYPEID_UNIT && ToCreature()->isTotem())
if (Unit* owner = GetOwner())
- return owner->SpellHealingBonus(pVictim, spellProto, healamount, damagetype, stack);
+ return owner->SpellHealingBonus(victim, spellProto, healamount, damagetype, stack);
// no bonus for heal potions/bandages
if (spellProto->SpellFamilyName == SPELLFAMILY_POTION)
@@ -11242,18 +11228,18 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
break;
case 7997: // Renewed Hope
case 7998:
- if (pVictim->HasAura(6788))
+ if (victim->HasAura(6788))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
case 21: // Test of Faith
case 6935:
case 6918:
- if (pVictim->HealthBelowPct(50))
+ if (victim->HealthBelowPct(50))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
case 7798: // Glyph of Regrowth
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, 0x40, 0, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, 0x40, 0, 0))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -11261,7 +11247,7 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
{
int32 stepPercent = (*i)->GetAmount();
int32 modPercent = 0;
- AuraApplicationMap const& victimAuras = pVictim->GetAppliedAuras();
+ AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
{
Aura const* aura = itr->second->GetBase();
@@ -11278,7 +11264,7 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
}
case 7871: // Glyph of Lesser Healing Wave
{
- if (pVictim->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0 , 0x00000400, 0, GetGUID()))
+ if (victim->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0 , 0x00000400, 0, GetGUID()))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -11289,7 +11275,7 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
// Taken/Done fixed damage bonus auras
int32 DoneAdvertisedBenefit = SpellBaseHealingBonus(GetSpellSchoolMask(spellProto));
- int32 TakenAdvertisedBenefit = SpellBaseHealingBonusForVictim(GetSpellSchoolMask(spellProto), pVictim);
+ int32 TakenAdvertisedBenefit = SpellBaseHealingBonusForVictim(GetSpellSchoolMask(spellProto), victim);
bool scripted = false;
@@ -11338,7 +11324,7 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
if (apBonus > DoneAdvertisedBenefit)
DoneTotal += int32(apBonus * 0.22f); // 22% of AP per tick
else
- DoneTotal += int32(DoneAdvertisedBenefit * 0.377f); //37.7% of BH per tick
+ DoneTotal += int32(DoneAdvertisedBenefit * 0.377f); // 37.7% of BH per tick
}
// Earthliving - 0.45% of normal hot coeff
else if (spellProto->SpellFamilyName == SPELLFAMILY_SHAMAN && spellProto->SpellFamilyFlags[1] & 0x80000)
@@ -11427,7 +11413,7 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID && spellProto->SpellFamilyFlags[1] & 0x2000000)
{
// Rejuvenation, Regrowth, Lifebloom, or Wild Growth
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, 0x50, 0x4000010, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, 0x50, 0x4000010, 0))
// increase healing by 20%
TakenTotalMod *= 1.2f;
}
@@ -11435,31 +11421,31 @@ uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto, uint
// Taken mods
// Tenacity increase healing % taken
- if (AuraEffect const* Tenacity = pVictim->GetAuraEffect(58549, 0))
+ if (AuraEffect const* Tenacity = victim->GetAuraEffect(58549, 0))
AddPctN(TakenTotalMod, Tenacity->GetAmount());
// Healing taken percent
- float minval = (float)pVictim->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
+ float minval = (float)victim->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
if (minval)
AddPctF(TakenTotalMod, minval);
- float maxval = (float)pVictim->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
+ float maxval = (float)victim->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
if (maxval)
AddPctF(TakenTotalMod, maxval);
if (damagetype == DOT)
{
// Healing over time taken percent
- float minval_hot = (float)pVictim->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HOT_PCT);
+ float minval_hot = (float)victim->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HOT_PCT);
if (minval_hot)
AddPctF(TakenTotalMod, minval_hot);
- float maxval_hot = (float)pVictim->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HOT_PCT);
+ float maxval_hot = (float)victim->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HOT_PCT);
if (maxval_hot)
AddPctF(TakenTotalMod, maxval_hot);
}
- AuraEffectList const& mHealingGet= pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_RECEIVED);
+ AuraEffectList const& mHealingGet= victim->GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_RECEIVED);
for (AuraEffectList::const_iterator i = mHealingGet.begin(); i != mHealingGet.end(); ++i)
if (GetGUID() == (*i)->GetCasterGUID() && (*i)->IsAffectedOnSpell(spellProto))
AddPctN(TakenTotalMod, (*i)->GetAmount());
@@ -11502,10 +11488,10 @@ int32 Unit::SpellBaseHealingBonus(SpellSchoolMask schoolMask)
return AdvertisedBenefit;
}
-int32 Unit::SpellBaseHealingBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim)
+int32 Unit::SpellBaseHealingBonusForVictim(SpellSchoolMask schoolMask, Unit* victim)
{
int32 AdvertisedBenefit = 0;
- AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_HEALING);
+ AuraEffectList const& mDamageTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_HEALING);
for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
if (((*i)->GetMiscValue() & schoolMask) != 0)
AdvertisedBenefit += (*i)->GetAmount();
@@ -11666,15 +11652,15 @@ bool Unit::IsDamageToThreatSpell(SpellEntry const* spellInfo) const
return false;
}
-void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType attType, SpellEntry const *spellProto)
+void Unit::MeleeDamageBonus(Unit* victim, uint32 *pdamage, WeaponAttackType attType, SpellEntry const* spellProto)
{
- if (!pVictim)
+ if (!victim)
return;
if (*pdamage == 0)
return;
- uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
+ uint32 creatureTypeMask = victim->GetCreatureTypeMask();
// Taken/Done fixed damage bonus auras
int32 DoneFlatBenefit = 0;
@@ -11694,7 +11680,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
if (attType == RANGED_ATTACK)
{
- APbonus += pVictim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
+ APbonus += victim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
// ..done (base at attack power and creature type)
AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS);
@@ -11704,7 +11690,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
}
else
{
- APbonus += pVictim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
+ APbonus += victim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
// ..done (base at attack power and creature type)
AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS);
@@ -11727,15 +11713,17 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
}
// ..taken
- AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
+ AuraEffectList const& mDamageTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetMeleeDamageSchoolMask())
TakenFlatBenefit += (*i)->GetAmount();
if (attType != RANGED_ATTACK)
- TakenFlatBenefit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
+ TakenFlatBenefit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
else
- TakenFlatBenefit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
+ TakenFlatBenefit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
+
+ Player* player = ToPlayer();
// Done/Taken total percent damage auras
float DoneTotalMod = 1.0f;
@@ -11746,24 +11734,22 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
if (spellProto)
{
- if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
+ if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
+ {
+ if ((*i)->GetSpellProto()->EquippedItemClass == -1)
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
+ else if (!((*i)->GetSpellProto()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK))
{
- if ((*i)->GetSpellProto()->EquippedItemClass == -1)
- {
- AddPctN(DoneTotalMod, (*i)->GetAmount());
- }
- else if (!((*i)->GetSpellProto()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK))
- {
- if ((*i)->GetSpellProto()->EquippedItemClass & spellProto->EquippedItemClass)
- if (((*i)->GetSpellProto()->EquippedItemSubClassMask == 0) ||
- ((*i)->GetSpellProto()->EquippedItemSubClassMask & spellProto->EquippedItemSubClassMask))
- AddPctN(DoneTotalMod, (*i)->GetAmount());
- }
- else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
- AddPctN(DoneTotalMod, (*i)->GetAmount());
+ if ((*i)->GetSpellProto()->EquippedItemClass & spellProto->EquippedItemClass)
+ if (((*i)->GetSpellProto()->EquippedItemSubClassMask == 0) ||
+ ((*i)->GetSpellProto()->EquippedItemSubClassMask & spellProto->EquippedItemSubClassMask))
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
+ }
+ else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
+ AddPctN(DoneTotalMod, (*i)->GetAmount());
}
}
- else if (ToPlayer())
+ else if (player)
{
if (!((*i)->GetSpellProto()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK))
{
@@ -11777,12 +11763,12 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
default: return;
}
- Item* item = ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
+ Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
if (item && !item->IsBroken() && item->IsFitToSpellRequirements((*i)->GetSpellProto()))
AddPctN(DoneTotalMod, (*i)->GetAmount());
}
- else if (ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
+ else if (player->HasItemFitToSpellRequirements((*i)->GetSpellProto()))
AddPctN(DoneTotalMod, (*i)->GetAmount());
}
@@ -11794,7 +11780,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
// bonus against aurastate
AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
- if (pVictim->HasAuraState(AuraState((*i)->GetMiscValue())))
+ if (victim->HasAuraState(AuraState((*i)->GetMiscValue())))
AddPctN(DoneTotalMod, (*i)->GetAmount());
// done scripted mod (take it from owner)
@@ -11814,14 +11800,14 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
// Merciless Combat
if ((*i)->GetSpellProto()->SpellIconID == 2656)
{
- if (!pVictim->HealthAbovePct(35))
+ if (!victim->HealthAbovePct(35))
AddPctN(DoneTotalMod, (*i)->GetAmount());
}
// Tundra Stalker
else
{
// Frost Fever (target debuff)
- if (pVictim->HasAura(55095))
+ if (victim->HasAura(55095))
AddPctN(DoneTotalMod, (*i)->GetAmount());
}
break;
@@ -11829,7 +11815,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
// Rage of Rivendare
case 7293:
{
- if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
if (SpellChainNode const* chain = sSpellMgr->GetSpellChainNode((*i)->GetId()))
AddPctF(DoneTotalMod, chain->rank * 2.0f);
break;
@@ -11841,7 +11827,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
case 7601:
case 7602:
{
- if (pVictim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
+ if (victim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
AddPctN(DoneTotalMod, (*i)->GetAmount());
break;
}
@@ -11856,19 +11842,19 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
// Glacier Rot
if (spellProto->SpellFamilyFlags[0] & 0x2 || spellProto->SpellFamilyFlags[1] & 0x6)
if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0))
- if (pVictim->GetDiseasesByCaster(owner->GetGUID()) > 0)
+ if (victim->GetDiseasesByCaster(owner->GetGUID()) > 0)
AddPctN(DoneTotalMod, aurEff->GetAmount());
break;
}
// ..taken
- AuraEffectList const& mModDamagePercentTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
+ AuraEffectList const& mModDamagePercentTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
for (AuraEffectList::const_iterator i = mModDamagePercentTaken.begin(); i != mModDamagePercentTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetMeleeDamageSchoolMask())
AddPctN(TakenTotalMod, (*i)->GetAmount());
// From caster spells
- AuraEffectList const& mOwnerTaken = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
+ AuraEffectList const& mOwnerTaken = victim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
if ((*i)->GetCasterGUID() == GetGUID() && (*i)->IsAffectedOnSpell(spellProto))
AddPctN(TakenTotalMod, (*i)->GetAmount());
@@ -11885,7 +11871,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
if (mechanicMask)
{
- AuraEffectList const& mDamageDoneMechanic = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
+ AuraEffectList const& mDamageDoneMechanic = victim->GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin(); i != mDamageDoneMechanic.end(); ++i)
if (mechanicMask & uint32(1<<((*i)->GetMiscValue())))
AddPctN(TakenTotalMod, (*i)->GetAmount());
@@ -11893,18 +11879,18 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
}
// .. taken pct: dummy auras
- AuraEffectList const& mDummyAuras = pVictim->GetAuraEffectsByType(SPELL_AURA_DUMMY);
+ AuraEffectList const& mDummyAuras = victim->GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
{
switch((*i)->GetSpellProto()->SpellIconID)
{
- //Cheat Death
+ // Cheat Death
case 2109:
if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
{
- if (pVictim->GetTypeId() != TYPEID_PLAYER)
+ if (victim->GetTypeId() != TYPEID_PLAYER)
continue;
- float mod = pVictim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE) * (-8.0f);
+ float mod = victim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE) * (-8.0f);
AddPctF(TakenTotalMod, std::max(mod, float((*i)->GetAmount())));
}
break;
@@ -11935,7 +11921,7 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
switch((*i)->GetMiscValue())
{
case 6427: case 6428: // Dirty Deeds
- if (pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
+ if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
{
AuraEffect* eff0 = (*i)->GetBase()->GetEffect(EFFECT_0);
if (!eff0 || (*i)->GetEffIndex() != 1)
@@ -11953,13 +11939,13 @@ void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage, WeaponAttackType att
if (attType != RANGED_ATTACK)
{
- AuraEffectList const& mModMeleeDamageTakenPercent = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
+ AuraEffectList const& mModMeleeDamageTakenPercent = victim->GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
for (AuraEffectList::const_iterator i = mModMeleeDamageTakenPercent.begin(); i != mModMeleeDamageTakenPercent.end(); ++i)
AddPctN(TakenTotalMod, (*i)->GetAmount());
}
else
{
- AuraEffectList const& mModRangedDamageTakenPercent = pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
+ AuraEffectList const& mModRangedDamageTakenPercent = victim->GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
for (AuraEffectList::const_iterator i = mModRangedDamageTakenPercent.begin(); i != mModRangedDamageTakenPercent.end(); ++i)
AddPctN(TakenTotalMod, (*i)->GetAmount());
}
@@ -12151,7 +12137,7 @@ void Unit::SetInCombatWith(Unit* enemy)
return;
}
- //check for duel
+ // check for duel
if (eOwner->GetTypeId() == TYPEID_PLAYER && eOwner->ToPlayer()->duel)
{
Unit const* myOwner = GetCharmerOrOwnerOrSelf();
@@ -12259,20 +12245,20 @@ void Unit::ClearInCombat()
ClearUnitState(UNIT_STAT_ATTACK_PLAYER);
if (HasFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED))
SetUInt32Value(UNIT_DYNAMIC_FLAGS, creature->GetCreatureInfo()->dynamicflags);
+
+ if (creature->isPet())
+ {
+ if (Unit* owner = GetOwner())
+ for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
+ if (owner->GetSpeedRate(UnitMoveType(i)) > GetSpeedRate(UnitMoveType(i)))
+ SetSpeed(UnitMoveType(i), owner->GetSpeedRate(UnitMoveType(i)), true);
+ }
+ else if (!isCharmed())
+ return;
}
else
ToPlayer()->UpdatePotionCooldown();
- if (GetTypeId() != TYPEID_PLAYER && ToCreature()->isPet())
- {
- if (Unit* owner = GetOwner())
- for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
- if (owner->GetSpeedRate(UnitMoveType(i)) > GetSpeedRate(UnitMoveType(i)))
- SetSpeed(UnitMoveType(i), owner->GetSpeedRate(UnitMoveType(i)), true);
- }
- else if (!isCharmed())
- return;
-
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
}
@@ -12820,11 +12806,11 @@ float Unit::ApplyTotalThreatModifier(float fThreat, SpellSchoolMask schoolMask)
//======================================================================
-void Unit::AddThreat(Unit* pVictim, float fThreat, SpellSchoolMask schoolMask, SpellEntry const *threatSpell)
+void Unit::AddThreat(Unit* victim, float fThreat, SpellSchoolMask schoolMask, SpellEntry const* threatSpell)
{
// Only mobs can manage threat lists
if (CanHaveThreatList())
- m_ThreatManager.addThreat(pVictim, fThreat, schoolMask, threatSpell);
+ m_ThreatManager.addThreat(victim, fThreat, schoolMask, threatSpell);
}
//======================================================================
@@ -12866,7 +12852,7 @@ void Unit::TauntApply(Unit* taunter)
//======================================================================
-void Unit::TauntFadeOut(Unit *taunter)
+void Unit::TauntFadeOut(Unit* taunter)
{
ASSERT(GetTypeId() == TYPEID_UNIT);
@@ -12983,7 +12969,7 @@ Unit* Creature::SelectVictim()
return target;
}
- // last case when creature don't must go to evade mode:
+ // last case when creature must not go to evade mode:
// it in combat but attacker not make any damage and not enter to aggro radius to have record in threat list
// for example at owner command to pet attack some far away creature
// Note: creature not have targeted movement generator but have attacker in this case
@@ -13181,7 +13167,7 @@ void Unit::ModSpellCastTime(SpellEntry const* spellProto, int32 & castTime, Spel
{
if (!spellProto || castTime < 0)
return;
- //called from caster
+ // called from caster
if (Player* modOwner = GetSpellModOwner())
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CASTING_TIME, castTime, spell);
@@ -13233,7 +13219,7 @@ void Unit::IncrDiminishing(DiminishingGroup group)
m_Diminishing.push_back(DiminishingReturn(group, getMSTime(), DIMINISHING_LEVEL_2));
}
-float Unit::ApplyDiminishingToDuration(DiminishingGroup group, int32 &duration, Unit *caster, DiminishingLevels Level, int32 limitduration)
+float Unit::ApplyDiminishingToDuration(DiminishingGroup group, int32 &duration, Unit* caster, DiminishingLevels Level, int32 limitduration)
{
if (duration == -1 || group == DIMINISHING_NONE)
return 1.0f;
@@ -13875,7 +13861,7 @@ CharmInfo::~CharmInfo()
void CharmInfo::RestoreState()
{
if (m_unit->GetTypeId() == TYPEID_UNIT)
- if (Creature *pCreature = m_unit->ToCreature())
+ if (Creature* pCreature = m_unit->ToCreature())
pCreature->SetReactState(m_oldReactState);
}
@@ -13925,7 +13911,7 @@ void CharmInfo::InitPossessCreateSpells()
void CharmInfo::InitCharmCreateSpells()
{
- if (m_unit->GetTypeId() == TYPEID_PLAYER) //charmed players don't have spells
+ if (m_unit->GetTypeId() == TYPEID_PLAYER) // charmed players don't have spells
{
InitEmptyActionBar();
return;
@@ -14308,7 +14294,7 @@ void Unit::ProcDamageAndSpellFor(bool isVictim, Unit* pTarget, uint32 procFlag,
continue;
// Triggered spells not triggering additional spells
- bool triggered= !(spellProto->AttributesEx3 & SPELL_ATTR3_CAN_PROC_TRIGGERED) ?
+ bool triggered = !(spellProto->AttributesEx3 & SPELL_ATTR3_CAN_PROC_TRIGGERED) ?
(procExtra & PROC_EX_INTERNAL_TRIGGERED && !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION)) : false;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
@@ -14869,7 +14855,7 @@ void Unit::UpdateReactives(uint32 p_time)
Unit* Unit::SelectNearbyTarget(float dist) const
{
- std::list<Unit *> targets;
+ std::list<Unit*> targets;
Trinity::AnyUnfriendlyUnitInObjectRangeCheck u_check(this, this, dist);
Trinity::UnitListSearcher<Trinity::AnyUnfriendlyUnitInObjectRangeCheck> searcher(this, targets, u_check);
VisitNearbyObject(dist, searcher);
@@ -14921,7 +14907,7 @@ void Unit::ApplyCastTimePercentMod(float val, bool apply)
ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, -val, apply);
}
-uint32 Unit::GetCastingTimeForBonus(SpellEntry const *spellProto, DamageEffectType damagetype, uint32 CastingTime)
+uint32 Unit::GetCastingTimeForBonus(SpellEntry const* spellProto, DamageEffectType damagetype, uint32 CastingTime)
{
// Not apply this to creature casted spells with casttime == 0
if (CastingTime == 0 && GetTypeId() == TYPEID_UNIT && !ToCreature()->isPet())
@@ -15068,7 +15054,7 @@ bool Unit::IsUnderLastManaUseEffect() const
return getMSTimeDiff(m_lastManaUse, getMSTime()) < 5000;
}
-void Unit::SetContestedPvP(Player *attackedPlayer)
+void Unit::SetContestedPvP(Player* attackedPlayer)
{
Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
@@ -15174,7 +15160,7 @@ bool Unit::InitTamedPet(Pet * pet, uint8 level, uint32 spell_id)
return true;
}
-bool Unit::IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura * aura, SpellEntry const* procSpell, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, bool isVictim, bool active, SpellProcEventEntry const *& spellProcEvent)
+bool Unit::IsTriggeredAtSpellProcEvent(Unit* victim, Aura* aura, SpellEntry const* procSpell, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, bool isVictim, bool active, SpellProcEventEntry const* & spellProcEvent)
{
SpellEntry const* spellProto = aura->GetSpellProto();
@@ -15210,8 +15196,8 @@ bool Unit::IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura * aura, SpellEntry co
{
bool allow = false;
- if (pVictim)
- allow = ToPlayer()->isHonorOrXPTarget(pVictim);
+ if (victim)
+ allow = ToPlayer()->isHonorOrXPTarget(victim);
// Shadow Word: Death - can trigger from every kill
if (aura->GetId() == 32409)
@@ -15268,8 +15254,8 @@ bool Unit::IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura * aura, SpellEntry co
}
else
{
- uint32 WeaponSpeed = pVictim->GetAttackTime(attType);
- chance = pVictim->GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate, spellProto);
+ uint32 WeaponSpeed = victim->GetAttackTime(attType);
+ chance = victim->GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate, spellProto);
}
}
// Apply chance modifer aura
@@ -15280,7 +15266,7 @@ bool Unit::IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura * aura, SpellEntry co
return roll_chance_f(chance);
}
-bool Unit::HandleAuraRaidProcFromChargeWithValue(AuraEffect *triggeredByAura)
+bool Unit::HandleAuraRaidProcFromChargeWithValue(AuraEffect* triggeredByAura)
{
// aura can be deleted at casts
SpellEntry const* spellProto = triggeredByAura->GetSpellProto();
@@ -15288,7 +15274,7 @@ bool Unit::HandleAuraRaidProcFromChargeWithValue(AuraEffect *triggeredByAura)
int32 heal = triggeredByAura->GetAmount();
uint64 caster_guid = triggeredByAura->GetCasterGUID();
- //Currently only Prayer of Mending
+ // Currently only Prayer of Mending
if (!(spellProto->SpellFamilyName == SPELLFAMILY_PRIEST && spellProto->SpellFamilyFlags[1] & 0x20))
{
sLog->outDebug(LOG_FILTER_SPELLS_AURAS, "Unit::HandleAuraRaidProcFromChargeWithValue, received not handled spell: %u", spellProto->Id);
@@ -15617,8 +15603,8 @@ void Unit::Kill(Unit* victim, bool durabilityLoss)
if (OutdoorPvP* pvp = player->GetOutdoorPvP())
pvp->HandleKill(player, victim);
- //if (pVictim->GetTypeId() == TYPEID_PLAYER)
- // if (OutdoorPvP* pvp = pVictim->ToPlayer()->GetOutdoorPvP())
+ //if (victim->GetTypeId() == TYPEID_PLAYER)
+ // if (OutdoorPvP* pvp = victim->ToPlayer()->GetOutdoorPvP())
// pvp->HandlePlayerActivityChangedpVictim->ToPlayer();
// battleground things (do this at the end, so the death state flag will be properly set to handle in the bg->handlekill)
@@ -16038,7 +16024,7 @@ bool Unit::SetCharmedBy(Unit* charmer, CharmType type, AuraApplication const* au
return true;
}
-void Unit::RemoveCharmedBy(Unit *charmer)
+void Unit::RemoveCharmedBy(Unit* charmer)
{
if (!isCharmed())
return;
@@ -16193,15 +16179,15 @@ void Unit::RemoveVehicleKit()
RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_PLAYER_VEHICLE);
}
-Unit *Unit::GetVehicleBase() const
+Unit* Unit::GetVehicleBase() const
{
return m_vehicle ? m_vehicle->GetBase() : NULL;
}
-Creature *Unit::GetVehicleCreatureBase() const
+Creature* Unit::GetVehicleCreatureBase() const
{
- if (Unit *veh = GetVehicleBase())
- if (Creature *c = veh->ToCreature())
+ if (Unit* veh = GetVehicleBase())
+ if (Creature* c = veh->ToCreature())
return c;
return NULL;
@@ -16217,13 +16203,13 @@ uint64 Unit::GetTransGUID() const
return 0;
}
-bool Unit::IsInPartyWith(Unit const *unit) const
+bool Unit::IsInPartyWith(Unit const* unit) const
{
if (this == unit)
return true;
- const Unit *u1 = GetCharmerOrOwnerOrSelf();
- const Unit *u2 = unit->GetCharmerOrOwnerOrSelf();
+ const Unit* u1 = GetCharmerOrOwnerOrSelf();
+ const Unit* u2 = unit->GetCharmerOrOwnerOrSelf();
if (u1 == u2)
return true;
@@ -16233,13 +16219,13 @@ bool Unit::IsInPartyWith(Unit const *unit) const
return false;
}
-bool Unit::IsInRaidWith(Unit const *unit) const
+bool Unit::IsInRaidWith(Unit const* unit) const
{
if (this == unit)
return true;
- const Unit *u1 = GetCharmerOrOwnerOrSelf();
- const Unit *u2 = unit->GetCharmerOrOwnerOrSelf();
+ const Unit* u1 = GetCharmerOrOwnerOrSelf();
+ const Unit* u2 = unit->GetCharmerOrOwnerOrSelf();
if (u1 == u2)
return true;
@@ -16357,7 +16343,7 @@ void Unit::GetPartyMembers(std::list<Unit*> &TagUnitMap)
}
}
-Aura * Unit::AddAura(uint32 spellId, Unit* target)
+Aura* Unit::AddAura(uint32 spellId, Unit* target)
{
if (!target)
return NULL;
@@ -16372,7 +16358,7 @@ Aura * Unit::AddAura(uint32 spellId, Unit* target)
return AddAura(spellInfo, MAX_EFFECT_MASK, target);
}
-Aura * Unit::AddAura(SpellEntry const *spellInfo, uint8 effMask, Unit* target)
+Aura* Unit::AddAura(SpellEntry const* spellInfo, uint8 effMask, Unit* target)
{
if (!spellInfo)
return NULL;
@@ -16398,7 +16384,7 @@ Aura * Unit::AddAura(SpellEntry const *spellInfo, uint8 effMask, Unit* target)
void Unit::SetAuraStack(uint32 spellId, Unit* target, uint32 stack)
{
- Aura *aura = target->GetAura(spellId, GetGUID());
+ Aura* aura = target->GetAura(spellId, GetGUID());
if (!aura)
aura = AddAura(spellId, target);
if (aura && stack)
@@ -16484,7 +16470,7 @@ void Unit::ApplyResilience(Unit const* victim, float* crit, int32* damage, bool
// Melee based spells can be miss, parry or dodge on this step
// Crit or block - determined on damage calculation phase! (and can be both in some time)
-float Unit::MeleeSpellMissChance(const Unit *pVictim, WeaponAttackType attType, int32 skillDiff, uint32 spellId) const
+float Unit::MeleeSpellMissChance(const Unit* victim, WeaponAttackType attType, int32 skillDiff, uint32 spellId) const
{
// Calculate hit chance (more correct for chance mod)
int32 HitChance;
@@ -16497,9 +16483,9 @@ float Unit::MeleeSpellMissChance(const Unit *pVictim, WeaponAttackType attType,
// Hit chance depends from victim auras
if (attType == RANGED_ATTACK)
- HitChance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
+ HitChance += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
else
- HitChance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
+ HitChance += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
// Spellmod from SPELLMOD_RESIST_MISS_CHANCE
if (spellId)
@@ -16520,7 +16506,7 @@ float Unit::MeleeSpellMissChance(const Unit *pVictim, WeaponAttackType attType,
// bonus from skills is 0.04%
//miss_chance -= skillDiff * 0.04f;
int32 diff = -skillDiff;
- if (pVictim->GetTypeId() == TYPEID_PLAYER)
+ if (victim->GetTypeId() == TYPEID_PLAYER)
miss_chance += diff > 0 ? diff * 0.04f : diff * 0.02f;
else
miss_chance += diff > 10 ? 2 + (diff - 10) * 0.4f : diff * 0.1f;
@@ -16552,7 +16538,7 @@ void Unit::SetPhaseMask(uint32 newPhaseMask, bool update)
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
if (m_SummonSlot[i])
- if (Creature *summon = GetMap()->GetCreature(m_SummonSlot[i]))
+ if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
summon->SetPhaseMask(newPhaseMask, true);
}
@@ -16574,9 +16560,9 @@ void Unit::KnockbackFrom(float x, float y, float speedXY, float speedZ)
Player* player = NULL;
if (GetTypeId() == TYPEID_PLAYER)
player = (Player*)this;
- else if (GetCharmer())
+ else if (Unit* charmer = GetCharmer())
{
- player = GetCharmer()->ToPlayer();
+ player = charmer->ToPlayer();
if (player && player->m_mover != this)
player = NULL;
}
@@ -16994,7 +16980,7 @@ bool Unit::HandleSpellClick(Unit* clicker, int8 seatId)
return success;
}
-void Unit::EnterVehicle(Unit *base, int8 seatId)
+void Unit::EnterVehicle(Unit* base, int8 seatId)
{
CastCustomSpell(VEHICLE_SPELL_RIDE_HARDCODED, SPELLVALUE_BASE_POINT0, seatId+1, base, false);
}