#include <SpellAuraEffects.h>

Public Member Functions
	~AuraEffect ()

	AuraEffect (Aura base, uint32 effIndex, int32 baseAmount, Unit *caster)

Unit *	GetCaster () const

ObjectGuid	GetCasterGUID () const

Aura *	GetBase () const

void	GetTargetList (std::list< Unit * > &targetList) const

void	GetApplicationList (std::list< AuraApplication * > &applicationList) const

SpellModifier *	GetSpellModifier () const

SpellInfo const *	GetSpellInfo () const

uint32	GetId () const

uint32	GetEffIndex () const

int32	GetBaseAmount () const

int32	GetPeriod () const

int32	GetMiscValueB () const

int32	GetMiscValue () const

AuraType	GetAuraType () const

int32	GetAmount () const

void	SetAmount (int32 amount)

int32	GetPeriodicTimer () const

void	SetPeriodicTimer (int32 periodicTimer)

int32	CalculateAmount (Unit *caster)

void	CalculatePeriodic (Unit *caster, bool resetPeriodicTimer=true, bool load=false)

void	CalculateSpellMod ()

void	ChangeAmount (int32 newAmount, bool mark=true, bool onStackOrReapply=false)

void	RecalculateAmount ()

void	RecalculateAmount (Unit *caster)

bool	CanBeRecalculated () const

void	SetCanBeRecalculated (bool val)

void	HandleEffect (AuraApplication *aurApp, uint8 mode, bool apply)

void	HandleEffect (Unit *target, uint8 mode, bool apply)

void	ApplySpellMod (Unit *target, bool apply)

void	SetDamage (int32 val)

int32	GetDamage () const

void	SetCritChance (float val)

float	GetCritChance () const

void	SetDonePct (float val)

float	GetDonePct () const

void	Update (uint32 diff, Unit *caster)

void	UpdatePeriodic (Unit *caster)

uint32	GetTickNumber () const

int32	GetTotalTicks () const

void	ResetPeriodic (bool resetPeriodicTimer=false)

bool	IsPeriodic () const

void	SetPeriodic (bool isPeriodic)

bool	IsAffectingSpell (SpellInfo const *spell) const

bool	HasSpellClassMask () const

void	SendTickImmune (Unit target, Unit caster) const

void	PeriodicTick (AuraApplication aurApp, Unit caster) const

void	HandleProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	CleanupTriggeredSpells (Unit *target)

void	HandleShapeshiftBoosts (Unit *target, bool apply) const

SpellEffectInfo const *	GetSpellEffectInfo () const

bool	IsEffect () const

bool	IsEffect (SpellEffectName effectName) const

bool	IsAreaAuraEffect () const

void	HandleNULL (AuraApplication const *, uint8, bool) const

void	HandleUnused (AuraApplication const *, uint8, bool) const

void	HandleNoImmediateEffect (AuraApplication const *, uint8, bool) const

void	HandleModInvisibilityDetect (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModInvisibility (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModStealth (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModStealthLevel (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModStealthDetect (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleSpiritOfRedemption (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraGhost (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandlePhase (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandlePhaseGroup (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModShapeshift (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraTransform (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModScale (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraCloneCaster (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleFeignDeath (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModUnattackable (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModDisarm (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModSilence (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModPacify (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModPacifyAndSilence (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraAllowOnlyAbility (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraTrackResources (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraTrackCreatures (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraTrackStealthed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModStalked (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraUntrackable (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModPetTalentsPoints (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModSkill (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraMounted (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraAllowFlight (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraWaterWalk (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraFeatherFall (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraHover (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleWaterBreathing (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleForceMoveForward (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModThreat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModTotalThreat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModTaunt (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModConfuse (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModFear (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModStun (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModRoot (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandlePreventFleeing (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPossess (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPossessPet (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModCharm (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleCharmConvert (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraControlVehicle (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseMountedSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseFlightSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseSwimSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModDecreaseSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModUseNormalSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModStateImmunityMask (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModMechanicImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModEffectImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModStateImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModSchoolImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModDmgImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModDispelImmunity (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModResistanceExclusive (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModResistance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModBaseResistancePCT (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModResistancePercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModBaseResistance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModTargetResistance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPercentStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellDamagePercentFromStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellHealingPercentFromStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellDamagePercentFromAttackPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellHealingPercentFromAttackPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModHealingDone (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModTotalPercentStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModResistenceOfStatPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModExpertise (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModStatBonusPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleOverrideSpellPowerByAttackPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleOverrideAttackPowerBySpellPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPowerRegen (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPowerRegenPCT (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModManaRegen (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseHealth (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseMaxHealth (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseEnergy (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseEnergyPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseHealthPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraIncreaseBaseHealthPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModIncreaseBaseManaPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModParryPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModDodgePercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModBlockPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModRegenInterrupt (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModWeaponCritPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModHitChance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellHitChance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellCritChance (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellCritChanceShool (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModCritPct (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModCastingSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModMeleeRangedSpeedPct (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModCombatSpeedPct (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModAttackSpeed (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModMeleeSpeedPct (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModRangedHaste (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModRating (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModRatingFromStat (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModAttackPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModRangedAttackPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModAttackPowerPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModRangedAttackPowerPercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModAttackPowerOfArmor (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModDamageDone (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModDamagePercentDone (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModOffhandDamagePercent (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleShieldBlockValue (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPowerCostPCT (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModPowerCost (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleArenaPreparation (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleNoReagentUseAura (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraRetainComboPoints (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraDummy (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleChannelDeathItem (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleBindSight (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleForceReaction (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraEmpathy (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModFaction (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleComprehendLanguage (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraConvertRune (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraLinked (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraOpenStable (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraModFakeInebriation (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraOverrideSpells (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraSetVehicle (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandlePreventResurrection (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleMastery (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleAuraForceWeather (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleEnableAltPower (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandleModSpellCategoryCooldown (AuraApplication const *aurApp, uint8 mode, bool apply) const

void	HandlePeriodicDummyAuraTick (Unit target, Unit caster) const

void	HandlePeriodicTriggerSpellAuraTick (Unit target, Unit caster) const

void	HandlePeriodicTriggerSpellWithValueAuraTick (Unit target, Unit caster) const

void	HandlePeriodicDamageAurasTick (Unit target, Unit caster) const

void	HandlePeriodicHealthLeechAuraTick (Unit target, Unit caster) const

void	HandlePeriodicHealthFunnelAuraTick (Unit target, Unit caster) const

void	HandlePeriodicHealAurasTick (Unit target, Unit caster) const

void	HandlePeriodicManaLeechAuraTick (Unit target, Unit caster) const

void	HandleObsModPowerAuraTick (Unit target, Unit caster) const

void	HandlePeriodicEnergizeAuraTick (Unit target, Unit caster) const

void	HandlePeriodicPowerBurnAuraTick (Unit target, Unit caster) const

void	HandleProcTriggerSpellAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	HandleProcTriggerSpellWithValueAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	HandleProcTriggerDamageAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	HandleRaidProcFromChargeAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	HandleRaidProcFromChargeWithValueAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	HandleProcTriggerSpellOnPowerAmountAuraProc (AuraApplication *aurApp, ProcEventInfo &eventInfo)

Private Member Functions
friend	Aura::~Aura ()

bool	CanPeriodicTickCrit (Unit const *caster) const

Private Attributes
Aura *const	m_base

SpellInfo const *const	m_spellInfo

SpellEffectInfo const *	_effectInfo

int32 const	m_baseAmount

int32	m_amount

int32	m_damage

float	m_critChance

float	m_donePct

SpellModifier *	m_spellmod

int32	m_periodicTimer

int32	m_period

uint32	m_tickNumber

uint8 const	m_effIndex

bool	m_canBeRecalculated

bool	m_isPeriodic

Friends
void	Aura::_InitEffects (uint32 effMask, Unit caster, int32 baseAmount)

Aura *	Unit::_TryStackingOrRefreshingExistingAura (SpellInfo const newAura, uint32 effMask, Unit caster, int32 baseAmount, Item castItem, ObjectGuid casterGUID, int32 castItemLevel)

Constructor & Destructor Documentation

AuraEffect::Aura::~Aura ( )

private

AuraEffect::~AuraEffect ( )

 {
  delete m_spellmod;
 }

AuraEffect::AuraEffect	(	Aura *	base,
		uint32	effIndex,
		int32 *	baseAmount,
		Unit *	caster
	)

  :
 m_base(base), m_spellInfo(base->GetSpellInfo()),
 _effectInfo(base->GetSpellEffectInfo(effIndex)),
 m_baseAmount(baseAmount ? *baseAmount : base->GetSpellEffectInfo(effIndex)->BasePoints),
 m_damage(0), m_critChance(0.0f), m_donePct(1.0f),
 m_spellmod(NULL), m_periodicTimer(0), m_tickNumber(0), m_effIndex(effIndex),
 m_canBeRecalculated(true), m_isPeriodic(false)
 {
  CalculatePeriodic(caster, true, false);
 
  m_amount = CalculateAmount(caster);
 
  CalculateSpellMod();
 }

Here is the call graph for this function:

Member Function Documentation

void AuraEffect::ApplySpellMod	(	Unit *	target,
		bool	apply
	)

 {
  if (!m_spellmod || target->GetTypeId() != TYPEID_PLAYER)
  return;
 
  target->ToPlayer()->AddSpellMod(m_spellmod, apply);
 
  // Auras with charges do not mod amount of passive auras
  if (GetBase()->IsUsingCharges())
  return;
  // reapply some passive spells after add/remove related spellmods
  // Warning: it is a dead loop if 2 auras each other amount-shouldn't happen
  switch (GetMiscValue())
  {
  case SPELLMOD_ALL_EFFECTS:
  case SPELLMOD_EFFECT1:
  case SPELLMOD_EFFECT2:
  case SPELLMOD_EFFECT3:
  case SPELLMOD_EFFECT4:
  case SPELLMOD_EFFECT5:
  {
  ObjectGuid guid = target->GetGUID();
  Unit::AuraApplicationMap & auras = target->GetAppliedAuras();
  for (Unit::AuraApplicationMap::iterator iter = auras.begin(); iter != auras.end(); ++iter)
  {
  Aura* aura = iter->second->GetBase();
  // only passive and permament auras-active auras should have amount set on spellcast and not be affected
  // if aura is cast by others, it will not be affected
  if ((aura->IsPassive() || aura->IsPermanent()) && aura->GetCasterGUID() == guid && aura->GetSpellInfo()->IsAffectedBySpellMod(m_spellmod))
  {
  if (GetMiscValue() == SPELLMOD_ALL_EFFECTS)
  {
  for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
  {
  if (AuraEffect* aurEff = aura->GetEffect(i))
  aurEff->RecalculateAmount();
  }
  }
  else if (GetMiscValue() == SPELLMOD_EFFECT1)
  {
  if (AuraEffect* aurEff = aura->GetEffect(0))
  aurEff->RecalculateAmount();
  }
  else if (GetMiscValue() == SPELLMOD_EFFECT2)
  {
  if (AuraEffect* aurEff = aura->GetEffect(1))
  aurEff->RecalculateAmount();
  }
  else if (GetMiscValue() == SPELLMOD_EFFECT3)
  {
  if (AuraEffect* aurEff = aura->GetEffect(2))
  aurEff->RecalculateAmount();
  }
  else if (GetMiscValue() == SPELLMOD_EFFECT4)
  {
  if (AuraEffect* aurEff = aura->GetEffect(3))
  aurEff->RecalculateAmount();
  }
  else if (GetMiscValue() == SPELLMOD_EFFECT5)
  {
  if (AuraEffect* aurEff = aura->GetEffect(4))
  aurEff->RecalculateAmount();
  }
  }
  }
  }
  default:
  break;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 AuraEffect::CalculateAmount ( Unit * caster )

 {
  // default amount calculation
  int32 amount = 0;
 
  if (!m_spellInfo->HasAttribute(SPELL_ATTR8_MASTERY_SPECIALIZATION) || G3D::fuzzyEq(GetSpellEffectInfo()->BonusCoefficient, 0.0f))
  amount = GetSpellEffectInfo()->CalcValue(caster, &m_baseAmount, GetBase()->GetOwner()->ToUnit(), nullptr, GetBase()->GetCastItemLevel());
  else if (caster && caster->GetTypeId() == TYPEID_PLAYER)
  amount = int32(caster->GetFloatValue(PLAYER_MASTERY) * GetSpellEffectInfo()->BonusCoefficient);
 
  // check item enchant aura cast
  if (!amount && caster)
  {
  ObjectGuid itemGUID = GetBase()->GetCastItemGUID();
  if (!itemGUID.IsEmpty())
  {
  if (Player* playerCaster = caster->ToPlayer())
  {
  if (Item* castItem = playerCaster->GetItemByGuid(itemGUID))
  {
  if (castItem->GetItemSuffixFactor())
  {
  ItemRandomSuffixEntry const* item_rand_suffix = sItemRandomSuffixStore.LookupEntry(abs(castItem->GetItemRandomPropertyId()));
  if (item_rand_suffix)
  {
  for (int k = 0; k < MAX_ITEM_RANDOM_PROPERTIES; k++)
  {
  SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(item_rand_suffix->Enchantment[k]);
  if (pEnchant)
  {
  for (int t = 0; t < MAX_ITEM_ENCHANTMENT_EFFECTS; t++)
  {
  if (pEnchant->EffectSpellID[t] == m_spellInfo->Id)
  {
  amount = uint32((item_rand_suffix->AllocationPct[k] * castItem->GetItemSuffixFactor()) / 10000);
  break;
  }
  }
  }
 
  if (amount)
  break;
  }
  }
  }
  }
  }
  }
  }
 
  // custom amount calculations go here
  switch (GetAuraType())
  {
  // crowd control auras
  case SPELL_AURA_MOD_CONFUSE:
  case SPELL_AURA_MOD_FEAR:
  case SPELL_AURA_MOD_STUN:
  case SPELL_AURA_MOD_ROOT:
  case SPELL_AURA_TRANSFORM:
  m_canBeRecalculated = false;
  if (!m_spellInfo->ProcFlags)
  break;
  amount = int32(GetBase()->GetUnitOwner()->CountPctFromMaxHealth(10));
  if (caster)
  {
  // Glyphs increasing damage cap
  Unit::AuraEffectList const& overrideClassScripts = caster->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
  for (Unit::AuraEffectList::const_iterator itr = overrideClassScripts.begin(); itr != overrideClassScripts.end(); ++itr)
  {
  if ((*itr)->IsAffectingSpell(m_spellInfo))
  {
  // Glyph of Frost nova and similar auras
  if ((*itr)->GetMiscValue() == 7801)
  {
  AddPct(amount, (*itr)->GetAmount());
  break;
  }
  }
  }
  }
  break;
  case SPELL_AURA_SCHOOL_ABSORB:
  case SPELL_AURA_MANA_SHIELD:
  m_canBeRecalculated = false;
  break;
  case SPELL_AURA_MOUNTED:
  {
  uint32 mountType = uint32(GetMiscValueB());
  if (MountEntry const* mountEntry = sDB2Manager.GetMount(GetId()))
  mountType = mountEntry->MountTypeId;
 
  if (MountCapabilityEntry const* mountCapability = GetBase()->GetUnitOwner()->GetMountCapability(mountType))
  {
  amount = mountCapability->ID;
  m_canBeRecalculated = false;
  }
  break;
  }
  case SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE:
  {
  if (caster)
  {
  // if Level <= 70 resist = player level
  int32 resist = caster->getLevel();
 
  if (resist > 70 && resist < 81)
  resist += (resist - 70) * 5;
  else if (resist > 80)
  resist += ((resist-70) * 5 + (resist - 80) * 7);
 
  switch (GetId())
  {
  case 20043: // Aspect of the Wild
  case 8185: // Elemental Resistance
  case 19891: // Resistance Aura
  case 79106: // Shadow Protection
  case 79107: // Shadow Protection
  amount = resist;
  break;
  case 79060: // Mark of the Wild
  case 79061: // Mark of the Wild
  case 79062: // Blessing of Kings
  case 79063: // Blessing of Kings
  case 90363: // Embrace of the Shale Spider
  amount = resist / 2;
  break;
  }
  break;
  }
  }
  default:
  break;
  }
 
  GetBase()->CallScriptEffectCalcAmountHandlers(this, amount, m_canBeRecalculated);
  amount *= GetBase()->GetStackAmount();
  return amount;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::CalculatePeriodic	(	Unit *	caster,
		bool	resetPeriodicTimer = `true`,
		bool	load = `false`
	)

 {
  m_period = GetSpellEffectInfo()->ApplyAuraPeriod;
 
  // prepare periodics
  switch (GetAuraType())
  {
  case SPELL_AURA_OBS_MOD_POWER:
  // 3 spells have no amplitude set
  if (!m_period)
  m_period = 1 * IN_MILLISECONDS;
  case SPELL_AURA_PERIODIC_DAMAGE:
  case SPELL_AURA_PERIODIC_HEAL:
  case SPELL_AURA_OBS_MOD_HEALTH:
  case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
  case SPELL_AURA_PERIODIC_ENERGIZE:
  case SPELL_AURA_PERIODIC_LEECH:
  case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
  case SPELL_AURA_PERIODIC_MANA_LEECH:
  case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
  case SPELL_AURA_POWER_BURN:
  case SPELL_AURA_PERIODIC_DUMMY:
  case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
  m_isPeriodic = true;
  break;
  default:
  break;
  }
 
  GetBase()->CallScriptEffectCalcPeriodicHandlers(this, m_isPeriodic, m_period);
 
  if (!m_isPeriodic)
  return;
 
  Player* modOwner = caster ? caster->GetSpellModOwner() : NULL;
 
  // Apply casting time mods
  if (m_period)
  {
  // Apply periodic time mod
  if (modOwner)
  modOwner->ApplySpellMod(GetId(), SPELLMOD_ACTIVATION_TIME, m_period);
 
  if (caster)
  {
  // Haste modifies periodic time of channeled spells
  if (m_spellInfo->IsChanneled())
  caster->ModSpellDurationTime(m_spellInfo, m_period);
  else if (m_spellInfo->HasAttribute(SPELL_ATTR5_HASTE_AFFECT_DURATION))
  m_period = int32(m_period * caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
  }
  }
 
  if (load) // aura loaded from db
  {
  m_tickNumber = m_period ? GetBase()->GetDuration() / m_period : 0;
  m_periodicTimer = m_period ? GetBase()->GetDuration() % m_period : 0;
  if (m_spellInfo->HasAttribute(SPELL_ATTR5_START_PERIODIC_AT_APPLY))
  ++m_tickNumber;
  }
  else // aura just created or reapplied
  {
  m_tickNumber = 0;
  // reset periodic timer on aura create or on reapply when aura isn't dot
  // possibly we should not reset periodic timers only when aura is triggered by proc
  // or maybe there's a spell attribute somewhere
  if (resetPeriodicTimer)
  {
  m_periodicTimer = 0;
  // Start periodic on next tick or at aura apply
  if (m_period && !m_spellInfo->HasAttribute(SPELL_ATTR5_START_PERIODIC_AT_APPLY))
  m_periodicTimer += m_period;
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::CalculateSpellMod ( )

 {
  switch (GetAuraType())
  {
  case SPELL_AURA_ADD_FLAT_MODIFIER:
  case SPELL_AURA_ADD_PCT_MODIFIER:
  if (!m_spellmod)
  {
  m_spellmod = new SpellModifier(GetBase());
  m_spellmod->op = SpellModOp(GetMiscValue());
 
  m_spellmod->type = SpellModType(uint32(GetAuraType())); // SpellModType value == spell aura types
  m_spellmod->spellId = GetId();
  m_spellmod->mask = GetSpellEffectInfo()->SpellClassMask;
  m_spellmod->charges = GetBase()->GetCharges();
  }
  m_spellmod->value = GetAmount();
  break;
  default:
  break;
  }
  GetBase()->CallScriptEffectCalcSpellModHandlers(this, m_spellmod);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool AuraEffect::CanBeRecalculated ( ) const

inline

67 { return m_canBeRecalculated; }

AuraEffect::m_canBeRecalculated

bool m_canBeRecalculated

Definition: SpellAuraEffects.h:127

Here is the caller graph for this function:

bool AuraEffect::CanPeriodicTickCrit ( Unit const * caster ) const

private

 {
     ASSERT(caster);
 
     return caster->HasAuraTypeWithAffectMask(SPELL_AURA_ABILITY_PERIODIC_CRIT, m_spellInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::ChangeAmount	(	int32	newAmount,
		bool	mark = `true`,
		bool	onStackOrReapply = `false`
	)

 {
     // Reapply if amount change
     uint8 handleMask = 0;
     if (newAmount != GetAmount())
         handleMask |= AURA_EFFECT_HANDLE_CHANGE_AMOUNT;
     if (onStackOrReapply)
         handleMask |= AURA_EFFECT_HANDLE_REAPPLY;
 
     if (!handleMask)
         return;
 
     std::list<AuraApplication*> effectApplications;
     GetApplicationList(effectApplications);
 
     for (std::list<AuraApplication*>::const_iterator apptItr = effectApplications.begin(); apptItr != effectApplications.end(); ++apptItr)
         if ((*apptItr)->HasEffect(GetEffIndex()))
             HandleEffect(*apptItr, handleMask, false);
 
     if (handleMask & AURA_EFFECT_HANDLE_CHANGE_AMOUNT)
     {
         if (!mark)
             m_amount = newAmount;
         else
             SetAmount(newAmount);
         CalculateSpellMod();
     }
 
     for (std::list<AuraApplication*>::const_iterator apptItr = effectApplications.begin(); apptItr != effectApplications.end(); ++apptItr)
         if ((*apptItr)->HasEffect(GetEffIndex()))
             HandleEffect(*apptItr, handleMask, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::CleanupTriggeredSpells ( Unit * target )

Todo:: is there a spell flag, which can solve this in a more sophisticated way?

 {
     uint32 tSpellId = GetSpellEffectInfo()->TriggerSpell;
     if (!tSpellId)
         return;
 
     SpellInfo const* tProto = sSpellMgr->GetSpellInfo(tSpellId);
     if (!tProto)
         return;
 
     if (tProto->GetDuration() != -1)
         return;
 
     // needed for spell 43680, maybe others
     if (GetSpellEffectInfo()->ApplyAuraName == SPELL_AURA_PERIODIC_TRIGGER_SPELL &&
         uint32(m_spellInfo->GetDuration()) == GetSpellEffectInfo()->ApplyAuraPeriod)
         return;
 
     target->RemoveAurasDueToSpell(tSpellId, GetCasterGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 AuraEffect::GetAmount ( ) const

inline

55 { return m_amount; }

AuraEffect::m_amount

int32 m_amount

Definition: SpellAuraEffects.h:115

void AuraEffect::GetApplicationList ( std::list< AuraApplication * > & applicationList ) const

 {
     Aura::ApplicationMap const & targetMap = GetBase()->GetApplicationMap();
     for (Aura::ApplicationMap::const_iterator appIter = targetMap.begin(); appIter != targetMap.end(); ++appIter)
     {
         if (appIter->second->HasEffect(GetEffIndex()))
             applicationList.push_back(appIter->second);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraType AuraEffect::GetAuraType ( ) const

inline

54 { return (AuraType)GetSpellEffectInfo()->ApplyAuraName; }

AuraType

Definition: SpellAuraDefines.h:58

AuraEffect::GetSpellEffectInfo

SpellEffectInfo const * GetSpellEffectInfo() const

Definition: SpellAuraEffects.h:102

SpellEffectInfo::ApplyAuraName

uint32 ApplyAuraName

Definition: SpellInfo.h:244

Here is the caller graph for this function:

Aura* AuraEffect::GetBase ( ) const

inline

41 { return m_base; }

AuraEffect::m_base

Aura *const m_base

Definition: SpellAuraEffects.h:109

Here is the caller graph for this function:

int32 AuraEffect::GetBaseAmount ( ) const

inline

49 { return m_baseAmount; }

AuraEffect::m_baseAmount

int32 const m_baseAmount

Definition: SpellAuraEffects.h:113

Here is the caller graph for this function:

Unit* AuraEffect::GetCaster ( ) const

inline

39 { return GetBase()->GetCaster(); }

Aura::GetCaster

Unit * GetCaster() const

Definition: SpellAuras.cpp:438

AuraEffect::GetBase

Aura * GetBase() const

Definition: SpellAuraEffects.h:41

Here is the caller graph for this function:

ObjectGuid AuraEffect::GetCasterGUID ( ) const

inline

40 { return GetBase()->GetCasterGUID(); }

AuraEffect::GetBase

Aura * GetBase() const

Definition: SpellAuraEffects.h:41

Aura::GetCasterGUID

ObjectGuid GetCasterGUID() const

Definition: SpellAuras.h:135

Here is the caller graph for this function:

float AuraEffect::GetCritChance ( ) const

inline

76 { return m_critChance; }

AuraEffect::m_critChance

float m_critChance

Definition: SpellAuraEffects.h:117

int32 AuraEffect::GetDamage ( ) const

inline

74 { return m_damage; }

AuraEffect::m_damage

int32 m_damage

Definition: SpellAuraEffects.h:116

float AuraEffect::GetDonePct ( ) const

inline

78 { return m_donePct; }

AuraEffect::m_donePct

float m_donePct

Definition: SpellAuraEffects.h:118

uint32 AuraEffect::GetEffIndex ( ) const

inline

48 { return m_effIndex; }

AuraEffect::m_effIndex

uint8 const m_effIndex

Definition: SpellAuraEffects.h:126

Here is the caller graph for this function:

uint32 AuraEffect::GetId ( void ) const

inline

47 { return m_spellInfo->Id; }

SpellInfo::Id

uint32 Id

Definition: SpellInfo.h:329

AuraEffect::m_spellInfo

SpellInfo const *const m_spellInfo

Definition: SpellAuraEffects.h:111

Here is the caller graph for this function:

int32 AuraEffect::GetMiscValue ( ) const

inline

53 { return GetSpellEffectInfo()->MiscValue; }

SpellEffectInfo::MiscValue

int32 MiscValue

Definition: SpellInfo.h:253

AuraEffect::GetSpellEffectInfo

SpellEffectInfo const * GetSpellEffectInfo() const

Definition: SpellAuraEffects.h:102

int32 AuraEffect::GetMiscValueB ( ) const

inline

52 { return GetSpellEffectInfo()->MiscValueB; }

AuraEffect::GetSpellEffectInfo

SpellEffectInfo const * GetSpellEffectInfo() const

Definition: SpellAuraEffects.h:102

SpellEffectInfo::MiscValueB

int32 MiscValueB

Definition: SpellInfo.h:254

Here is the caller graph for this function:

int32 AuraEffect::GetPeriod ( ) const

inline

50 { return m_period; }

AuraEffect::m_period

int32 m_period

Definition: SpellAuraEffects.h:123

Here is the caller graph for this function:

int32 AuraEffect::GetPeriodicTimer ( ) const

inline

58 { return m_periodicTimer; }

AuraEffect::m_periodicTimer

int32 m_periodicTimer

Definition: SpellAuraEffects.h:122

Here is the caller graph for this function:

SpellEffectInfo const* AuraEffect::GetSpellEffectInfo ( ) const

inline

102 { return _effectInfo; }

AuraEffect::_effectInfo

SpellEffectInfo const * _effectInfo

Definition: SpellAuraEffects.h:112

Here is the caller graph for this function:

SpellInfo const* AuraEffect::GetSpellInfo ( ) const

inline

46 { return m_spellInfo; }

AuraEffect::m_spellInfo

SpellInfo const *const m_spellInfo

Definition: SpellAuraEffects.h:111

Here is the caller graph for this function:

SpellModifier* AuraEffect::GetSpellModifier ( ) const

inline

44 { return m_spellmod; }

AuraEffect::m_spellmod

SpellModifier * m_spellmod

Definition: SpellAuraEffects.h:120

void AuraEffect::GetTargetList ( std::list< Unit * > & targetList ) const

 {
     Aura::ApplicationMap const & targetMap = GetBase()->GetApplicationMap();
     // remove all targets which were not added to new list - they no longer deserve area aura
     for (Aura::ApplicationMap::const_iterator appIter = targetMap.begin(); appIter != targetMap.end(); ++appIter)
     {
         if (appIter->second->HasEffect(GetEffIndex()))
             targetList.push_back(appIter->second->GetTarget());
     }
 }

Here is the call graph for this function:

uint32 AuraEffect::GetTickNumber ( ) const

inline

83 { return m_tickNumber; }

AuraEffect::m_tickNumber

uint32 m_tickNumber

Definition: SpellAuraEffects.h:124

Here is the caller graph for this function:

int32 AuraEffect::GetTotalTicks ( ) const

inline

84 { return m_period ? (GetBase()->GetMaxDuration() / m_period) : 1;}

Aura::GetMaxDuration

int32 GetMaxDuration() const

Definition: SpellAuras.h:159

AuraEffect::GetBase

Aura * GetBase() const

Definition: SpellAuraEffects.h:41

AuraEffect::m_period

int32 m_period

Definition: SpellAuraEffects.h:123

Here is the caller graph for this function:

void AuraEffect::HandleArenaPreparation	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
         target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PREPARATION);
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
         target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PREPARATION);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraAllowFlight	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!apply)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()) || target->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED))
             return;
     }
 
     target->SetCanFly(apply);
 
     if (!apply && target->GetTypeId() == TYPEID_UNIT && !target->IsLevitating())
         target->GetMotionMaster()->MoveFall();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraAllowOnlyAbility	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         if (apply)
             target->SetFlag(PLAYER_FLAGS, PLAYER_ALLOW_ONLY_ABILITY);
         else
         {
             // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
             if (target->HasAuraType(SPELL_AURA_ALLOW_ONLY_ABILITY))
                 return;
             target->RemoveFlag(PLAYER_FLAGS, PLAYER_ALLOW_ONLY_ABILITY);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraCloneCaster	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         Unit* caster = GetCaster();
         if (!caster || caster == target)
             return;
 
         // What must be cloned? at least display and scale
         target->SetDisplayId(caster->GetDisplayId());
         //target->SetObjectScale(caster->GetObjectScale()); // we need retail info about how scaling is handled (aura maybe?)
         target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_MIRROR_IMAGE);
     }
     else
     {
         target->SetDisplayId(target->GetNativeDisplayId());
         target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_MIRROR_IMAGE);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraControlVehicle	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

Such auras are applied from a caster(=player) to a vehicle. This has been verified using spell #49256

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     if (!target->IsVehicle())
         return;
 
     Unit* caster = GetCaster();
     if (!caster || caster == target)
         return;
 
     if (apply)
     {
         // Currently spells that have base points  0 and DieSides 0 = "0/0" exception are pushed to -1,
         // however the idea of 0/0 is to ingore flag VEHICLE_SEAT_FLAG_CAN_ENTER_OR_EXIT and -1 checks for it,
         // so this break such spells or most of them.
         // Current formula about m_amount: effect base points + dieside - 1
         // TO DO: Reasearch more about 0/0 and fix it.
         caster->_EnterVehicle(target->GetVehicleKit(), m_amount - 1, aurApp);
     }
     else
     {
         // Remove pending passengers before exiting vehicle - might cause an Uninstall
         target->GetVehicleKit()->RemovePendingEventsForPassenger(caster);
 
         if (GetId() == 53111) // Devour Humanoid
         {
             target->Kill(caster);
             if (caster->GetTypeId() == TYPEID_UNIT)
                 caster->ToCreature()->RemoveCorpse();
         }
 
         if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT))
             caster->_ExitVehicle();
         else
             target->GetVehicleKit()->RemovePassenger(caster);  // Only remove passenger from vehicle without launching exit movement or despawning the vehicle
 
         // some SPELL_AURA_CONTROL_VEHICLE auras have a dummy effect on the player - remove them
         caster->RemoveAurasDueToSpell(GetId());
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraConvertRune	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Player* player = target->ToPlayer();
     if (!player)
         return;
 
     if (player->getClass() != CLASS_DEATH_KNIGHT)
         return;
 
     uint32 runes = m_amount;
     // convert number of runes specified in aura amount of rune type in miscvalue to runetype in miscvalueb
     if (apply)
     {
         for (uint32 i = 0; i < MAX_RUNES && runes; ++i)
         {
             if (GetMiscValue() != player->GetCurrentRune(i))
                 continue;
             if (!player->GetRuneCooldown(i))
             {
                 player->AddRuneByAuraEffect(i, RuneType(GetMiscValueB()), this);
                 --runes;
             }
         }
     }
     else
         player->RemoveRunesByAuraEffect(this);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraDummy	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_REAPPLY)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Unit* caster = GetCaster();
 
     if (mode & AURA_EFFECT_HANDLE_REAL)
     {
         // pet auras
         if (PetAura const* petSpell = sSpellMgr->GetPetAura(GetId(), m_effIndex))
         {
             if (apply)
                 target->AddPetAura(petSpell);
             else
                 target->RemovePetAura(petSpell);
         }
     }
 
     if (mode & (AURA_EFFECT_HANDLE_REAL | AURA_EFFECT_HANDLE_REAPPLY))
     {
         // AT APPLY
         if (apply)
         {
             switch (GetId())
             {
                 case 1515:                                      // Tame beast
                     // FIX_ME: this is 2.0.12 threat effect replaced in 2.1.x by dummy aura, must be checked for correctness
                     if (caster && target->CanHaveThreatList())
                         target->AddThreat(caster, 10.0f);
                     break;
                 case 13139:                                     // net-o-matic
                     // root to self part of (root_target->charge->root_self sequence
                     if (caster)
                         caster->CastSpell(caster, 13138, true, NULL, this);
                     break;
                 case 34026:   // kill command
                 {
                     Unit* pet = target->GetGuardianPet();
                     if (!pet)
                         break;
 
                     target->CastSpell(target, 34027, true, NULL, this);
 
                     // set 3 stacks and 3 charges (to make all auras not disappear at once)
                     Aura* owner_aura = target->GetAura(34027, GetCasterGUID());
                     Aura* pet_aura  = pet->GetAura(58914, GetCasterGUID());
                     if (owner_aura)
                     {
                         owner_aura->SetStackAmount(owner_aura->GetSpellInfo()->StackAmount);
                         if (pet_aura)
                         {
                             pet_aura->SetCharges(0);
                             pet_aura->SetStackAmount(owner_aura->GetSpellInfo()->StackAmount);
                         }
                     }
                     break;
                 }
                 case 37096:                                     // Blood Elf Illusion
                 {
                     if (caster)
                     {
                         if (caster->getGender() == GENDER_FEMALE)
                             caster->CastSpell(target, 37095, true, NULL, this); // Blood Elf Disguise
                         else
                             caster->CastSpell(target, 37093, true, NULL, this);
                     }
                     break;
                 }
                 case 39850:                                     // Rocket Blast
                     if (roll_chance_i(20))                       // backfire stun
                         target->CastSpell(target, 51581, true, NULL, this);
                     break;
                 case 43873:                                     // Headless Horseman Laugh
                     target->PlayDistanceSound(11965);
                     break;
                 case 46354:                                     // Blood Elf Illusion
                     if (caster)
                     {
                         if (caster->getGender() == GENDER_FEMALE)
                             caster->CastSpell(target, 46356, true, NULL, this);
                         else
                             caster->CastSpell(target, 46355, true, NULL, this);
                     }
                     break;
                 case 46361:                                     // Reinforced Net
                     if (caster)
                         target->GetMotionMaster()->MoveFall();
                     break;
                 case 71563:
                     if (Aura* newAura = target->AddAura(71564, target))
                         newAura->SetStackAmount(newAura->GetSpellInfo()->StackAmount);
                         break;
             }
         }
         // AT REMOVE
         else
         {
             if ((GetSpellInfo()->IsQuestTame()) && caster && caster->IsAlive() && target->IsAlive())
             {
                 uint32 finalSpelId = 0;
                 switch (GetId())
                 {
                     case 19548: finalSpelId = 19597; break;
                     case 19674: finalSpelId = 19677; break;
                     case 19687: finalSpelId = 19676; break;
                     case 19688: finalSpelId = 19678; break;
                     case 19689: finalSpelId = 19679; break;
                     case 19692: finalSpelId = 19680; break;
                     case 19693: finalSpelId = 19684; break;
                     case 19694: finalSpelId = 19681; break;
                     case 19696: finalSpelId = 19682; break;
                     case 19697: finalSpelId = 19683; break;
                     case 19699: finalSpelId = 19685; break;
                     case 19700: finalSpelId = 19686; break;
                     case 30646: finalSpelId = 30647; break;
                     case 30653: finalSpelId = 30648; break;
                     case 30654: finalSpelId = 30652; break;
                     case 30099: finalSpelId = 30100; break;
                     case 30102: finalSpelId = 30103; break;
                     case 30105: finalSpelId = 30104; break;
                 }
 
                 if (finalSpelId)
                     caster->CastSpell(target, finalSpelId, true, NULL, this);
             }
 
             switch (m_spellInfo->SpellFamilyName)
             {
                 case SPELLFAMILY_GENERIC:
                     switch (GetId())
                     {
                         case 2584: // Waiting to Resurrect
                             // Waiting to resurrect spell cancel, we must remove player from resurrect queue
                             if (target->GetTypeId() == TYPEID_PLAYER)
                             {
                                 if (Battleground* bg = target->ToPlayer()->GetBattleground())
                                     bg->RemovePlayerFromResurrectQueue(target->GetGUID());
                                 if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(target->GetZoneId()))
                                     bf->RemovePlayerFromResurrectQueue(target->GetGUID());
                             }
                             break;
                         case 36730:                                     // Flame Strike
                         {
                             target->CastSpell(target, 36731, true, NULL, this);
                             break;
                         }
                         case 44191:                                     // Flame Strike
                         {
                             if (target->GetMap()->IsDungeon())
                             {
                                 uint32 spellId = target->GetMap()->IsHeroic() ? 46163 : 44190;
 
                                 target->CastSpell(target, spellId, true, NULL, this);
                             }
                             break;
                         }
                         case 43681: // Inactive
                         {
                             if (target->GetTypeId() != TYPEID_PLAYER || aurApp->GetRemoveMode() != AURA_REMOVE_BY_EXPIRE)
                                 return;
 
                             if (target->GetMap()->IsBattleground())
                                 target->ToPlayer()->LeaveBattleground();
                             break;
                         }
                         case 42783: // Wrath of the Astromancer
                             target->CastSpell(target, GetAmount(), true, NULL, this);
                             break;
                         case 46308: // Burning Winds cast only at creatures at spawn
                             target->CastSpell(target, 47287, true, NULL, this);
                             break;
                         case 52172:  // Coyote Spirit Despawn Aura
                         case 60244:  // Blood Parrot Despawn Aura
                             target->CastSpell((Unit*)NULL, GetAmount(), true, NULL, this);
                             break;
                         case 91604: // Restricted Flight Area
                             if (aurApp->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
                                 target->CastSpell(target, 58601, true);
                             break;
                     }
                     break;
                 case SPELLFAMILY_DEATHKNIGHT:
                     // Summon Gargoyle (Dismiss Gargoyle at remove)
                     if (GetId() == 61777)
                         target->CastSpell(target, GetAmount(), true);
                     break;
                 default:
                     break;
             }
         }
     }
 
     // AT APPLY & REMOVE
 
     switch (m_spellInfo->SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
         {
             if (!(mode & AURA_EFFECT_HANDLE_REAL))
                 break;
             switch (GetId())
             {
                 // Recently Bandaged
                 case 11196:
                     target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, GetMiscValue(), apply);
                     break;
                 // Unstable Power
                 case 24658:
                 {
                     uint32 spellId = 24659;
                     if (apply && caster)
                     {
                         SpellInfo const* spell = sSpellMgr->AssertSpellInfo(spellId);
 
                         for (uint32 i = 0; i < spell->StackAmount; ++i)
                             caster->CastSpell(target, spell->Id, true, NULL, NULL, GetCasterGUID());
                         break;
                     }
                     target->RemoveAurasDueToSpell(spellId);
                     break;
                 }
                 // Restless Strength
                 case 24661:
                 {
                     uint32 spellId = 24662;
                     if (apply && caster)
                     {
                         SpellInfo const* spell = sSpellMgr->AssertSpellInfo(spellId);
                         for (uint32 i = 0; i < spell->StackAmount; ++i)
                             caster->CastSpell(target, spell->Id, true, NULL, NULL, GetCasterGUID());
                         break;
                     }
                     target->RemoveAurasDueToSpell(spellId);
                     break;
                 }
                 // Tag Murloc
                 case 30877:
                 {
                     // Tag/untag Blacksilt Scout
                     target->SetEntry(apply ? 17654 : 17326);
                     break;
                 }
                 case 57819: // Argent Champion
                 case 57820: // Ebon Champion
                 case 57821: // Champion of the Kirin Tor
                 case 57822: // Wyrmrest Champion
                 {
                     if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
                         break;
 
                     uint32 FactionID = 0;
 
                     if (apply)
                     {
                         switch (m_spellInfo->Id)
                         {
                             case 57819: FactionID = 1106; break; // Argent Crusade
                             case 57820: FactionID = 1098; break; // Knights of the Ebon Blade
                             case 57821: FactionID = 1090; break; // Kirin Tor
                             case 57822: FactionID = 1091; break; // The Wyrmrest Accord
                         }
                     }
                     caster->ToPlayer()->SetChampioningFaction(FactionID);
                     break;
                 }
                 // LK Intro VO (1)
                 case 58204:
                     if (target->GetTypeId() == TYPEID_PLAYER)
                     {
                         // Play part 1
                         if (apply)
                             target->PlayDirectSound(14970, target->ToPlayer());
                         // continue in 58205
                         else
                             target->CastSpell(target, 58205, true);
                     }
                     break;
                 // LK Intro VO (2)
                 case 58205:
                     if (target->GetTypeId() == TYPEID_PLAYER)
                     {
                         // Play part 2
                         if (apply)
                             target->PlayDirectSound(14971, target->ToPlayer());
                         // Play part 3
                         else
                             target->PlayDirectSound(14972, target->ToPlayer());
                     }
                     break;
             }
 
             break;
         }
         case SPELLFAMILY_MAGE:
         {
             //if (!(mode & AURA_EFFECT_HANDLE_REAL))
                 //break;
             break;
         }
         case SPELLFAMILY_PRIEST:
         {
             //if (!(mode & AURA_EFFECT_HANDLE_REAL))
                 //break;
             break;
         }
         case SPELLFAMILY_DRUID:
         {
             //if (!(mode & AURA_EFFECT_HANDLE_REAL))
                 //break;
             break;
         }
         case SPELLFAMILY_SHAMAN:
         {
             //if (!(mode & AURA_EFFECT_HANDLE_REAL))
                 //break;
             break;
         }
         case SPELLFAMILY_PALADIN:
             // if (!(mode & AURA_EFFECT_HANDLE_REAL))
             //    break;
             break;
         case SPELLFAMILY_DEATHKNIGHT:
         {
             //if (!(mode & AURA_EFFECT_HANDLE_REAL))
             //    break;
             break;
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraEmpathy	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
     if (!apply)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
     }
 
     if (target->GetCreatureType() == CREATURE_TYPE_BEAST)
         target->ApplyModUInt32Value(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraFeatherFall	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!apply)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
     }
 
     target->SetFeatherFall(apply);
 
     // start fall from current height
     if (!apply && target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->SetFallInformation(0, target->GetPositionZ());
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraForceWeather	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
 
     if (!target)
         return;
 
     if (apply)
     {
         WorldPackets::Misc::Weather weather(WeatherState(GetMiscValue()), 1.0f);
         target->GetSession()->SendPacket(weather.Write());
     }
     else
     {
         // send weather for current zone
         if (Weather* weather = WeatherMgr::FindWeather(target->GetZoneId()))
             weather->SendWeatherUpdateToPlayer(target);
         else
         {
             if (!WeatherMgr::AddWeather(target->GetZoneId()))
             {
                 // send fine weather packet to remove old weather
                 WeatherMgr::SendFineWeatherUpdateToPlayer(target);
             }
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraGhost	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (apply)
     {
         target->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST);
         target->m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
         target->m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
     }
     else
     {
         if (target->HasAuraType(SPELL_AURA_GHOST))
             return;
 
         target->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST);
         target->m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_ALIVE);
         target->m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_ALIVE);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraHover	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

Sets movementflags

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!apply)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
     }
 
     target->SetHover(apply);    
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraIncreaseBaseHealthPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->HandleStatModifier(UNIT_MOD_HEALTH, BASE_PCT, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraLinked	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     Unit* target = aurApp->GetTarget();
 
     uint32 triggeredSpellId = GetSpellEffectInfo()->TriggerSpell;
     SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggeredSpellId);
     if (!triggeredSpellInfo)
         return;
 
     Unit* caster = triggeredSpellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, target->GetMap()->GetDifficultyID()) ? GetCaster() : target;
     if (!caster)
         return;
 
     if (mode & AURA_EFFECT_HANDLE_REAL)
     {
         if (apply)
         {
             // If amount avalible cast with basepoints (Crypt Fever for example)
             if (GetAmount())
                 caster->CastCustomSpell(target, triggeredSpellId, &m_amount, NULL, NULL, true, NULL, this);
             else
                 caster->CastSpell(target, triggeredSpellId, true, NULL, this);
         }
         else
         {
             ObjectGuid casterGUID = triggeredSpellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, caster->GetMap()->GetDifficultyID()) ? GetCasterGUID() : target->GetGUID();
             target->RemoveAura(triggeredSpellId, casterGUID, 0, aurApp->GetRemoveMode());
         }
     }
     else if (mode & AURA_EFFECT_HANDLE_REAPPLY && apply)
     {
         ObjectGuid casterGUID = triggeredSpellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, caster->GetMap()->GetDifficultyID()) ? GetCasterGUID() : target->GetGUID();
         // change the stack amount to be equal to stack amount of our aura
         if (Aura* triggeredAura = target->GetAura(triggeredSpellId, casterGUID))
             triggeredAura->ModStackAmount(GetBase()->GetStackAmount() - triggeredAura->GetStackAmount());
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModAttackPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->HandleStatModifier(UNIT_MOD_ATTACK_POWER, TOTAL_VALUE, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModAttackPowerOfArmor	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // Recalculate bonus
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->UpdateAttackPowerAndDamage(false);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModAttackPowerPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     //UNIT_FIELD_ATTACK_POWER_MULTIPLIER = multiplier - 1
     target->HandleStatModifier(UNIT_MOD_ATTACK_POWER, TOTAL_PCT, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModBaseResistancePCT	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // only players have base stats
     if (target->GetTypeId() != TYPEID_PLAYER)
     {
         //pets only have base armor
         if (target->IsPet() && (GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL))
             target->HandleStatModifier(UNIT_MOD_ARMOR, BASE_PCT, float(GetAmount()), apply);
     }
     else
     {
         for (int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL; x++)
         {
             if (GetMiscValue() & int32(1<<x))
                 target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), BASE_PCT, float(GetAmount()), apply);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModBlockPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     target->ToPlayer()->UpdateBlockPercentage();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModCritPct	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
     {
         target->m_baseSpellCritChance += (apply) ? GetAmount():-GetAmount();
         return;
     }
 
     target->ToPlayer()->HandleBaseModValue(CRIT_PERCENTAGE,         FLAT_MOD, float (GetAmount()), apply);
     target->ToPlayer()->HandleBaseModValue(OFFHAND_CRIT_PERCENTAGE, FLAT_MOD, float (GetAmount()), apply);
     target->ToPlayer()->HandleBaseModValue(RANGED_CRIT_PERCENTAGE,  FLAT_MOD, float (GetAmount()), apply);
 
     // included in Player::UpdateSpellCritChance calculation
     target->ToPlayer()->UpdateAllSpellCritChances();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModDecreaseSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->UpdateSpeed(MOVE_RUN, true);
     target->UpdateSpeed(MOVE_SWIM, true);
     target->UpdateSpeed(MOVE_FLIGHT, true);
     target->UpdateSpeed(MOVE_RUN_BACK, true);
     target->UpdateSpeed(MOVE_SWIM_BACK, true);
     target->UpdateSpeed(MOVE_FLIGHT_BACK, true);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModDisarm	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     AuraType type = GetAuraType();
 
     // Prevent handling aura twice
     if (apply ? target->GetAuraEffectsByType(type).size() > 1 : target->HasAuraType(type))
         return;
 
     uint32 field, flag, slot;
     WeaponAttackType attType;
     switch (type)
     {
         case SPELL_AURA_MOD_DISARM:
             field = UNIT_FIELD_FLAGS;
             flag = UNIT_FLAG_DISARMED;
             slot = EQUIPMENT_SLOT_MAINHAND;
             attType = BASE_ATTACK;
             break;
         case SPELL_AURA_MOD_DISARM_OFFHAND:
             field = UNIT_FIELD_FLAGS_2;
             flag = UNIT_FLAG2_DISARM_OFFHAND;
             slot = EQUIPMENT_SLOT_OFFHAND;
             attType = OFF_ATTACK;
             break;
         case SPELL_AURA_MOD_DISARM_RANGED:
             field = UNIT_FIELD_FLAGS_2;
             flag = UNIT_FLAG2_DISARM_RANGED;
             slot = EQUIPMENT_SLOT_MAINHAND;
             attType = RANGED_ATTACK;
             break;
         default:
             return;
     }
 
     // if disarm aura is to be removed, remove the flag first to reapply damage/aura mods
     if (!apply)
         target->RemoveFlag(field, flag);
 
     // Handle damage modification, shapeshifted druids are not affected
     if (target->GetTypeId() == TYPEID_PLAYER && !target->IsInFeralForm())
     {
         Player* player = target->ToPlayer();
         if (Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))
         {
             uint8 attacktype = Player::GetAttackBySlot(slot, item->GetTemplate()->GetInventoryType());
 
             if (attacktype < MAX_ATTACK)
             {
                 player->_ApplyWeaponDamage(slot, item, !apply);
                 player->_ApplyWeaponDependentAuraMods(item, WeaponAttackType(attacktype), !apply);
             }
         }
     }
 
     // if disarm effects should be applied, wait to set flag until damage mods are unapplied
     if (apply)
         target->SetFlag(field, flag);
 
     if (target->GetTypeId() == TYPEID_UNIT && target->ToCreature()->GetCurrentEquipmentId())
         target->UpdateDamagePhysical(attType);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModDispelImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplySpellDispelImmunity(m_spellInfo, DispelType(GetMiscValue()), (apply));
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModDmgImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplySpellImmune(GetId(), IMMUNITY_DAMAGE, GetMiscValue(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModDodgePercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     target->ToPlayer()->UpdateDodgePercentage();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModEffectImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, GetMiscValue(), apply);
 
     // when removing flag aura, handle flag drop
     Player* player = target->ToPlayer();
     if (!apply && player && (GetSpellInfo()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION))
     {
         if (player->InBattleground())
         {
             if (Battleground* bg = player->GetBattleground())
                 bg->EventPlayerDroppedFlag(player);
         }
         else
             sOutdoorPvPMgr->HandleDropFlag(player, GetSpellInfo()->Id);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModExpertise	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     target->ToPlayer()->UpdateExpertise(BASE_ATTACK);
     target->ToPlayer()->UpdateExpertise(OFF_ATTACK);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModFaction	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         target->setFaction(GetMiscValue());
         if (target->GetTypeId() == TYPEID_PLAYER)
             target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
     }
     else
     {
         target->RestoreFaction();
         if (target->GetTypeId() == TYPEID_PLAYER)
             target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModFakeInebriation	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         target->m_invisibilityDetect.AddFlag(INVISIBILITY_DRUNK);
         target->m_invisibilityDetect.AddValue(INVISIBILITY_DRUNK, GetAmount());
 
         if (target->GetTypeId() == TYPEID_PLAYER)
         {
             int32 oldval = target->ToPlayer()->GetInt32Value(PLAYER_FAKE_INEBRIATION);
             target->ToPlayer()->SetInt32Value(PLAYER_FAKE_INEBRIATION, oldval + GetAmount());
         }
     }
     else
     {
         bool removeDetect = !target->HasAuraType(SPELL_AURA_MOD_FAKE_INEBRIATE);
 
         target->m_invisibilityDetect.AddValue(INVISIBILITY_DRUNK, -GetAmount());
 
         if (target->GetTypeId() == TYPEID_PLAYER)
         {
             int32 oldval = target->ToPlayer()->GetInt32Value(PLAYER_FAKE_INEBRIATION);
             target->ToPlayer()->SetInt32Value(PLAYER_FAKE_INEBRIATION, oldval - GetAmount());
 
             if (removeDetect)
                 removeDetect = !target->ToPlayer()->GetDrunkValue();
         }
 
         if (removeDetect)
             target->m_invisibilityDetect.DelFlag(INVISIBILITY_DRUNK);
     }
 
     // call functions which may have additional effects after chainging state of unit
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseBaseManaPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     aurApp->GetTarget()->HandleStatModifier(UNIT_MOD_MANA, BASE_PCT, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseEnergy	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Powers powerType = Powers(GetMiscValue());
     // do not check power type, we can always modify the maximum
     // as the client will not see any difference
     // also, placing conditions that may change during the aura duration
     // inside effect handlers is not a good idea
     //if (int32(powerType) != GetMiscValue())
     //    return;
 
     UnitMods unitMod = UnitMods(UNIT_MOD_POWER_START + powerType);
 
     target->HandleStatModifier(unitMod, TOTAL_VALUE, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseEnergyPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Powers powerType = Powers(GetMiscValue());
     // do not check power type, we can always modify the maximum
     // as the client will not see any difference
     // also, placing conditions that may change during the aura duration
     // inside effect handlers is not a good idea
     //if (int32(powerType) != GetMiscValue())
     //    return;
 
     UnitMods unitMod = UnitMods(UNIT_MOD_POWER_START + powerType);
     float amount = float(GetAmount());
 
     if (apply)
     {
         target->HandleStatModifier(unitMod, TOTAL_PCT, amount, apply);
         target->ModifyPowerPct(powerType, amount, apply);
     }
     else
     {
         target->ModifyPowerPct(powerType, amount, apply);
         target->HandleStatModifier(unitMod, TOTAL_PCT, amount, apply);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseFlightSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

Update ability to fly

Someone should clean up these hacks and remove it from this function. It doesn't even belong here.

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     if (mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK)
         target->UpdateSpeed(MOVE_FLIGHT, true);
 
     if (GetAuraType() == SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK && (apply || (!target->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) && !target->HasAuraType(SPELL_AURA_FLY))))
         {
             target->SetCanFly(apply);
 
             if (!apply && target->GetTypeId() == TYPEID_UNIT && !target->IsLevitating())
                 target->GetMotionMaster()->MoveFall();
         }
 
         if (mode & AURA_EFFECT_HANDLE_REAL)
         {
             //Players on flying mounts must be immune to polymorph
             if (target->GetTypeId() == TYPEID_PLAYER)
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
 
             // Dragonmaw Illusion (overwrite mount model, mounted aura already applied)
             if (apply && target->HasAuraEffect(42016, 0) && target->GetMountID())
                 target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 16314);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseHealth	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(GetAmount()), apply);
         target->ModifyHealth(GetAmount());
     }
     else
     {
         if (target->GetHealth() > 0)
         {
             int32 value = std::min<int32>(target->GetHealth() - 1, GetAmount());
             target->ModifyHealth(-value);
         }
         target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(GetAmount()), apply);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseHealthPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // Unit will keep hp% after MaxHealth being modified if unit is alive.
     float percent = target->GetHealthPct();
     target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_PCT, float(GetAmount()), apply);
 
     if (target->GetHealth() > 0)
     {
         uint32 newHealth = std::max<uint32>(target->CountPctFromMaxHealth(int32(percent)), 1);
         target->SetHealth(newHealth);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseMaxHealth	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     float percent = target->GetHealthPct();
 
     target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(GetAmount()), apply);
 
     // refresh percentage
     if (target->GetHealth() > 0)
     {
         uint32 newHealth = std::max<uint32>(target->CountPctFromMaxHealth(int32(percent)), 1);
         target->SetHealth(newHealth);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseMountedSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     HandleAuraModIncreaseSpeed(aurApp, mode, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModIncreaseSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->UpdateSpeed(MOVE_RUN, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleAuraModIncreaseSwimSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->UpdateSpeed(MOVE_SWIM, true);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModPacify	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED);
         target->AttackStop();
     }
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(SPELL_AURA_MOD_PACIFY) || target->HasAuraType(SPELL_AURA_MOD_PACIFY_SILENCE))
             return;
         target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleAuraModPacifyAndSilence	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // Vengeance of the Blue Flight (@todo REMOVE THIS!)
     if (m_spellInfo->Id == 45839)
     {
         if (apply)
             target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
         else
             target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
     }
     if (!(apply))
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(SPELL_AURA_MOD_PACIFY_SILENCE))
             return;
     }
     HandleAuraModPacify(aurApp, mode, apply);
     HandleAuraModSilence(aurApp, mode, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModParryPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     target->ToPlayer()->UpdateParryPercentage();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModPetTalentsPoints	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Recalculate pet talent points
     if (Pet* pet = target->ToPlayer()->GetPet())
         pet->InitTalentForLevel();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModRangedAttackPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if ((target->getClassMask() & CLASSMASK_WAND_USERS) != 0)
         return;
 
     target->HandleStatModifier(UNIT_MOD_ATTACK_POWER_RANGED, TOTAL_VALUE, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModRangedAttackPowerPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if ((target->getClassMask() & CLASSMASK_WAND_USERS) != 0)
         return;
 
     //UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER = multiplier - 1
     target->HandleStatModifier(UNIT_MOD_ATTACK_POWER_RANGED, TOTAL_PCT, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModRangedHaste	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

ToDo: Haste auras with the same handler CAN'T stack together

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplyAttackTimePercentMod(RANGED_ATTACK, (float)GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModRegenInterrupt	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     HandleModManaRegen(aurApp, mode, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModResistance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     for (int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL; x++)
     {
         if (GetMiscValue() & int32(1<<x))
         {
             target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), TOTAL_VALUE, float(GetAmount()), apply);
             if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                 target->ApplyResistanceBuffModsMod(SpellSchools(x), GetAmount() > 0, (float)GetAmount(), apply);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModResistanceExclusive	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     for (int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL; x++)
     {
         if (GetMiscValue() & int32(1<<x))
         {
             int32 amount = target->GetMaxPositiveAuraModifierByMiscMask(SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE, 1<<x, this);
             if (amount < GetAmount())
             {
                 float value = float(GetAmount() - amount);
                 target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), BASE_VALUE, value, apply);
                 if (target->GetTypeId() == TYPEID_PLAYER)
                     target->ApplyResistanceBuffModsMod(SpellSchools(x), aurApp->IsPositive(), value, apply);
             }
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModResistenceOfStatPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (GetMiscValue() != SPELL_SCHOOL_MASK_NORMAL)
     {
         // support required adding replace UpdateArmor by loop by UpdateResistence at intellect update
         // and include in UpdateResistence same code as in UpdateArmor for aura mod apply.
         TC_LOG_ERROR("spells", "Aura SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT(182) does not work for non-armor type resistances!");
         return;
     }
 
     // Recalculate Armor
     target->UpdateArmor();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModRoot	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->SetControlled(apply, UNIT_STATE_ROOT);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModScale	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     float scale = target->GetObjectScale();
     ApplyPercentModFloatVar(scale, float(GetAmount()), apply);
     target->SetObjectScale(scale);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModSchoolImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

Todo:: optimalize this cycle - use RemoveAurasWithInterruptFlags call or something else

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplySpellImmune(GetId(), IMMUNITY_SCHOOL, GetMiscValue(), (apply));
 
     if (GetSpellInfo()->Mechanic == MECHANIC_BANISH)
     {
         if (apply)
             target->AddUnitState(UNIT_STATE_ISOLATED);
         else
         {
             bool banishFound = false;
             Unit::AuraEffectList const& banishAuras = target->GetAuraEffectsByType(GetAuraType());
             for (Unit::AuraEffectList::const_iterator i = banishAuras.begin(); i != banishAuras.end(); ++i)
                 if ((*i)->GetSpellInfo()->Mechanic == MECHANIC_BANISH)
                 {
                     banishFound = true;
                     break;
                 }
             if (!banishFound)
                 target->ClearUnitState(UNIT_STATE_ISOLATED);
         }
     }
 
     if (apply && GetMiscValue() == SPELL_SCHOOL_MASK_NORMAL)
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
 
     // remove all flag auras (they are positive, but they must be removed when you are immune)
     if (GetSpellInfo()->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY
         && GetSpellInfo()->AttributesEx2 & SPELL_ATTR2_DAMAGE_REDUCED_SHIELD)
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
 
     if ((apply)
         && GetSpellInfo()->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY
         && GetSpellInfo()->IsPositive())                       //Only positive immunity removes auras
     {
         uint32 school_mask = GetMiscValue();
         Unit::AuraApplicationMap& Auras = target->GetAppliedAuras();
         for (Unit::AuraApplicationMap::iterator iter = Auras.begin(); iter != Auras.end();)
         {
             SpellInfo const* spell = iter->second->GetBase()->GetSpellInfo();
             if ((spell->GetSchoolMask() & school_mask)//Check for school mask
                 && GetSpellInfo()->CanDispelAura(spell)
                 && !iter->second->IsPositive()          //Don't remove positive spells
                 && spell->Id != GetId())               //Don't remove self
             {
                 target->RemoveAura(iter, AURA_REMOVE_BY_ENEMY_SPELL);
             }
             else
                 ++iter;
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModShapeshift	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     uint32 modelid = 0;
     Powers PowerType = POWER_MANA;
     ShapeshiftForm form = ShapeshiftForm(GetMiscValue());
 
     switch (form)
     {
         case FORM_CAT:                                      // 0x01
         case FORM_GHOUL:                                    // 0x07
             PowerType = POWER_ENERGY;
             break;
 
         case FORM_BEAR:                                     // 0x05
 
         case FORM_BATTLESTANCE:                             // 0x11
         case FORM_DEFENSIVESTANCE:                          // 0x12
         case FORM_BERSERKERSTANCE:                          // 0x13
             PowerType = POWER_RAGE;
             break;
 
         case FORM_TREE:                                     // 0x02
         case FORM_TRAVEL:                                   // 0x03
         case FORM_AQUA:                                     // 0x04
         case FORM_AMBIENT:                                  // 0x06
 
         case FORM_STEVES_GHOUL:                             // 0x09
         case FORM_THARONJA_SKELETON:                        // 0x0A
         case FORM_TEST_OF_STRENGTH:                         // 0x0B
         case FORM_BLB_PLAYER:                               // 0x0C
         case FORM_SHADOW_DANCE:                             // 0x0D
         case FORM_CREATUREBEAR:                             // 0x0E
         case FORM_CREATURECAT:                              // 0x0F
         case FORM_GHOSTWOLF:                                // 0x10
 
         case FORM_TEST:                                     // 0x14
         case FORM_ZOMBIE:                                   // 0x15
         case FORM_METAMORPHOSIS:                            // 0x16
         case FORM_UNDEAD:                                   // 0x19
         case FORM_MASTER_ANGLER:                            // 0x1A
         case FORM_FLIGHT_EPIC:                              // 0x1B
         case FORM_SHADOW:                                   // 0x1C
         case FORM_FLIGHT:                                   // 0x1D
         case FORM_STEALTH:                                  // 0x1E
         case FORM_MOONKIN:                                  // 0x1F
         case FORM_SPIRITOFREDEMPTION:                       // 0x20
             break;
         default:
             TC_LOG_ERROR("spells", "Auras: Unknown Shapeshift Type: %u", GetMiscValue());
     }
 
     modelid = target->GetModelForForm(form);
 
     if (apply)
     {
         // remove polymorph before changing display id to keep new display id
         switch (form)
         {
             case FORM_CAT:
             case FORM_TREE:
             case FORM_TRAVEL:
             case FORM_AQUA:
             case FORM_BEAR:
             case FORM_FLIGHT_EPIC:
             case FORM_FLIGHT:
             case FORM_MOONKIN:
             {
                 // remove movement affects
                 target->RemoveMovementImpairingAuras();
 
                 // and polymorphic affects
                 if (target->IsPolymorphed())
                     target->RemoveAurasDueToSpell(target->getTransForm());
                 break;
             }
             default:
                break;
         }
 
         // remove other shapeshift before applying a new one
         target->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT, ObjectGuid::Empty, GetBase());
 
         // stop handling the effect if it was removed by linked event
         if (aurApp->GetRemoveMode())
             return;
 
         if (PowerType != POWER_MANA)
         {
             int32 oldPower = target->GetPower(PowerType);
             // reset power to default values only at power change
             if (target->getPowerType() != PowerType)
                 target->setPowerType(PowerType);
 
             if (form == FORM_CAT || form == FORM_BEAR)
             {
                 // get furor proc chance
                 int32 FurorChance = 0;
                 if (AuraEffect const* dummy = target->GetDummyAuraEffect(SPELLFAMILY_DRUID, 238, 0))
                     FurorChance = std::max(dummy->GetAmount(), 0);
 
                 if (form == FORM_CAT)
                 {
                     int32 basePoints = std::min<int32>(oldPower, FurorChance);
                     target->SetPower(POWER_ENERGY, 0);
                     target->CastCustomSpell(target, 17099, &basePoints, NULL, NULL, true, NULL, this);
                 }
                 else if (roll_chance_i(FurorChance))
                     target->CastSpell(target, 17057, true);
             }
         }
         // stop handling the effect if it was removed by linked event
         if (aurApp->GetRemoveMode())
             return;
 
         target->SetShapeshiftForm(form);
         if (modelid > 0)
         {
             SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(target->getTransForm());
             if (!transformSpellInfo || !GetSpellInfo()->IsPositive())
                 target->SetDisplayId(modelid);
         }
     }
     else
     {
         // reset model id if no other auras present
         // may happen when aura is applied on linked event on aura removal
         if (!target->HasAuraType(SPELL_AURA_MOD_SHAPESHIFT))
         {
             target->SetShapeshiftForm(FORM_NONE);
             if (target->getClass() == CLASS_DRUID)
             {
                 target->setPowerType(POWER_MANA);
                 // Remove movement impairing effects also when shifting out
                 target->RemoveMovementImpairingAuras();
             }
         }
 
         if (modelid > 0)
             target->RestoreDisplayId();
 
         switch (form)
         {
             // Nordrassil Harness - bonus
             case FORM_BEAR:
             case FORM_CAT:
                 if (AuraEffect* dummy = target->GetAuraEffect(37315, 0))
                     target->CastSpell(target, 37316, true, NULL, dummy);
                 break;
             // Nordrassil Regalia - bonus
             case FORM_MOONKIN:
                 if (AuraEffect* dummy = target->GetAuraEffect(37324, 0))
                     target->CastSpell(target, 37325, true, NULL, dummy);
                 break;
             case FORM_BATTLESTANCE:
             case FORM_DEFENSIVESTANCE:
             case FORM_BERSERKERSTANCE:
             {
                 int32 Rage_val = 0;
                 // Defensive Tactics
                 if (form == FORM_DEFENSIVESTANCE)
                 {
                     if (AuraEffect const* aurEff = target->IsScriptOverriden(m_spellInfo, 831))
                         Rage_val += aurEff->GetAmount() * 10;
                 }
                 // Stance mastery + Tactical mastery (both passive, and last have aura only in defense stance, but need apply at any stance switch)
                 if (target->GetTypeId() == TYPEID_PLAYER)
                 {
                     PlayerSpellMap const& sp_list = target->ToPlayer()->GetSpellMap();
                     for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
                     {
                         if (itr->second->state == PLAYERSPELL_REMOVED || itr->second->disabled)
                             continue;
 
                         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first);
                         if (spellInfo && spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR && spellInfo->SpellIconID == 139)
                             Rage_val += target->CalculateSpellDamage(target, spellInfo, 0) * 10;
                     }
                 }
                 if (target->GetPower(POWER_RAGE) > Rage_val)
                     target->SetPower(POWER_RAGE, Rage_val);
                 break;
             }
             default:
                 break;
         }
     }
 
     // adding/removing linked auras
     // add/remove the shapeshift aura's boosts
     HandleShapeshiftBoosts(target, apply);
 
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->InitDataForForm();
 
     if (target->getClass() == CLASS_DRUID)
     {
         // Dash
         if (AuraEffect* aurEff = target->GetAuraEffect(SPELL_AURA_MOD_INCREASE_SPEED, SPELLFAMILY_DRUID, flag128(0, 0, 0x8)))
             aurEff->RecalculateAmount();
 
         // Disarm handling
         // If druid shifts while being disarmed we need to deal with that since forms aren't affected by disarm
         // and also HandleAuraModDisarm is not triggered
         if (!target->CanUseAttackType(BASE_ATTACK))
         {
             if (Item* pItem = target->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND))
                 target->ToPlayer()->_ApplyWeaponDamage(EQUIPMENT_SLOT_MAINHAND, pItem, apply);
         }
     }
 
     // stop handling the effect if it was removed by linked event
     if (apply && aurApp->GetRemoveMode())
         return;
 
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         SpellShapeshiftFormEntry const* shapeInfo = sSpellShapeshiftFormStore.LookupEntry(form);
         ASSERT(shapeInfo);
         // Learn spells for shapeshift form - no need to send action bars or add spells to spellbook
         for (uint8 i = 0; i < MAX_SHAPESHIFT_SPELLS; ++i)
         {
             if (!shapeInfo->PresetSpellID[i])
                 continue;
             if (apply)
                 target->ToPlayer()->AddTemporarySpell(shapeInfo->PresetSpellID[i]);
             else
                 target->ToPlayer()->RemoveTemporarySpell(shapeInfo->PresetSpellID[i]);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModSilence	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED);
 
         // call functions which may have additional effects after chainging state of unit
         // Stop cast only spells vs PreventionType == SPELL_PREVENTION_TYPE_SILENCE
         for (uint32 i = CURRENT_MELEE_SPELL; i < CURRENT_MAX_SPELL; ++i)
             if (Spell* spell = target->GetCurrentSpell(CurrentSpellTypes(i)))
                 if (spell->m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
                     // Stop spells on prepare or casting state
                     target->InterruptSpell(CurrentSpellTypes(i), false);
     }
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(SPELL_AURA_MOD_SILENCE) || target->HasAuraType(SPELL_AURA_MOD_PACIFY_SILENCE))
             return;
 
         target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleAuraModSkill	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_SKILL)))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
     if (!target)
         return;
 
     uint32 prot = GetMiscValue();
     int32 points = GetAmount();
 
     if (prot == SKILL_DEFENSE)
         return;
 
     target->ModifySkillBonus(prot, (apply ? points : -points), GetAuraType() == SPELL_AURA_MOD_SKILL_TALENT);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModStalked	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // used by spells: Hunter's Mark, Mind Vision, Syndicate Tracker (MURP) DND
     if (apply)
         target->SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (!target->HasAuraType(GetAuraType()))
             target->RemoveFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
     }
 
     // call functions which may have additional effects after chainging state of unit
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     if (GetMiscValue() < -2 || GetMiscValue() > 4)
     {
         TC_LOG_ERROR("spells", "WARNING: Spell %u effect %u has an unsupported misc value (%i) for SPELL_AURA_MOD_STAT ", GetId(), GetEffIndex(), GetMiscValue());
         return;
     }
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_STAT, true, GetMiscValue());
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     for (int32 i = STAT_STRENGTH; i < MAX_STATS; i++)
     {
         // -1 or -2 is all stats (misc < -2 checked in function beginning)
         if (GetMiscValue() < 0 || GetMiscValue() == i)
         {
             if (spellGroupVal)
             {
                 target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_VALUE, float(spellGroupVal), !apply);
                 if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                     target->ApplyStatBuffMod(Stats(i), float(spellGroupVal), !apply);
             }
 
             //target->ApplyStatMod(Stats(i), m_amount, apply);
             target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_VALUE, float(GetAmount()), apply);
             if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                 target->ApplyStatBuffMod(Stats(i), (float)GetAmount(), apply);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModStateImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplySpellImmune(GetId(), IMMUNITY_STATE, GetMiscValue(), apply);
 
     if (apply && GetSpellInfo()->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)
         target->RemoveAurasByType(AuraType(GetMiscValue()), ObjectGuid::Empty, GetBase());
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModStun	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->SetControlled(apply, UNIT_STATE_STUNNED);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModTotalThreat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!target->IsAlive() || target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Unit* caster = GetCaster();
     if (caster && caster->IsAlive())
         target->getHostileRefManager().addTempThreat((float)GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModUseNormalSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->UpdateSpeed(MOVE_RUN,  true);
     target->UpdateSpeed(MOVE_SWIM, true);
     target->UpdateSpeed(MOVE_FLIGHT,  true);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraModWeaponCritPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     for (int i = 0; i < MAX_ATTACK; ++i)
         if (Item* pItem = target->ToPlayer()->GetWeaponForAttack(WeaponAttackType(i), true))
             target->ToPlayer()->_ApplyWeaponDependentAuraCritMod(pItem, WeaponAttackType(i), this, apply);
 
     // mods must be applied base at equipped weapon class and subclass comparison
     // with spell->EquippedItemClass and  EquippedItemSubClassMask and EquippedItemInventoryTypeMask
     // GetMiscValue() comparison with item generated damage types
 
     if (GetSpellInfo()->EquippedItemClass == -1)
     {
         target->ToPlayer()->HandleBaseModValue(CRIT_PERCENTAGE,         FLAT_MOD, float (GetAmount()), apply);
         target->ToPlayer()->HandleBaseModValue(OFFHAND_CRIT_PERCENTAGE, FLAT_MOD, float (GetAmount()), apply);
         target->ToPlayer()->HandleBaseModValue(RANGED_CRIT_PERCENTAGE,  FLAT_MOD, float (GetAmount()), apply);
     }
     else
     {
         // done in Player::_ApplyWeaponDependentAuraMods
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraMounted	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         uint32 creatureEntry = GetMiscValue();
         uint32 displayId = 0;
         uint32 vehicleId = 0;
 
         if (MountEntry const* mountEntry = sDB2Manager.GetMount(GetId()))
         {
             displayId = mountEntry->DisplayId;
             // TODO: CREATE TABLE mount_vehicle (mountId, vehicleCreatureId) for future mounts that are vehicles (new mounts no longer have proper data in MiscValue)
             //if (MountVehicle const* mountVehicle = sObjectMgr->GetMountVehicle(mountEntry->Id))
             //    creatureEntry = mountVehicle->VehicleCreatureId;
         }
 
         if (CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(creatureEntry))
         {
             vehicleId = creatureInfo->VehicleId;
 
             if (!displayId || vehicleId)
             {
                 displayId = ObjectMgr::ChooseDisplayId(creatureInfo);
                 sObjectMgr->GetCreatureModelRandomGender(&displayId);
             }
 
             //some spell has one aura of mount and one of vehicle
             for (SpellEffectInfo const* effect : GetBase()->GetSpellEffectInfos())
                 if (effect && effect->Effect == SPELL_EFFECT_SUMMON && effect->MiscValue == GetMiscValue())
                     displayId = 0;
         }
 
         target->Mount(displayId, vehicleId, creatureEntry);
 
         // cast speed aura
         if (mode & AURA_EFFECT_HANDLE_REAL)
             if (MountCapabilityEntry const* mountCapability = sMountCapabilityStore.LookupEntry(GetAmount()))
                 target->CastSpell(target, mountCapability->SpeedModSpell, true);
     }
     else
     {
         target->Dismount();
         //some mounts like Headless Horseman's Mount or broom stick are skill based spell
         // need to remove ALL arura related to mounts, this will stop client crash with broom stick
         // and never endless flying after using Headless Horseman's Mount
         if (mode & AURA_EFFECT_HANDLE_REAL)
         {
             target->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
             // remove speed aura
             if (MountCapabilityEntry const* mountCapability = sMountCapabilityStore.LookupEntry(GetAmount()))
                 target->RemoveAurasDueToSpell(mountCapability->SpeedModSpell, target->GetGUID());
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraOpenStable	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER || !target->IsInWorld())
         return;
 
     if (apply)
         target->ToPlayer()->GetSession()->SendStablePet(target->GetGUID());
 
      // client auto close stable dialog at !apply aura
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraOverrideSpells	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
 
     if (!target || !target->IsInWorld())
         return;
 
     uint32 overrideId = uint32(GetMiscValue());
 
     if (apply)
     {
         target->SetUInt16Value(PLAYER_FIELD_BYTES2, PLAYER_BYTES_2_OVERRIDE_SPELLS_UINT16_OFFSET, overrideId);
         if (OverrideSpellDataEntry const* overrideSpells = sOverrideSpellDataStore.LookupEntry(overrideId))
             for (uint8 i = 0; i < MAX_OVERRIDE_SPELL; ++i)
                 if (uint32 spellId = overrideSpells->SpellID[i])
                     target->AddTemporarySpell(spellId);
     }
     else
     {
         target->SetUInt16Value(PLAYER_FIELD_BYTES2, PLAYER_BYTES_2_OVERRIDE_SPELLS_UINT16_OFFSET, 0);
         if (OverrideSpellDataEntry const* overrideSpells = sOverrideSpellDataStore.LookupEntry(overrideId))
             for (uint8 i = 0; i < MAX_OVERRIDE_SPELL; ++i)
                 if (uint32 spellId = overrideSpells->SpellID[i])
                     target->RemoveTemporarySpell(spellId);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraRetainComboPoints	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // combo points was added in SPELL_EFFECT_ADD_COMBO_POINTS handler
     // remove only if aura expire by time (in case combo points amount change aura removed without combo points lost)
     if (!apply && aurApp->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
         target->ToPlayer()->AddComboPoints(-GetAmount());
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraSetVehicle	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!target->IsInWorld())
         return;
 
     uint32 vehicleId = GetMiscValue();
 
     if (apply)
     {
         if (!target->CreateVehicleKit(vehicleId, 0))
             return;
     }
     else if (target->GetVehicleKit())
         target->RemoveVehicleKit();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (apply)
         target->ToPlayer()->SendOnCancelExpectedVehicleRideAura();
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraTrackCreatures	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (apply)
         target->SetFlag(PLAYER_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
     else
         target->RemoveFlag(PLAYER_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraTrackResources	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (apply)
         target->SetFlag(PLAYER_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
     else
         target->RemoveFlag(PLAYER_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraTrackStealthed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (!(apply))
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
     }
     target->ApplyModFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_TRACK_STEALTHED, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraTransform	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         // update active transform spell only when transform not set or not overwriting negative by positive case
         SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(target->getTransForm());
         if (!transformSpellInfo || !GetSpellInfo()->IsPositive() || transformSpellInfo->IsPositive())
         {
             target->setTransForm(GetId());
             // special case (spell specific functionality)
             if (GetMiscValue() == 0)
             {
                 switch (GetId())
                 {
                     // Orb of Deception
                     case 16739:
                     {
                         if (target->GetTypeId() != TYPEID_PLAYER)
                             return;
 
                         switch (target->getRace())
                         {
                             // Blood Elf
                             case RACE_BLOODELF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 17830 : 17829);
                                 break;
                             // Orc
                             case RACE_ORC:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10140 : 10139);
                                 break;
                             // Troll
                             case RACE_TROLL:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10134 : 10135);
                                 break;
                             // Tauren
                             case RACE_TAUREN:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10147 : 10136);
                                 break;
                             // Undead
                             case RACE_UNDEAD_PLAYER:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10145 : 10146);
                                 break;
                             // Draenei
                             case RACE_DRAENEI:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 17828 : 17827);
                                 break;
                             // Dwarf
                             case RACE_DWARF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10142 : 10141);
                                 break;
                             // Gnome
                             case RACE_GNOME:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10149 : 10148);
                                 break;
                             // Human
                             case RACE_HUMAN:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10138 : 10137);
                                 break;
                             // Night Elf
                             case RACE_NIGHTELF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 10144 : 10143);
                                 break;
                             default:
                                 break;
                         }
                         break;
                     }
                     // Murloc costume
                     case 42365:
                         target->SetDisplayId(21723);
                         break;
                     // Dread Corsair
                     case 50517:
                     // Corsair Costume
                     case 51926:
                     {
                         if (target->GetTypeId() != TYPEID_PLAYER)
                             return;
 
                         switch (target->getRace())
                         {
                             // Blood Elf
                             case RACE_BLOODELF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25043 : 25032);
                                 break;
                             // Orc
                             case RACE_ORC:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25050 : 25039);
                                 break;
                             // Troll
                             case RACE_TROLL:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25052 : 25041);
                                 break;
                             // Tauren
                             case RACE_TAUREN:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25051 : 25040);
                                 break;
                             // Undead
                             case RACE_UNDEAD_PLAYER:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25053 : 25042);
                                 break;
                             // Draenei
                             case RACE_DRAENEI:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25044 : 25033);
                                 break;
                             // Dwarf
                             case RACE_DWARF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25045 : 25034);
                                 break;
                             // Gnome
                             case RACE_GNOME:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25035 : 25046);
                                 break;
                             // Human
                             case RACE_HUMAN:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25037 : 25048);
                                 break;
                             // Night Elf
                             case RACE_NIGHTELF:
                                 target->SetDisplayId(target->getGender() == GENDER_FEMALE ? 25038 : 25049);
                                 break;
                             default:
                                 break;
                         }
                         break;
                     }
                     // Pygmy Oil
                     case 53806:
                         target->SetDisplayId(22512);
                         break;
                     // Honor the Dead
                     case 65386:
                     case 65495:
                         target->SetDisplayId(target->getGender() == GENDER_MALE ? 29203 : 29204);
                         break;
                     // Darkspear Pride
                     case 75532:
                         target->SetDisplayId(target->getGender() == GENDER_MALE ? 31737 : 31738);
                         break;
                     // Gnomeregan Pride
                     case 75531:
                         target->SetDisplayId(target->getGender() == GENDER_MALE ? 31654 : 31655);
                         break;
                     default:
                         break;
                 }
             }
             else
             {
                 CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(GetMiscValue());
                 if (!ci)
                 {
                     target->SetDisplayId(16358);              // pig pink ^_^
                     TC_LOG_ERROR("spells", "Auras: unknown creature id = %d (only need its modelid) From Spell Aura Transform in Spell ID = %d", GetMiscValue(), GetId());
                 }
                 else
                 {
                     uint32 model_id = 0;
 
                     if (uint32 modelid = ci->GetRandomValidModelId())
                         model_id = modelid;                     // Will use the default model here
 
                     target->SetDisplayId(model_id);
 
                     // Dragonmaw Illusion (set mount model also)
                     if (GetId() == 42016 && target->GetMountID() && !target->GetAuraEffectsByType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED).empty())
                         target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 16314);
                 }
             }
         }
 
         // polymorph case
         if ((mode & AURA_EFFECT_HANDLE_REAL) && target->GetTypeId() == TYPEID_PLAYER && target->IsPolymorphed())
         {
             // for players, start regeneration after 1s (in polymorph fast regeneration case)
             // only if caster is Player (after patch 2.4.2)
             if (GetCasterGUID().IsPlayer())
                 target->ToPlayer()->setRegenTimerCount(1*IN_MILLISECONDS);
 
             //dismount polymorphed target (after patch 2.4.2)
             if (target->IsMounted())
                 target->RemoveAurasByType(SPELL_AURA_MOUNTED);
         }
     }
     else
     {
         // HandleEffect(this, AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true) will reapply it if need
         if (target->getTransForm() == GetId())
             target->setTransForm(0);
 
         target->RestoreDisplayId();
 
         // Dragonmaw Illusion (restore mount model)
         if (GetId() == 42016 && target->GetMountID() == 16314)
         {
             if (!target->GetAuraEffectsByType(SPELL_AURA_MOUNTED).empty())
             {
                 uint32 cr_id = target->GetAuraEffectsByType(SPELL_AURA_MOUNTED).front()->GetMiscValue();
                 if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(cr_id))
                 {
                     uint32 displayID = ObjectMgr::ChooseDisplayId(ci);
                     sObjectMgr->GetCreatureModelRandomGender(&displayID);
 
                     target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, displayID);
                 }
             }
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraUntrackable	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
         target->SetByteFlag(UNIT_FIELD_BYTES_1, 2, UNIT_STAND_FLAGS_UNTRACKABLE);
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
         target->RemoveByteFlag(UNIT_FIELD_BYTES_1, 2, UNIT_STAND_FLAGS_UNTRACKABLE);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleAuraWaterWalk	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!apply)
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
     }
 
     target->SetWaterWalking(apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleBindSight	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Unit* caster = GetCaster();
 
     if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     caster->ToPlayer()->SetViewpoint(target, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleChannelDeathItem	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     if (apply || aurApp->GetRemoveMode() != AURA_REMOVE_BY_DEATH)
         return;
 
     Unit* caster = GetCaster();
 
     if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* plCaster = caster->ToPlayer();
     Unit* target = aurApp->GetTarget();
 
     // Item amount
     if (GetAmount() <= 0)
         return;
 
     if (GetSpellEffectInfo()->ItemType == 0)
         return;
 
     // Soul Shard
     if (GetSpellEffectInfo()->ItemType == 6265)
     {
         // Soul Shard only from units that grant XP or honor
         if (!plCaster->isHonorOrXPTarget(target) ||
             (target->GetTypeId() == TYPEID_UNIT && !target->ToCreature()->isTappedBy(plCaster)))
             return;
     }
 
     //Adding items
     uint32 noSpaceForCount = 0;
     uint32 count = m_amount;
 
     ItemPosCountVec dest;
     InventoryResult msg = plCaster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, GetSpellEffectInfo()->ItemType, count, &noSpaceForCount);
     if (msg != EQUIP_ERR_OK)
     {
         count-=noSpaceForCount;
         plCaster->SendEquipError(msg, NULL, NULL, GetSpellEffectInfo()->ItemType);
         if (count == 0)
             return;
     }
 
     Item* newitem = plCaster->StoreNewItem(dest, GetSpellEffectInfo()->ItemType, true);
     if (!newitem)
     {
         plCaster->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
         return;
     }
     plCaster->SendNewItem(newitem, count, true, true);
 }

Here is the call graph for this function:

void AuraEffect::HandleCharmConvert	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Unit* caster = GetCaster();
 
     if (apply)
         target->SetCharmedBy(caster, CHARM_TYPE_CONVERT, aurApp);
     else
         target->RemoveCharmedBy(caster);
 }

Here is the call graph for this function:

void AuraEffect::HandleComprehendLanguage	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
         target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_COMPREHEND_LANG);
     else
     {
         if (target->HasAuraType(GetAuraType()))
             return;
 
         target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_COMPREHEND_LANG);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleEffect	(	AuraApplication *	aurApp,
		uint8	mode,
		bool	apply
	)

 {
     // check if call is correct, we really don't want using bitmasks here (with 1 exception)
     ASSERT(mode == AURA_EFFECT_HANDLE_REAL
         || mode == AURA_EFFECT_HANDLE_SEND_FOR_CLIENT
         || mode == AURA_EFFECT_HANDLE_CHANGE_AMOUNT
         || mode == AURA_EFFECT_HANDLE_STAT
         || mode == AURA_EFFECT_HANDLE_SKILL
         || mode == AURA_EFFECT_HANDLE_REAPPLY
         || mode == (AURA_EFFECT_HANDLE_CHANGE_AMOUNT | AURA_EFFECT_HANDLE_REAPPLY));
 
     // register/unregister effect in lists in case of real AuraEffect apply/remove
     // registration/unregistration is done always before real effect handling (some effect handlers code is depending on this)
     if (mode & AURA_EFFECT_HANDLE_REAL)
         aurApp->GetTarget()->_RegisterAuraEffect(this, apply);
 
     // real aura apply/remove, handle modifier
     if (mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK)
         ApplySpellMod(aurApp->GetTarget(), apply);
 
     // call scripts helping/replacing effect handlers
     bool prevented = false;
     if (apply)
         prevented = GetBase()->CallScriptEffectApplyHandlers(this, aurApp, (AuraEffectHandleModes)mode);
     else
         prevented = GetBase()->CallScriptEffectRemoveHandlers(this, aurApp, (AuraEffectHandleModes)mode);
 
     // check if script events have removed the aura or if default effect prevention was requested
     if ((apply && aurApp->GetRemoveMode()) || prevented)
         return;
 
     (*this.*AuraEffectHandler[GetAuraType()])(aurApp, mode, apply);
 
     // check if script events have removed the aura or if default effect prevention was requested
     if (apply && aurApp->GetRemoveMode())
         return;
 
     // call scripts triggering additional events after apply/remove
     if (apply)
         GetBase()->CallScriptAfterEffectApplyHandlers(this, aurApp, (AuraEffectHandleModes)mode);
     else
         GetBase()->CallScriptAfterEffectRemoveHandlers(this, aurApp, (AuraEffectHandleModes)mode);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleEffect	(	Unit *	target,
		uint8	mode,
		bool	apply
	)

 {
     AuraApplication* aurApp = GetBase()->GetApplicationOfTarget(target->GetGUID());
     ASSERT(aurApp);
     HandleEffect(aurApp, mode, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleEnableAltPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     uint32 altPowerId = GetMiscValue();
     UnitPowerBarEntry const* powerEntry = sUnitPowerBarStore.LookupEntry(altPowerId);
     if (!powerEntry)
         return;
 
     if (apply)
         aurApp->GetTarget()->SetMaxPower(POWER_ALTERNATE_POWER, powerEntry->MaxPower);
     else
         aurApp->GetTarget()->SetMaxPower(POWER_ALTERNATE_POWER, 0);
 }

Here is the call graph for this function:

void AuraEffect::HandleFeignDeath	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
     {
         /*
         WorldPacket data(SMSG_FEIGN_DEATH_RESISTED, 0);
         target->SendMessageToSet(&data, true);
         */
 
         UnitList targets;
         Trinity::AnyUnfriendlyUnitInObjectRangeCheck u_check(target, target, target->GetMap()->GetVisibilityRange());
         Trinity::UnitListSearcher<Trinity::AnyUnfriendlyUnitInObjectRangeCheck> searcher(target, targets, u_check);
         target->VisitNearbyObject(target->GetMap()->GetVisibilityRange(), searcher);
         for (UnitList::iterator iter = targets.begin(); iter != targets.end(); ++iter)
         {
             if (!(*iter)->HasUnitState(UNIT_STATE_CASTING))
                 continue;
 
             for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
             {
                 if ((*iter)->GetCurrentSpell(i)
                 && (*iter)->GetCurrentSpell(i)->m_targets.GetUnitTargetGUID() == target->GetGUID())
                 {
                     (*iter)->InterruptSpell(CurrentSpellTypes(i), false);
                 }
             }
         }
         target->CombatStop();
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
 
         // prevent interrupt message
         if (GetCasterGUID() == target->GetGUID() && target->GetCurrentSpell(CURRENT_GENERIC_SPELL))
             target->FinishSpell(CURRENT_GENERIC_SPELL, false);
         target->InterruptNonMeleeSpells(true);
         target->getHostileRefManager().deleteReferences();
 
         // stop handling the effect if it was removed by linked event
         if (aurApp->GetRemoveMode())
             return;
 
         target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_29);            // blizz like 2.0.x
         target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FEIGN_DEATH);    // blizz like 2.0.x
         target->SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);         // blizz like 2.0.x
         target->AddUnitState(UNIT_STATE_DIED);
 
         if (Creature* creature = target->ToCreature())
             creature->SetReactState(REACT_PASSIVE);
     }
     else
     {
         /*
         WorldPacket data(SMSG_FEIGN_DEATH_RESISTED, 0);
         target->SendMessageToSet(&data, true);
         */
 
         target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_29);         // blizz like 2.0.x
         target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FEIGN_DEATH); // blizz like 2.0.x
         target->RemoveFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);      // blizz like 2.0.x
         target->ClearUnitState(UNIT_STATE_DIED);
 
         if (Creature* creature = target->ToCreature())
             creature->InitializeReactState();
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleForceMoveForward	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (apply)
         target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVEMENT);
     else
     {
         // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
         if (target->HasAuraType(GetAuraType()))
             return;
         target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVEMENT);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleForceReaction	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Player* player = target->ToPlayer();
     if (!player)
         return;
 
     uint32 factionId = GetMiscValue();
     ReputationRank factionRank = ReputationRank(m_amount);
 
     player->GetReputationMgr().ApplyForceReaction(factionId, factionRank, apply);
     player->GetReputationMgr().SendForceReactions();
 
     // stop fighting if at apply forced rank friendly or at remove real rank friendly
     if ((apply && factionRank >= REP_FRIENDLY) || (!apply && player->GetReputationRank(factionId) >= REP_FRIENDLY))
         player->StopAttackFaction(factionId);
 }

Here is the call graph for this function:

void AuraEffect::HandleMastery	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
     if (!target)
         return;
 
     target->UpdateMastery();
 }

Here is the call graph for this function:

void AuraEffect::HandleModAttackSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplyAttackTimePercentMod(BASE_ATTACK, float(GetAmount()), apply);
     target->UpdateDamagePhysical(BASE_ATTACK);
 }

Here is the call graph for this function:

void AuraEffect::HandleModBaseResistance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // only players have base stats
     if (target->GetTypeId() != TYPEID_PLAYER)
     {
         //only pets have base stats
         if (target->IsPet() && (GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL))
             target->HandleStatModifier(UNIT_MOD_ARMOR, TOTAL_VALUE, float(GetAmount()), apply);
     }
     else
     {
         for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; i++)
             if (GetMiscValue() & (1<<i))
                 target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_VALUE, float(GetAmount()), apply);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModCastingSpeed	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplyCastTimePercentMod((float)GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModCharm	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Unit* caster = GetCaster();
 
     if (apply)
         target->SetCharmedBy(caster, CHARM_TYPE_CHARM, aurApp);
     else
         target->RemoveCharmedBy(caster);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleModCombatSpeedPct	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MELEE_SLOW);
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     if (spellGroupVal)
     {
         target->ApplyCastTimePercentMod(float(spellGroupVal), !apply);
         target->ApplyAttackTimePercentMod(BASE_ATTACK, float(spellGroupVal), !apply);
         target->ApplyAttackTimePercentMod(OFF_ATTACK, float(spellGroupVal), !apply);
         target->ApplyAttackTimePercentMod(RANGED_ATTACK, float(spellGroupVal), !apply);
     }
     target->ApplyCastTimePercentMod(float(m_amount), apply);
     target->ApplyAttackTimePercentMod(BASE_ATTACK, float(GetAmount()), apply);
     target->ApplyAttackTimePercentMod(OFF_ATTACK, float(GetAmount()), apply);
     target->ApplyAttackTimePercentMod(RANGED_ATTACK, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModConfuse	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->SetControlled(apply, UNIT_STATE_CONFUSED);
 }

Here is the call graph for this function:

void AuraEffect::HandleModDamageDone	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // apply item specific bonuses for already equipped weapon
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         for (int i = 0; i < MAX_ATTACK; ++i)
             if (Item* pItem = target->ToPlayer()->GetWeaponForAttack(WeaponAttackType(i), true))
                 target->ToPlayer()->_ApplyWeaponDependentAuraDamageMod(pItem, WeaponAttackType(i), this, apply);
     }
 
     // GetMiscValue() is bitmask of spell schools
     // 1 (0-bit) - normal school damage (SPELL_SCHOOL_MASK_NORMAL)
     // 126 - full bitmask all magic damages (SPELL_SCHOOL_MASK_MAGIC) including wands
     // 127 - full bitmask any damages
     //
     // mods must be applied base at equipped weapon class and subclass comparison
     // with spell->EquippedItemClass and  EquippedItemSubClassMask and EquippedItemInventoryTypeMask
     // GetMiscValue() comparison with item generated damage types
 
     if ((GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL) != 0)
     {
         // apply generic physical damage bonuses including wand case
         if (GetSpellInfo()->EquippedItemClass == -1 || target->GetTypeId() != TYPEID_PLAYER)
         {
             target->HandleStatModifier(UNIT_MOD_DAMAGE_MAINHAND, TOTAL_VALUE, float(GetAmount()), apply);
             target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_VALUE, float(GetAmount()), apply);
             target->HandleStatModifier(UNIT_MOD_DAMAGE_RANGED, TOTAL_VALUE, float(GetAmount()), apply);
 
             if (target->GetTypeId() == TYPEID_PLAYER)
             {
                 if (GetAmount() > 0)
                     target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS, GetAmount(), apply);
                 else
                     target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG, GetAmount(), apply);
             }
         }
         else
         {
             // done in Player::_ApplyWeaponDependentAuraMods
         }
     }
 
     // Skip non magic case for speedup
     if ((GetMiscValue() & SPELL_SCHOOL_MASK_MAGIC) == 0)
         return;
 
     if (GetSpellInfo()->EquippedItemClass != -1 || GetSpellInfo()->EquippedItemInventoryTypeMask != 0)
     {
         // wand magic case (skip generic to all item spell bonuses)
         // done in Player::_ApplyWeaponDependentAuraMods
 
         // Skip item specific requirements for not wand magic damage
         return;
     }
 
     // Magic damage modifiers implemented in Unit::SpellDamageBonus
     // This information for client side use only
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         if (GetAmount() > 0)
         {
             for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; i++)
             {
                 if ((GetMiscValue() & (1<<i)) != 0)
                     target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+i, GetAmount(), apply);
             }
         }
         else
         {
             for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; i++)
             {
                 if ((GetMiscValue() & (1<<i)) != 0)
                     target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+i, GetAmount(), apply);
             }
         }
         if (Guardian* pet = target->ToPlayer()->GetGuardianPet())
             pet->UpdateAttackPowerAndDamage();
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModDamagePercentDone	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         for (int i = 0; i < MAX_ATTACK; ++i)
             if (Item* item = target->ToPlayer()->GetWeaponForAttack(WeaponAttackType(i), false))
                 target->ToPlayer()->_ApplyWeaponDependentAuraDamageMod(item, WeaponAttackType(i), this, apply);
     }
 
     if ((GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL) && (GetSpellInfo()->EquippedItemClass == -1 || target->GetTypeId() != TYPEID_PLAYER))
     {
         if (spellGroupVal)
         {
             target->HandleStatModifier(UNIT_MOD_DAMAGE_MAINHAND, TOTAL_PCT, float(spellGroupVal), !apply);
             target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_PCT, float(spellGroupVal), !apply);
             target->HandleStatModifier(UNIT_MOD_DAMAGE_RANGED, TOTAL_PCT, float(spellGroupVal), !apply);
         }
         target->HandleStatModifier(UNIT_MOD_DAMAGE_MAINHAND, TOTAL_PCT, float(GetAmount()), apply);
         target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND,  TOTAL_PCT, float(GetAmount()), apply);
         target->HandleStatModifier(UNIT_MOD_DAMAGE_RANGED,   TOTAL_PCT, float(GetAmount()), apply);
 
         if (Player* player = target->ToPlayer())
         {
             if (spellGroupVal)
                 player->ApplyPercentModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT, float(spellGroupVal), !apply);
 
             player->ApplyPercentModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT, float(GetAmount()), apply);
         }
     }
     else
     {
         // done in Player::_ApplyWeaponDependentAuraMods for SPELL_SCHOOL_MASK_NORMAL && EquippedItemClass != -1 and also for wand case
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModFear	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->SetControlled(apply, UNIT_STATE_FLEEING);
 }

Here is the call graph for this function:

void AuraEffect::HandleModHealingDone	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
     // implemented in Unit::SpellHealingBonus
     // this information is for client side only
     target->ToPlayer()->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandleModHitChance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
         target->ToPlayer()->UpdateMeleeHitChances();
         target->ToPlayer()->UpdateRangedHitChances();
     }
     else
     {
         target->m_modMeleeHitChance += (apply) ? GetAmount() : (-GetAmount());
         target->m_modRangedHitChance += (apply) ? GetAmount() : (-GetAmount());
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModInvisibility	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     InvisibilityType type = InvisibilityType(GetMiscValue());
 
     if (apply)
     {
         // apply glow vision
         if (target->GetTypeId() == TYPEID_PLAYER)
             target->SetByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
 
         target->m_invisibility.AddFlag(type);
         target->m_invisibility.AddValue(type, GetAmount());
     }
     else
     {
         if (!target->HasAuraType(SPELL_AURA_MOD_INVISIBILITY))
         {
             // if not have different invisibility auras.
             // remove glow vision
             if (target->GetTypeId() == TYPEID_PLAYER)
                 target->RemoveByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
 
             target->m_invisibility.DelFlag(type);
         }
         else
         {
             bool found = false;
             Unit::AuraEffectList const& invisAuras = target->GetAuraEffectsByType(SPELL_AURA_MOD_INVISIBILITY);
             for (Unit::AuraEffectList::const_iterator i = invisAuras.begin(); i != invisAuras.end(); ++i)
             {
                 if (GetMiscValue() == (*i)->GetMiscValue())
                 {
                     found = true;
                     break;
                 }
             }
             if (!found)
                 target->m_invisibility.DelFlag(type);
         }
 
         target->m_invisibility.AddValue(type, -GetAmount());
     }
 
     // call functions which may have additional effects after chainging state of unit
     if (apply && (mode & AURA_EFFECT_HANDLE_REAL))
     {
         // drop flag at invisibiliy in bg
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
     }
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleModInvisibilityDetect	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     InvisibilityType type = InvisibilityType(GetMiscValue());
 
     if (apply)
     {
         target->m_invisibilityDetect.AddFlag(type);
         target->m_invisibilityDetect.AddValue(type, GetAmount());
     }
     else
     {
         if (!target->HasAuraType(SPELL_AURA_MOD_INVISIBILITY_DETECT))
             target->m_invisibilityDetect.DelFlag(type);
 
         target->m_invisibilityDetect.AddValue(type, -GetAmount());
     }
 
     // call functions which may have additional effects after chainging state of unit
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleModManaRegen	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     //Note: an increase in regen does NOT cause threat.
     target->ToPlayer()->UpdateManaRegen();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleModMechanicImmunity	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
     uint32 mechanic;
 
     switch (GetId())
     {
         case 34471: // The Beast Within
         case 19574: // Bestial Wrath
             mechanic = IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_KNOCKOUT, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_BANISH, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SHACKLE, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DAZE, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
             break;
         case 42292: // PvP trinket
         case 59752: // Every Man for Himself
             mechanic = IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
             // Actually we should apply immunities here, too, but the aura has only 100 ms duration, so there is practically no point
             break;
         case 54508: // Demonic Empowerment
             mechanic = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
             break;
         default:
             if (GetMiscValue() < 1)
                 return;
             mechanic = 1 << GetMiscValue();
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, GetMiscValue(), apply);
             break;
     }
 
     if (apply && GetSpellInfo()->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)
         target->RemoveAurasWithMechanic(mechanic, AURA_REMOVE_BY_DEFAULT, GetId());
 }

Here is the call graph for this function:

void AuraEffect::HandleModMeleeRangedSpeedPct	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

ToDo: Haste auras with the same handler CAN'T stack together

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->ApplyAttackTimePercentMod(BASE_ATTACK, (float)GetAmount(), apply);
     target->ApplyAttackTimePercentMod(OFF_ATTACK, (float)GetAmount(), apply);
     target->ApplyAttackTimePercentMod(RANGED_ATTACK, (float)GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModMeleeSpeedPct	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

ToDo: Haste auras with the same handler CAN'T stack together

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_MELEE_HASTE);
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     if (spellGroupVal)
     {
         target->ApplyAttackTimePercentMod(BASE_ATTACK, float(spellGroupVal), !apply);
         target->ApplyAttackTimePercentMod(OFF_ATTACK, float(spellGroupVal), !apply);
     }
     target->ApplyAttackTimePercentMod(BASE_ATTACK, float(GetAmount()), apply);
     target->ApplyAttackTimePercentMod(OFF_ATTACK,  float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModOffhandDamagePercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_PCT, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModPercentStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (GetMiscValue() < -1 || GetMiscValue() > 4)
     {
         TC_LOG_ERROR("spells", "WARNING: Misc Value for SPELL_AURA_MOD_PERCENT_STAT not valid");
         return;
     }
 
     // only players have base stats
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     for (int32 i = STAT_STRENGTH; i < MAX_STATS; ++i)
     {
         if (GetMiscValue() == i || GetMiscValue() == -1)
             target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), BASE_PCT, float(m_amount), apply);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModPossess	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     Unit* caster = GetCaster();
 
     // no support for posession AI yet
     if (caster && caster->GetTypeId() == TYPEID_UNIT)
     {
         HandleModCharm(aurApp, mode, apply);
         return;
     }
 
     if (apply)
         target->SetCharmedBy(caster, CHARM_TYPE_POSSESS, aurApp);
     else
         target->RemoveCharmedBy(caster);
 }

Here is the call graph for this function:

void AuraEffect::HandleModPossessPet	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     // Used by spell "Eyes of the Beast"
 
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* caster = GetCaster();
     if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     //seems it may happen that when removing it is no longer owner's pet
     //if (caster->ToPlayer()->GetPet() != target)
     //    return;
 
     Unit* target = aurApp->GetTarget();
     if (target->GetTypeId() != TYPEID_UNIT || !target->IsPet())
         return;
 
     Pet* pet = target->ToPet();
 
     if (apply)
     {
         if (caster->ToPlayer()->GetPet() != pet)
             return;
 
         // Must clear current motion or pet leashes back to owner after a few yards
         //  when under spell 'Eyes of the Beast'
         pet->GetMotionMaster()->Clear();
         pet->SetCharmedBy(caster, CHARM_TYPE_POSSESS, aurApp);
     }
     else
     {
         pet->RemoveCharmedBy(caster);
 
         if (!pet->IsWithinDistInMap(caster, pet->GetMap()->GetVisibilityRange()))
             pet->Remove(PET_SAVE_NOT_IN_SLOT, true);
         else
         {
             // Reinitialize the pet bar or it will appear greyed out
             caster->ToPlayer()->PetSpellInitialize();
 
             // Follow owner only if not fighting or owner didn't click "stay" at new location
             // This may be confusing because pet bar shows "stay" when under the spell but it retains
             //  the "follow" flag. Player MUST click "stay" while under the spell.
             if (!pet->GetVictim() && !pet->GetCharmInfo()->HasCommandState(COMMAND_STAY))
             {
                 pet->GetMotionMaster()->MoveFollow(caster, PET_FOLLOW_DIST, pet->GetFollowAngle());
             }
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModPowerCost	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     for (int i = 0; i < MAX_SPELL_SCHOOL; ++i)
         if (GetMiscValue() & (1<<i))
             target->ApplyModInt32Value(UNIT_FIELD_POWER_COST_MODIFIER+i, GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModPowerCostPCT	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     float amount = CalculatePct(1.0f, GetAmount());
     for (int i = 0; i < MAX_SPELL_SCHOOL; ++i)
         if (GetMiscValue() & (1 << i))
             target->ApplyModSignedFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER + i, amount, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModPowerRegen	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Update manaregen value
     if (GetMiscValue() == POWER_MANA)
         target->ToPlayer()->UpdateManaRegen();
     else if (GetMiscValue() == POWER_RUNES)
         target->ToPlayer()->UpdateRuneRegen(RuneType(GetMiscValueB()));
     // other powers are not immediate effects - implemented in Player::Regenerate, Creature::Regenerate
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleModPowerRegenPCT	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     HandleModPowerRegen(aurApp, mode, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModRating	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     for (uint32 rating = 0; rating < MAX_COMBAT_RATING; ++rating)
         if (GetMiscValue() & (1 << rating))
             target->ToPlayer()->ApplyRatingMod(CombatRating(rating), GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModRatingFromStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Just recalculate ratings
     for (uint32 rating = 0; rating < MAX_COMBAT_RATING; ++rating)
         if (GetMiscValue() & (1 << rating))
             target->ToPlayer()->ApplyRatingMod(CombatRating(rating), 0, apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModResistancePercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_RESISTANCE_PCT);
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     for (int8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; i++)
     {
         if (GetMiscValue() & int32(1<<i))
         {
             if (spellGroupVal)
             {
                 target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_PCT, (float)spellGroupVal, !apply);
                 if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                 {
                     target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), true, (float)spellGroupVal, !apply);
                     target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), false, (float)spellGroupVal, !apply);
                 }
             }
             target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_PCT, float(GetAmount()), apply);
             if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
             {
                 target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), true, (float)GetAmount(), apply);
                 target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), false, (float)GetAmount(), apply);
             }
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellCategoryCooldown	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     if (Player* player = aurApp->GetTarget()->ToPlayer())
         player->SendSpellCategoryCooldowns();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellCritChance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->UpdateAllSpellCritChances();
     else
         target->m_baseSpellCritChance += (apply) ? GetAmount():-GetAmount();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellCritChanceShool	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     for (int school = SPELL_SCHOOL_NORMAL; school < MAX_SPELL_SCHOOL; ++school)
         if (GetMiscValue() & (1<<school))
             target->ToPlayer()->UpdateSpellCritChance(school);
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellDamagePercentFromAttackPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Magic damage modifiers implemented in Unit::SpellDamageBonus
     // This information for client side use only
     // Recalculate bonus
     target->ToPlayer()->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellDamagePercentFromStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Magic damage modifiers implemented in Unit::SpellDamageBonus
     // This information for client side use only
     // Recalculate bonus
     target->ToPlayer()->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellHealingPercentFromAttackPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Recalculate bonus
     target->ToPlayer()->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellHealingPercentFromStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Recalculate bonus
     target->ToPlayer()->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandleModSpellHitChance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->UpdateSpellHitChances();
     else
         target->m_modSpellHitChance += (apply) ? GetAmount(): (-GetAmount());
 }

Here is the call graph for this function:

void AuraEffect::HandleModStatBonusPercent	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (GetMiscValue() < -1 || GetMiscValue() > 4)
     {
         TC_LOG_ERROR("spells", "WARNING: Misc Value for SPELL_AURA_MOD_STAT_BONUS_PCT not valid");
         return;
     }
 
     // only players have base stats
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     for (int32 i = STAT_STRENGTH; i < MAX_STATS; ++i)
     {
         if (GetMiscValue() == i || GetMiscValue() == -1)
         {
             target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), BASE_PCT_EXCLUDE_CREATE, float(m_amount), apply);
             target->ApplyStatPercentBuffMod(Stats(i), float(m_amount), apply);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModStateImmunityMask	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
     std::list <AuraType> aura_immunity_list;
     uint32 mechanic_immunity_list = 0;
     int32 miscVal = GetMiscValue();
 
     switch (miscVal)
     {
         case 27:
             target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SILENCE, apply);
             aura_immunity_list.push_back(SPELL_AURA_MOD_SILENCE);
             break;
         case 96:
         case 1615:
         {
             if (GetAmount())
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT)
                     | (1 << MECHANIC_FEAR) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_SLEEP) | (1 << MECHANIC_CHARM)
                     | (1 << MECHANIC_SAPPED) | (1 << MECHANIC_HORROR)
                     | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_DISORIENTED)
                     | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_TURN);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             }
             break;
         }
         case 679:
         {
             if (GetId() == 57742)
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT)
                     | (1 << MECHANIC_FEAR) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_SLEEP) | (1 << MECHANIC_CHARM)
                     | (1 << MECHANIC_SAPPED) | (1 << MECHANIC_HORROR)
                     | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_DISORIENTED)
                     | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_TURN);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             }
             break;
         }
         case 1557:
         {
             if (GetId() == 64187)
             {
                 mechanic_immunity_list = (1 << MECHANIC_STUN);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
             }
             else
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT)
                     | (1 << MECHANIC_FEAR) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_SLEEP) | (1 << MECHANIC_CHARM)
                     | (1 << MECHANIC_SAPPED) | (1 << MECHANIC_HORROR)
                     | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_DISORIENTED)
                     | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_TURN);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             }
             break;
         }
         case 1614:
         case 1694:
         {
             target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, apply);
             aura_immunity_list.push_back(SPELL_AURA_MOD_TAUNT);
             break;
         }
         case 1630:
         {
             if (!GetAmount())
             {
                 target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_TAUNT);
             }
             else
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT)
                     | (1 << MECHANIC_FEAR) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_SLEEP) | (1 << MECHANIC_CHARM)
                     | (1 << MECHANIC_SAPPED) | (1 << MECHANIC_HORROR)
                     | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_DISORIENTED)
                     | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_TURN);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             }
             break;
         }
         case 477:
         case 1733:
         {
             if (!GetAmount())
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT)
                     | (1 << MECHANIC_FEAR) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_SLEEP) | (1 << MECHANIC_CHARM)
                     | (1 << MECHANIC_SAPPED) | (1 << MECHANIC_HORROR)
                     | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_DISORIENTED)
                     | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_TURN);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK_DEST, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             }
             break;
         }
         case 878:
         {
             if (GetAmount() == 1)
             {
                 mechanic_immunity_list = (1 << MECHANIC_SNARE) | (1 << MECHANIC_STUN)
                     | (1 << MECHANIC_DISORIENTED) | (1 << MECHANIC_FREEZE);
 
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
                 target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
             }
             break;
         }
         default:
             break;
     }
 
     if (aura_immunity_list.empty())
     {
             if (miscVal & (1<<10))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_STUN);
             if (miscVal & (1<<1))
                 aura_immunity_list.push_back(SPELL_AURA_TRANSFORM);
 
             // These flag can be recognized wrong:
             if (miscVal & (1<<6))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DECREASE_SPEED);
             if (miscVal & (1<<0))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_ROOT);
             if (miscVal & (1<<2))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_CONFUSE);
             if (miscVal & (1<<9))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_FEAR);
             if (miscVal & (1<<7))
                 aura_immunity_list.push_back(SPELL_AURA_MOD_DISARM);
     }
 
     // apply immunities
     for (std::list <AuraType>::iterator iter = aura_immunity_list.begin(); iter != aura_immunity_list.end(); ++iter)
         target->ApplySpellImmune(GetId(), IMMUNITY_STATE, *iter, apply);
 
     if (apply && GetSpellInfo()->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)
     {
         target->RemoveAurasWithMechanic(mechanic_immunity_list, AURA_REMOVE_BY_DEFAULT, GetId());
         for (std::list <AuraType>::iterator iter = aura_immunity_list.begin(); iter != aura_immunity_list.end(); ++iter)
             target->RemoveAurasByType(*iter);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModStealth	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     StealthType type = StealthType(GetMiscValue());
 
     if (apply)
     {
         target->m_stealth.AddFlag(type);
         target->m_stealth.AddValue(type, GetAmount());
 
         target->SetStandFlags(UNIT_STAND_FLAGS_CREEP);
         if (target->GetTypeId() == TYPEID_PLAYER)
             target->SetByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
     }
     else
     {
         target->m_stealth.AddValue(type, -GetAmount());
 
         if (!target->HasAuraType(SPELL_AURA_MOD_STEALTH)) // if last SPELL_AURA_MOD_STEALTH
         {
             target->m_stealth.DelFlag(type);
 
             target->RemoveStandFlags(UNIT_STAND_FLAGS_CREEP);
             if (target->GetTypeId() == TYPEID_PLAYER)
                 target->RemoveByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
         }
     }
 
     // call functions which may have additional effects after chainging state of unit
     if (apply && (mode & AURA_EFFECT_HANDLE_REAL))
     {
         // drop flag at stealth in bg
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
     }
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleModStealthDetect	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     StealthType type = StealthType(GetMiscValue());
 
     if (apply)
     {
         target->m_stealthDetect.AddFlag(type);
         target->m_stealthDetect.AddValue(type, GetAmount());
     }
     else
     {
         if (!target->HasAuraType(SPELL_AURA_MOD_STEALTH_DETECT))
             target->m_stealthDetect.DelFlag(type);
 
         target->m_stealthDetect.AddValue(type, -GetAmount());
     }
 
     // call functions which may have additional effects after chainging state of unit
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleModStealthLevel	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     StealthType type = StealthType(GetMiscValue());
 
     if (apply)
         target->m_stealth.AddValue(type, GetAmount());
     else
         target->m_stealth.AddValue(type, -GetAmount());
 
     // call functions which may have additional effects after chainging state of unit
     target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandleModTargetResistance	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // applied to damage as HandleNoImmediateEffect in Unit::CalcAbsorbResist and Unit::CalcArmorReducedDamage
 
     // show armor penetration
     if (target->GetTypeId() == TYPEID_PLAYER && (GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL))
         target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, GetAmount(), apply);
 
     // show as spell penetration only full spell penetration bonuses (all resistances except armor and holy
     if (target->GetTypeId() == TYPEID_PLAYER && (GetMiscValue() & SPELL_SCHOOL_MASK_SPELL) == SPELL_SCHOOL_MASK_SPELL)
         target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_RESISTANCE, GetAmount(), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModTaunt	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (!target->IsAlive() || !target->CanHaveThreatList())
         return;
 
     Unit* caster = GetCaster();
     if (!caster || !caster->IsAlive())
         return;
 
     if (apply)
         target->TauntApply(caster);
     else
     {
         // When taunt aura fades out, mob will switch to previous target if current has less than 1.1 * secondthreat
         target->TauntFadeOut(caster);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleModThreat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
     for (int8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
         if (GetMiscValue() & (1 << i))
             ApplyPercentModFloatVar(target->m_threatModifier[i], float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleModTotalPercentStat	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
     int32 spellGroupVal = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, true, -1);
     if (abs(spellGroupVal) >= abs(GetAmount()))
         return;
 
     if (spellGroupVal)
     {
         for (int32 i = STAT_STRENGTH; i < MAX_STATS; i++)
         {
             if (GetMiscValue() == i || GetMiscValue() == -1) // affect the same stats
             {
                 target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_PCT, float(spellGroupVal), !apply);
                 if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                     target->ApplyStatPercentBuffMod(Stats(i), float(spellGroupVal), !apply);
             }
         }
     }
 
     // save current health state
     float healthPct = target->GetHealthPct();
     bool alive = target->IsAlive();
 
     for (int32 i = STAT_STRENGTH; i < MAX_STATS; i++)
     {
         if (GetMiscValueB() & 1 << i || !GetMiscValueB()) // 0 is also used for all stats
         {
             int32 spellGroupVal2 = target->GetHighestExclusiveSameEffectSpellGroupValue(this, SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, true, i);
             if (abs(spellGroupVal2) >= abs(GetAmount()))
                 continue;
 
             if (spellGroupVal2)
             {
                 target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_PCT, float(spellGroupVal2), !apply);
                 if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                     target->ApplyStatPercentBuffMod(Stats(i), float(spellGroupVal2), !apply);
             }
 
             target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_PCT, float(GetAmount()), apply);
             if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
                 target->ApplyStatPercentBuffMod(Stats(i), float(GetAmount()), apply);
         }
     }
 
     // recalculate current HP/MP after applying aura modifications (only for spells with SPELL_ATTR0_UNK4 0x00000010 flag)
     // this check is total bullshit i think
     if (GetMiscValueB() & 1 << STAT_STAMINA && (m_spellInfo->HasAttribute(SPELL_ATTR0_ABILITY)))
         target->SetHealth(std::max<uint32>(uint32(healthPct * target->GetMaxHealth() * 0.01f), (alive ? 1 : 0)));
 }

Here is the call graph for this function:

void AuraEffect::HandleModUnattackable	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
     if (!apply && target->HasAuraType(SPELL_AURA_MOD_UNATTACKABLE))
         return;
 
     target->ApplyModFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE, apply);
 
     // call functions which may have additional effects after chainging state of unit
     if (apply && (mode & AURA_EFFECT_HANDLE_REAL))
     {
         target->CombatStop();
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
     }
 }

Here is the call graph for this function:

void AuraEffect::HandleNoImmediateEffect	(	AuraApplication const *	,
		uint8	,
		bool
	)		const

inline

         {
             // aura type not have immediate effect at add/remove and handled by ID in other code place
         }

void AuraEffect::HandleNoReagentUseAura	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     flag128 mask;
     Unit::AuraEffectList const& noReagent = target->GetAuraEffectsByType(SPELL_AURA_NO_REAGENT_USE);
     for (Unit::AuraEffectList::const_iterator i = noReagent.begin(); i != noReagent.end(); ++i)
         if (SpellEffectInfo const* effect = (*i)->GetSpellEffectInfo())
             mask |= effect->SpellClassMask;
 
     target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1  , mask[0]);
     target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+1, mask[1]);
     target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+2, mask[2]);
     target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+3, mask[3]);
 }

Here is the call graph for this function:

void AuraEffect::HandleNULL	(	AuraApplication const *	,
		uint8	,
		bool
	)		const

inline

         {
             // not implemented
         }

void AuraEffect::HandleObsModPowerAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     Powers powerType;
     if (GetMiscValue() == POWER_ALL)
         powerType = target->getPowerType();
     else
         powerType = Powers(GetMiscValue());
 
     if (!target->IsAlive() || !target->GetMaxPower(powerType))
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     // don't regen when permanent aura target has full power
     if (GetBase()->IsPermanent() && target->GetPower(powerType) == target->GetMaxPower(powerType))
         return;
 
     // ignore negative values (can be result apply spellmods to aura damage
     uint32 amount = std::max(m_amount, 0) * target->GetMaxPower(powerType) /100;
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s energize %s for %u dmg inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), amount, GetId());
 
     SpellPeriodicAuraLogInfo pInfo(this, amount, 0, 0, 0, 0.0f, false);
     int32 gain = target->ModifyPower(powerType, amount);
 
     if (caster)
         target->getHostileRefManager().threatAssist(caster, float(gain) * 0.5f, GetSpellInfo());
 
     target->SendPeriodicAuraLog(&pInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleOverrideAttackPowerBySpellPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
     if (!target)
         return;
 
     target->ApplyModSignedFloatValue(PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT, float(m_amount), apply);
     target->UpdateAttackPowerAndDamage();
 }

Here is the call graph for this function:

void AuraEffect::HandleOverrideSpellPowerByAttackPower	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Player* target = aurApp->GetTarget()->ToPlayer();
     if (!target)
         return;
 
     target->ApplyModSignedFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT, float(m_amount), apply);
     target->UpdateSpellDamageAndHealingBonus();
 }

Here is the call graph for this function:

void AuraEffect::HandlePeriodicDamageAurasTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     if (!caster || !target->IsAlive())
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED) || target->IsImmunedToDamage(GetSpellInfo()))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     // Consecrate ticks can miss and will not show up in the combat log
     if (GetSpellEffectInfo()->Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
         caster->SpellHitResult(target, GetSpellInfo(), false) != SPELL_MISS_NONE)
         return;
 
     // some auras remove at specific health level or more
     if (GetAuraType() == SPELL_AURA_PERIODIC_DAMAGE)
     {
         switch (GetSpellInfo()->Id)
         {
             case 43093: case 31956: case 38801:  // Grievous Wound
             case 35321: case 38363: case 39215:  // Gushing Wound
                 if (target->IsFullHealth())
                 {
                     target->RemoveAurasDueToSpell(GetSpellInfo()->Id);
                     return;
                 }
                 break;
             case 38772: // Grievous Wound
             {
                 if (SpellEffectInfo const* effect = GetSpellInfo()->GetEffect(DIFFICULTY_NONE, EFFECT_1))
                 {
                     uint32 percent = effect->CalcValue(caster);
                     if (!target->HealthBelowPct(percent))
                     {
                         target->RemoveAurasDueToSpell(GetSpellInfo()->Id);
                         return;
                     }
                 }
                 break;
             }
         }
     }
 
     uint32 absorb = 0;
     uint32 resist = 0;
     CleanDamage cleanDamage = CleanDamage(0, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
 
     // AOE spells are not affected by the new periodic system.
     bool isAreaAura = GetSpellEffectInfo()->IsAreaAuraEffect() || GetSpellEffectInfo()->IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA);
     // ignore negative values (can be result apply spellmods to aura damage
     uint32 damage = isAreaAura ? std::max(GetAmount(), 0) : m_damage;
 
     // Script Hook For HandlePeriodicDamageAurasTick -- Allow scripts to change the Damage pre class mitigation calculations
     if (isAreaAura)
         sScriptMgr->ModifyPeriodicDamageAurasTick(target, caster, damage);
 
     if (GetAuraType() == SPELL_AURA_PERIODIC_DAMAGE)
     {
         if (isAreaAura)
             damage = caster->SpellDamageBonusDone(target, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount()) * caster->SpellDamagePctDone(target, m_spellInfo, DOT);
         damage = target->SpellDamageBonusTaken(caster, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount());
 
         // Calculate armor mitigation
         if (caster->IsDamageReducedByArmor(GetSpellInfo()->GetSchoolMask(), GetSpellInfo(), GetEffIndex()))
         {
             uint32 damageReductedArmor = caster->CalcArmorReducedDamage(target, damage, GetSpellInfo());
             cleanDamage.mitigated_damage += damage - damageReductedArmor;
             damage = damageReductedArmor;
         }
 
         // Curse of Agony damage-per-tick calculation
         if (GetSpellInfo()->SpellFamilyName == SPELLFAMILY_WARLOCK && (GetSpellInfo()->SpellFamilyFlags[0] & 0x400) && GetSpellInfo()->SpellIconID == 544)
         {
             uint32 totalTick = GetTotalTicks();
             // 1..4 ticks, 1/2 from normal tick damage
             if (m_tickNumber <= totalTick / 3)
                 damage = damage/2;
             // 9..12 ticks, 3/2 from normal tick damage
             else if (m_tickNumber > totalTick * 2 / 3)
                 damage += (damage+1)/2;           // +1 prevent 0.5 damage possible lost at 1..4 ticks
             // 5..8 ticks have normal tick damage
         }
         // There is a Chance to make a Soul Shard when Drain soul does damage
         if (GetSpellInfo()->SpellFamilyName == SPELLFAMILY_WARLOCK && (GetSpellInfo()->SpellFamilyFlags[0] & 0x00004000))
         {
             if (caster->GetTypeId() == TYPEID_PLAYER && caster->ToPlayer()->isHonorOrXPTarget(target))
                 caster->CastSpell(caster, 95810, true, 0, this);
         }
         if (GetSpellInfo()->SpellFamilyName == SPELLFAMILY_GENERIC)
         {
             switch (GetId())
             {
                 case 70911: // Unbound Plague
                 case 72854: // Unbound Plague
                 case 72855: // Unbound Plague
                 case 72856: // Unbound Plague
                     damage *= uint32(pow(1.25f, int32(m_tickNumber)));
                     break;
                 default:
                     break;
             }
         }
     }
     else
         damage = uint32(target->CountPctFromMaxHealth(damage));
 
     if (!m_spellInfo->HasAttribute(SPELL_ATTR4_FIXED_DAMAGE))
         if (GetSpellEffectInfo()->IsTargetingArea() || isAreaAura)
         {
             damage = int32(float(damage) * target->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
             if (caster->GetTypeId() != TYPEID_PLAYER)
                 damage = int32(float(damage) * target->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CREATURE_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
         }
 
     bool crit = false;
 
     if (CanPeriodicTickCrit(caster))
         crit = roll_chance_f(isAreaAura ? caster->GetUnitSpellCriticalChance(target, m_spellInfo, m_spellInfo->GetSchoolMask()) : m_critChance);
 
     if (crit)
         damage = caster->SpellCriticalDamageBonus(m_spellInfo, damage, target);
 
     int32 dmg = damage;
 
     if (!(GetSpellInfo()->AttributesEx4 & SPELL_ATTR4_FIXED_DAMAGE))
         caster->ApplyResilience(target, &dmg);
     damage = dmg;
 
     caster->CalcAbsorbResist(target, GetSpellInfo()->GetSchoolMask(), DOT, damage, &absorb, &resist, GetSpellInfo());
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s attacked %s for %u dmg inflicted by %u absorb is %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), damage, GetId(), absorb);
 
     caster->DealDamageMods(target, damage, &absorb);
 
     // Set trigger flag
     uint32 procAttacker = PROC_FLAG_DONE_PERIODIC;
     uint32 procVictim   = PROC_FLAG_TAKEN_PERIODIC;
     uint32 procEx = (crit ? PROC_EX_CRITICAL_HIT : PROC_EX_NORMAL_HIT) | PROC_EX_INTERNAL_DOT;
     damage = (damage <= absorb+resist) ? 0 : (damage-absorb-resist);
     if (damage)
         procVictim |= PROC_FLAG_TAKEN_DAMAGE;
 
     int32 overkill = damage - target->GetHealth();
     if (overkill < 0)
         overkill = 0;
 
     SpellPeriodicAuraLogInfo pInfo(this, damage, overkill, absorb, resist, 0.0f, crit);
 
     caster->ProcDamageAndSpell(target, procAttacker, procVictim, procEx, damage, BASE_ATTACK, GetSpellInfo());
     caster->DealDamage(target, damage, &cleanDamage, DOT, GetSpellInfo()->GetSchoolMask(), GetSpellInfo(), true);
     target->SendPeriodicAuraLog(&pInfo);
 }

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicDummyAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     switch (GetSpellInfo()->SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
             switch (GetId())
             {
                 case 66149: // Bullet Controller Periodic - 10 Man
                 case 68396: // Bullet Controller Periodic - 25 Man
                 {
                     if (!caster)
                         break;
 
                     caster->CastCustomSpell(66152, SPELLVALUE_MAX_TARGETS, urand(1, 6), target, true);
                     caster->CastCustomSpell(66153, SPELLVALUE_MAX_TARGETS, urand(1, 6), target, true);
                     break;
                 }
                 case 62292: // Blaze (Pool of Tar)
                     // should we use custom damage?
                     target->CastSpell((Unit*)NULL, GetSpellEffectInfo()->TriggerSpell, true);
                     break;
                 case 62399: // Overload Circuit
                     if (target->GetMap()->IsDungeon() && int(target->GetAppliedAuras().count(62399)) >= (target->GetMap()->IsHeroic() ? 4 : 2))
                     {
                          target->CastSpell(target, 62475, true); // System Shutdown
                          if (Unit* veh = target->GetVehicleBase())
                              veh->CastSpell(target, 62475, true);
                     }
                     break;
                 case 64821: // Fuse Armor (Razorscale)
                     if (GetBase()->GetStackAmount() == GetSpellInfo()->StackAmount)
                     {
                         target->CastSpell(target, 64774, true, NULL, NULL, GetCasterGUID());
                         target->RemoveAura(64821);
                     }
                     break;
             }
             break;
         case SPELLFAMILY_MAGE:
         {
             // Mirror Image
             if (GetId() == 55342)
                 // Set name of summons to name of caster
                 target->CastSpell((Unit*)NULL, GetSpellEffectInfo()->TriggerSpell, true);
             break;
         }
         case SPELLFAMILY_DRUID:
         {
             switch (GetSpellInfo()->Id)
             {
                 // Frenzied Regeneration
                 case 22842:
                 {
                     // Converts up to 10 rage per second into health for $d.  Each point of rage is converted into ${$m2/10}.1% of max health.
                     // Should be manauser
                     if (target->getPowerType() != POWER_RAGE)
                         break;
                     uint32 rage = target->GetPower(POWER_RAGE);
                     // Nothing todo
                     if (rage == 0)
                         break;
                     int32 mod = (rage < 100) ? rage : 100;
                     int32 points = target->CalculateSpellDamage(target, GetSpellInfo(), 1);
                     int32 regen = target->GetMaxHealth() * (mod * points / 10) / 1000;
                     target->CastCustomSpell(target, 22845, &regen, nullptr, nullptr, true, nullptr, this);
                     target->SetPower(POWER_RAGE, rage-mod);
                     break;
                 }
             }
             break;
         }
         case SPELLFAMILY_HUNTER:
         {
             // Explosive Shot
             if (GetSpellInfo()->SpellFamilyFlags[1] & 0x80000000)
             {
                 if (caster)
                     caster->CastCustomSpell(53352, SPELLVALUE_BASE_POINT0, m_amount, target, true, NULL, this);
                 break;
             }
             switch (GetSpellInfo()->Id)
             {
                 // Feeding Frenzy Rank 1
                 case 53511:
                     if (target->GetVictim() && target->EnsureVictim()->HealthBelowPct(35))
                         target->CastSpell(target, 60096, true, nullptr, this);
                     return;
                 // Feeding Frenzy Rank 2
                 case 53512:
                     if (target->GetVictim() && target->EnsureVictim()->HealthBelowPct(35))
                         target->CastSpell(target, 60097, true, nullptr, this);
                     return;
                 default:
                     break;
             }
             break;
         }
         case SPELLFAMILY_SHAMAN:
             if (GetId() == 52179) // Astral Shift
             {
                 // Periodic need for remove visual on stun/fear/silence lost
                 if (!(target->GetUInt32Value(UNIT_FIELD_FLAGS)&(UNIT_FLAG_STUNNED|UNIT_FLAG_FLEEING|UNIT_FLAG_SILENCED)))
                     target->RemoveAurasDueToSpell(52179);
                 break;
             }
             break;
         case SPELLFAMILY_DEATHKNIGHT:
             switch (GetId())
             {
                 case 49016: // Hysteria
                     uint32 damage = uint32(target->CountPctFromMaxHealth(1));
                     target->DealDamage(target, damage, NULL, NODAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
                     break;
             }
             // Blood of the North
             // Reaping
             // Death Rune Mastery
             if (GetSpellInfo()->SpellIconID == 3041 || GetSpellInfo()->SpellIconID == 22 || GetSpellInfo()->SpellIconID == 2622)
             {
                 if (target->GetTypeId() != TYPEID_PLAYER)
                     return;
                 if (target->ToPlayer()->getClass() != CLASS_DEATH_KNIGHT)
                     return;
 
                  // timer expired - remove death runes
                 target->ToPlayer()->RemoveRunesByAuraEffect(this);
             }
             break;
         default:
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicEnergizeAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     Powers powerType = Powers(GetMiscValue());
 
     if (target->GetTypeId() == TYPEID_PLAYER && target->getPowerType() != powerType && !m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_RESTORE_SECONDARY_POWER))
         return;
 
     if (!target->IsAlive() || !target->GetMaxPower(powerType))
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     // don't regen when permanent aura target has full power
     if (GetBase()->IsPermanent() && target->GetPower(powerType) == target->GetMaxPower(powerType))
         return;
 
     // ignore negative values (can be result apply spellmods to aura damage
     int32 amount = std::max(m_amount, 0);
 
     SpellPeriodicAuraLogInfo pInfo(this, amount, 0, 0, 0, 0.0f, false);
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s energize %s for %u dmg inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), amount, GetId());
 
     int32 gain = target->ModifyPower(powerType, amount);
     target->SendPeriodicAuraLog(&pInfo);
 
     if (caster)
         target->getHostileRefManager().threatAssist(caster, float(gain) * 0.5f, GetSpellInfo());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicHealAurasTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     if (!caster || !target->IsAlive())
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     // heal for caster damage (must be alive)
     if (target != caster && GetSpellInfo()->AttributesEx2 & SPELL_ATTR2_HEALTH_FUNNEL && !caster->IsAlive())
         return;
 
     // don't regen when permanent aura target has full power
     if (GetBase()->IsPermanent() && target->IsFullHealth())
         return;
 
     bool isAreaAura = GetSpellEffectInfo()->IsAreaAuraEffect() || GetSpellEffectInfo()->IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA);
     // ignore negative values (can be result apply spellmods to aura damage
     int32 damage = isAreaAura ? std::max(GetAmount(), 0) : m_damage;
 
     if (GetAuraType() == SPELL_AURA_OBS_MOD_HEALTH)
     {
         // Taken mods
         float TakenTotalMod = 1.0f;
 
         // Tenacity increase healing % taken
         if (AuraEffect const* Tenacity = target->GetAuraEffect(58549, 0))
             AddPct(TakenTotalMod, Tenacity->GetAmount());
 
         // Healing taken percent
         float minval = (float)target->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
         if (minval)
             AddPct(TakenTotalMod, minval);
 
         float maxval = (float)target->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
         if (maxval)
             AddPct(TakenTotalMod, maxval);
 
         TakenTotalMod = std::max(TakenTotalMod, 0.0f);
 
         damage = uint32(target->CountPctFromMaxHealth(damage));
         damage = uint32(damage * TakenTotalMod);
     }
     else
     {
         // Wild Growth = amount + (6 - 2*doneTicks) * ticks* amount / 100
         if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DRUID && m_spellInfo->SpellIconID == 2864)
         {
             int32 addition = int32(float(damage * GetTotalTicks()) * ((6-float(2*(GetTickNumber()-1)))/100));
 
             // Item - Druid T10 Restoration 2P Bonus
             if (AuraEffect* aurEff = caster->GetAuraEffect(70658, 0))
                 // divided by 50 instead of 100 because calculated as for every 2 tick
                 addition += abs(int32((addition * aurEff->GetAmount()) / 50));
 
             damage += addition;
         }
         if (isAreaAura)
             damage = caster->SpellHealingBonusDone(target, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount()) * caster->SpellHealingPctDone(target, m_spellInfo);
         damage = target->SpellHealingBonusTaken(caster, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount());
     }
 
     bool crit = false;
 
     if (CanPeriodicTickCrit(caster))
         crit = roll_chance_f(isAreaAura ? caster->GetUnitSpellCriticalChance(target, m_spellInfo, m_spellInfo->GetSchoolMask()) : m_critChance);
 
     if (crit)
         damage = caster->SpellCriticalHealingBonus(m_spellInfo, damage, target);
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s heal of %s for %u health inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), damage, GetId());
 
     uint32 absorb = 0;
     uint32 heal = uint32(damage);
     caster->CalcHealAbsorb(target, GetSpellInfo(), heal, absorb);
     int32 gain = caster->DealHeal(target, heal);
 
     SpellPeriodicAuraLogInfo pInfo(this, heal, heal - gain, absorb, 0, 0.0f, crit);
     target->SendPeriodicAuraLog(&pInfo);
 
     target->getHostileRefManager().threatAssist(caster, float(gain) * 0.5f, GetSpellInfo());
 
     uint32 procAttacker = PROC_FLAG_DONE_PERIODIC;
     uint32 procVictim   = PROC_FLAG_TAKEN_PERIODIC;
     uint32 procEx = (crit ? PROC_EX_CRITICAL_HIT : PROC_EX_NORMAL_HIT) | PROC_EX_INTERNAL_HOT;
     // ignore item heals
     if (GetBase()->GetCastItemGUID().IsEmpty())
         caster->ProcDamageAndSpell(target, procAttacker, procVictim, procEx, damage, BASE_ATTACK, GetSpellInfo());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicHealthFunnelAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     if (!caster || !caster->IsAlive() || !target->IsAlive())
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     uint32 damage = std::max(GetAmount(), 0);
     // do not kill health donator
     if (caster->GetHealth() < damage)
         damage = caster->GetHealth() - 1;
     if (!damage)
         return;
 
     caster->ModifyHealth(-(int32)damage);
     TC_LOG_DEBUG("spells", "PeriodicTick: donator %u target %u damage %u.", caster->GetEntry(), target->GetEntry(), damage);
 
     float gainMultiplier = GetSpellEffectInfo()->CalcValueMultiplier(caster);
 
     damage = int32(damage * gainMultiplier);
 
     caster->HealBySpell(target, GetSpellInfo(), damage);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicHealthLeechAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     if (!caster || !target->IsAlive())
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED) || target->IsImmunedToDamage(GetSpellInfo()))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     if (GetSpellEffectInfo()->Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
         caster->SpellHitResult(target, GetSpellInfo(), false) != SPELL_MISS_NONE)
         return;
 
     uint32 absorb = 0;
     uint32 resist = 0;
     CleanDamage cleanDamage = CleanDamage(0, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
 
     bool isAreaAura = GetSpellEffectInfo()->IsAreaAuraEffect() || GetSpellEffectInfo()->IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA);
     // ignore negative values (can be result apply spellmods to aura damage
     uint32 damage = isAreaAura ? std::max(GetAmount(), 0) : m_damage;
 
     if (isAreaAura)
     {
         // Script Hook For HandlePeriodicDamageAurasTick -- Allow scripts to change the Damage pre class mitigation calculations
         sScriptMgr->ModifyPeriodicDamageAurasTick(target, caster, damage);
         damage = caster->SpellDamageBonusDone(target, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount()) * caster->SpellDamagePctDone(target, m_spellInfo, DOT);
     }
     damage = target->SpellDamageBonusTaken(caster, GetSpellInfo(), damage, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount());
 
     // Calculate armor mitigation
     if (caster->IsDamageReducedByArmor(GetSpellInfo()->GetSchoolMask(), GetSpellInfo(), GetEffIndex()))
     {
         uint32 damageReductedArmor = caster->CalcArmorReducedDamage(target, damage, GetSpellInfo());
         cleanDamage.mitigated_damage += damage - damageReductedArmor;
         damage = damageReductedArmor;
     }
 
     if (!m_spellInfo->HasAttribute(SPELL_ATTR4_FIXED_DAMAGE))
         if (GetSpellEffectInfo()->IsTargetingArea() || isAreaAura)
         {
             damage = int32(float(damage) * target->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
             if (caster->GetTypeId() != TYPEID_PLAYER)
                 damage = int32(float(damage) * target->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CREATURE_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
         }
 
     bool crit = false;
 
     if (CanPeriodicTickCrit(caster))
         crit = roll_chance_f(isAreaAura ? caster->GetUnitSpellCriticalChance(target, m_spellInfo, m_spellInfo->GetSchoolMask()) : m_critChance);
 
     if (crit)
         damage = caster->SpellCriticalDamageBonus(m_spellInfo, damage, target);
 
     int32 dmg = damage;
     if (!(GetSpellInfo()->AttributesEx4 & SPELL_ATTR4_FIXED_DAMAGE))
         caster->ApplyResilience(target, &dmg);
     damage = dmg;
 
     caster->CalcAbsorbResist(target, GetSpellInfo()->GetSchoolMask(), DOT, damage, &absorb, &resist, m_spellInfo);
 
     if (target->GetHealth() < damage)
         damage = uint32(target->GetHealth());
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s health leech of %s for %u dmg inflicted by %u abs is %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), damage, GetId(), absorb);
 
     SpellNonMeleeDamage log(caster, target, GetId(), GetSpellInfo()->GetSchoolMask());
     log.damage = damage - absorb - resist;
     log.absorb = absorb;
     log.resist = resist;
     log.periodicLog = true;
     if (crit)
         log.HitInfo |= SPELL_HIT_TYPE_CRIT;
 
     // Set trigger flag
     uint32 procAttacker = PROC_FLAG_DONE_PERIODIC;
     uint32 procVictim   = PROC_FLAG_TAKEN_PERIODIC;
     uint32 procEx = (crit ? PROC_EX_CRITICAL_HIT : PROC_EX_NORMAL_HIT) | PROC_EX_INTERNAL_DOT;
     damage = (damage <= absorb+resist) ? 0 : (damage-absorb-resist);
     if (damage)
         procVictim |= PROC_FLAG_TAKEN_DAMAGE;
     if (caster->IsAlive())
         caster->ProcDamageAndSpell(target, procAttacker, procVictim, procEx, damage, BASE_ATTACK, GetSpellInfo());
     int32 new_damage = caster->DealDamage(target, damage, &cleanDamage, DOT, GetSpellInfo()->GetSchoolMask(), GetSpellInfo(), false);
     if (caster->IsAlive())
     {
         float gainMultiplier = GetSpellEffectInfo()->CalcValueMultiplier(caster);
 
         uint32 heal = uint32(caster->SpellHealingBonusDone(caster, GetSpellInfo(), uint32(new_damage * gainMultiplier), DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount()));
         heal = uint32(caster->SpellHealingBonusTaken(caster, GetSpellInfo(), heal, DOT, GetSpellEffectInfo(), GetBase()->GetStackAmount()));
 
         int32 gain = caster->HealBySpell(caster, GetSpellInfo(), heal);
         caster->getHostileRefManager().threatAssist(caster, gain * 0.5f, GetSpellInfo());
     }
 
     caster->SendSpellNonMeleeDamageLog(&log);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicManaLeechAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     Powers powerType = Powers(GetMiscValue());
 
     if (!caster || !caster->IsAlive() || !target->IsAlive() || target->getPowerType() != powerType)
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED) || target->IsImmunedToDamage(GetSpellInfo()))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     if (GetSpellEffectInfo()->Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
         caster->SpellHitResult(target, GetSpellInfo(), false) != SPELL_MISS_NONE)
         return;
 
     // ignore negative values (can be result apply spellmods to aura damage
     int32 drainAmount = std::max(m_amount, 0);
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s power leech of %s for %u dmg inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), drainAmount, GetId());
 
     int32 drainedAmount = -target->ModifyPower(powerType, -drainAmount);
 
     float gainMultiplier = GetSpellEffectInfo()->CalcValueMultiplier(caster);
 
     SpellPeriodicAuraLogInfo pInfo(this, drainedAmount, 0, 0, 0, gainMultiplier, false);
 
     int32 gainAmount = int32(drainedAmount * gainMultiplier);
     int32 gainedAmount = 0;
     if (gainAmount)
     {
         gainedAmount = caster->ModifyPower(powerType, gainAmount);
         target->AddThreat(caster, float(gainedAmount) * 0.5f, GetSpellInfo()->GetSchoolMask(), GetSpellInfo());
     }
 
     // Drain Mana
     if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK
         && m_spellInfo->SpellFamilyFlags[0] & 0x00000010)
     {
         int32 manaFeedVal = 0;
         if (AuraEffect const* aurEff = GetBase()->GetEffect(1))
             manaFeedVal = aurEff->GetAmount();
         // Mana Feed - Drain Mana
         if (manaFeedVal > 0)
         {
             int32 feedAmount = CalculatePct(gainedAmount, manaFeedVal);
             caster->CastCustomSpell(caster, 32554, &feedAmount, NULL, NULL, true, NULL, this);
         }
     }
 
     target->SendPeriodicAuraLog(&pInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicPowerBurnAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     Powers powerType = Powers(GetMiscValue());
 
     if (!caster || !target->IsAlive() || target->getPowerType() != powerType)
         return;
 
     if (target->HasUnitState(UNIT_STATE_ISOLATED) || target->IsImmunedToDamage(GetSpellInfo()))
     {
         SendTickImmune(target, caster);
         return;
     }
 
     // ignore negative values (can be result apply spellmods to aura damage
     int32 damage = std::max(m_amount, 0);
 
     uint32 gain = uint32(-target->ModifyPower(powerType, -damage));
 
     float dmgMultiplier = GetSpellEffectInfo()->CalcValueMultiplier(caster);
 
     SpellInfo const* spellProto = GetSpellInfo();
     // maybe has to be sent different to client, but not by SMSG_PERIODICAURALOG
     SpellNonMeleeDamage damageInfo(caster, target, spellProto->Id, spellProto->SchoolMask);
     // no SpellDamageBonus for burn mana
     caster->CalculateSpellDamageTaken(&damageInfo, int32(gain * dmgMultiplier), spellProto);
 
     caster->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
 
     // Set trigger flag
     uint32 procAttacker = PROC_FLAG_DONE_PERIODIC;
     uint32 procVictim   = PROC_FLAG_TAKEN_PERIODIC;
     uint32 procEx       = createProcExtendMask(&damageInfo, SPELL_MISS_NONE) | PROC_EX_INTERNAL_DOT;
     if (damageInfo.damage)
         procVictim |= PROC_FLAG_TAKEN_DAMAGE;
 
     caster->ProcDamageAndSpell(damageInfo.target, procAttacker, procVictim, procEx, damageInfo.damage, BASE_ATTACK, spellProto);
 
     caster->DealSpellDamage(&damageInfo, true);
     caster->SendSpellNonMeleeDamageLog(&damageInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicTriggerSpellAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

Todo:: effect trigger spell may be independant on spell targets, and executed in spell finish phase

 {
     // generic casting code with custom spells and target/caster customs
     uint32 triggerSpellId = GetSpellEffectInfo()->TriggerSpell;
 
     SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId);
     SpellInfo const* auraSpellInfo = GetSpellInfo();
     uint32 auraId = auraSpellInfo->Id;
 
     // specific code for cases with no trigger spell provided in field
     if (triggeredSpellInfo == NULL)
     {
         switch (auraSpellInfo->SpellFamilyName)
         {
             case SPELLFAMILY_GENERIC:
             {
                 switch (auraId)
                 {
                     // Brood Affliction: Bronze
                     case 23170:
                         triggerSpellId = 23171;
                         break;
                     // Restoration
                     case 24379:
                     case 23493:
                     {
                         if (caster)
                         {
                             int32 heal = caster->CountPctFromMaxHealth(10);
                             caster->HealBySpell(target, auraSpellInfo, heal);
 
                             if (int32 mana = caster->GetMaxPower(POWER_MANA))
                             {
                                 mana /= 10;
                                 caster->EnergizeBySpell(caster, 23493, mana, POWER_MANA);
                             }
                         }
                         return;
                     }
                     // Nitrous Boost
                     case 27746:
                         if (caster && target->GetPower(POWER_MANA) >= 10)
                         {
                             target->ModifyPower(POWER_MANA, -10);
                             target->SendEnergizeSpellLog(caster, 27746, 10, POWER_MANA);
                         }
                         else
                             target->RemoveAurasDueToSpell(27746);
                         return;
                     // Frost Blast
                     case 27808:
                         if (caster)
                             caster->CastCustomSpell(29879, SPELLVALUE_BASE_POINT0, int32(target->CountPctFromMaxHealth(21)), target, true, NULL, this);
                         return;
                     // Inoculate Nestlewood Owlkin
                     case 29528:
                         if (target->GetTypeId() != TYPEID_UNIT) // prevent error reports in case ignored player target
                             return;
                         break;
                     // Feed Captured Animal
                     case 29917:
                         triggerSpellId = 29916;
                         break;
                     // Extract Gas
                     case 30427:
                     {
                         // move loot to player inventory and despawn target
                         if (caster && caster->GetTypeId() == TYPEID_PLAYER &&
                                 target->GetTypeId() == TYPEID_UNIT &&
                                 target->ToCreature()->GetCreatureTemplate()->type == CREATURE_TYPE_GAS_CLOUD)
                         {
                             Player* player = caster->ToPlayer();
                             Creature* creature = target->ToCreature();
                             // missing lootid has been reported on startup - just return
                             if (!creature->GetCreatureTemplate()->SkinLootId)
                                 return;
 
                             player->AutoStoreLoot(creature->GetCreatureTemplate()->SkinLootId, LootTemplates_Skinning, true);
 
                             creature->DespawnOrUnsummon();
                         }
                         return;
                     }
                     // Quake
                     case 30576:
                         triggerSpellId = 30571;
                         break;
                     // Doom
                     // so instakill will be naturally done before trigger spell
                     case 31347:
                     {
                         target->CastSpell(target, 31350, true, NULL, this);
                         target->KillSelf();
                         return;
                     }
                     // Spellcloth
                     case 31373:
                     {
                         // Summon Elemental after create item
                         target->SummonCreature(17870, 0, 0, 0, target->GetOrientation(), TEMPSUMMON_DEAD_DESPAWN, 0);
                         return;
                     }
                     // Flame Quills
                     case 34229:
                     {
                         // cast 24 spells 34269-34289, 34314-34316
                         for (uint32 spell_id = 34269; spell_id != 34290; ++spell_id)
                             target->CastSpell(target, spell_id, true, NULL, this);
                         for (uint32 spell_id = 34314; spell_id != 34317; ++spell_id)
                             target->CastSpell(target, spell_id, true, NULL, this);
                         return;
                     }
                     // Remote Toy
                     case 37027:
                         triggerSpellId = 37029;
                         break;
                     // Eye of Grillok
                     case 38495:
                         triggerSpellId = 38530;
                         break;
                     // Absorb Eye of Grillok (Zezzak's Shard)
                     case 38554:
                     {
                         if (!caster || target->GetTypeId() != TYPEID_UNIT)
                             return;
 
                         caster->CastSpell(caster, 38495, true, NULL, this);
 
                         Creature* creatureTarget = target->ToCreature();
 
                         creatureTarget->DespawnOrUnsummon();
                         return;
                     }
                     // Tear of Azzinoth Summon Channel - it's not really supposed to do anything, and this only prevents the console spam
                     case 39857:
                         triggerSpellId = 39856;
                         break;
                     // Personalized Weather
                     case 46736:
                         triggerSpellId = 46737;
                         break;
                 }
                 break;
             }
             case SPELLFAMILY_SHAMAN:
             {
                 switch (auraId)
                 {
                     // Lightning Shield (The Earthshatterer set trigger after cast Lighting Shield)
                     case 28820:
                     {
                         // Need remove self if Lightning Shield not active
                         if (!target->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, flag128(0x400, 0, 0)))
                             target->RemoveAurasDueToSpell(28820);
                         return;
                     }
                     // Totemic Mastery (Skyshatter Regalia (Shaman Tier 6) - bonus)
                     case 38443:
                     {
                         bool all = true;
                         for (int i = SUMMON_SLOT_TOTEM; i < MAX_TOTEM_SLOT; ++i)
                         {
                             if (!target->m_SummonSlot[i])
                             {
                                 all = false;
                                 break;
                             }
                         }
 
                         if (all)
                             target->CastSpell(target, 38437, true, NULL, this);
                         else
                             target->RemoveAurasDueToSpell(38437);
                         return;
                     }
                 }
                 break;
             }
             default:
                 break;
         }
     }
     else
     {
         // Spell exist but require custom code
         switch (auraId)
         {
             // Pursuing Spikes (Anub'arak)
             case 65920:
             case 65922:
             case 65923:
             {
                 Unit* permafrostCaster = NULL;
                 Aura* permafrostAura = target->GetAura(66193);
                 if (!permafrostAura)
                     permafrostAura = target->GetAura(67855);
                 if (!permafrostAura)
                     permafrostAura = target->GetAura(67856);
                 if (!permafrostAura)
                     permafrostAura = target->GetAura(67857);
 
                 if (permafrostAura)
                     permafrostCaster = permafrostAura->GetCaster();
 
                 if (permafrostCaster)
                 {
                     if (Creature* permafrostCasterCreature = permafrostCaster->ToCreature())
                         permafrostCasterCreature->DespawnOrUnsummon(3000);
 
                     target->CastSpell(target, 66181, false);
                     target->RemoveAllAuras();
                     if (Creature* targetCreature = target->ToCreature())
                         targetCreature->DisappearAndDie();
                 }
                 break;
             }
             // Mana Tide
             case 16191:
                 target->CastCustomSpell(target, triggerSpellId, &m_amount, NULL, NULL, true, NULL, this);
                 return;
             // Negative Energy Periodic
             case 46284:
                 target->CastCustomSpell(triggerSpellId, SPELLVALUE_MAX_TARGETS, m_tickNumber / 10 + 1, NULL, true, NULL, this);
                 return;
             // Slime Pool (Dreadscale & Acidmaw)
             case 66882:
                 target->CastCustomSpell(triggerSpellId, SPELLVALUE_RADIUS_MOD, (int32)((((float)m_tickNumber / 60) * 0.9f + 0.1f) * 10000 * 2 / 3), NULL, true, NULL, this);
                 return;
             // Slime Spray - temporary here until preventing default effect works again
             // added on 9.10.2010
             case 69508:
             {
                 if (caster)
                     caster->CastSpell(target, triggerSpellId, true, NULL, NULL, caster->GetGUID());
                 return;
             }
             case 24745: // Summon Templar, Trigger
             case 24747: // Summon Templar Fire, Trigger
             case 24757: // Summon Templar Air, Trigger
             case 24759: // Summon Templar Earth, Trigger
             case 24761: // Summon Templar Water, Trigger
             case 24762: // Summon Duke, Trigger
             case 24766: // Summon Duke Fire, Trigger
             case 24769: // Summon Duke Air, Trigger
             case 24771: // Summon Duke Earth, Trigger
             case 24773: // Summon Duke Water, Trigger
             case 24785: // Summon Royal, Trigger
             case 24787: // Summon Royal Fire, Trigger
             case 24791: // Summon Royal Air, Trigger
             case 24792: // Summon Royal Earth, Trigger
             case 24793: // Summon Royal Water, Trigger
             {
                 // All this spells trigger a spell that requires reagents; if the
                 // triggered spell is cast as "triggered", reagents are not consumed
                 if (caster)
                     caster->CastSpell(target, triggerSpellId, false);
                 return;
             }
         }
     }
 
     // Reget trigger spell proto
     triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId);
 
     if (triggeredSpellInfo)
     {
         if (Unit* triggerCaster = triggeredSpellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, target->GetMap()->GetDifficultyID()) ? caster : target)
         {
             triggerCaster->CastSpell(target, triggeredSpellInfo, true, NULL, this);
             TC_LOG_DEBUG("spells", "AuraEffect::HandlePeriodicTriggerSpellAuraTick: Spell %u Trigger %u", GetId(), triggeredSpellInfo->Id);
         }
     }
     else
     {
         Creature* c = target->ToCreature();
         if (!c || !caster || !sScriptMgr->OnDummyEffect(caster, GetId(), SpellEffIndex(GetEffIndex()), target->ToCreature()) ||
             !c->AI()->sOnDummyEffect(caster, GetId(), SpellEffIndex(GetEffIndex())))
             TC_LOG_DEBUG("spells", "AuraEffect::HandlePeriodicTriggerSpellAuraTick: Spell %u has non-existent spell %u in EffectTriggered[%d] and is therefor not triggered.", GetId(), triggerSpellId, GetEffIndex());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePeriodicTriggerSpellWithValueAuraTick	(	Unit *	target,
		Unit *	caster
	)		const

 {
     uint32 triggerSpellId = GetSpellEffectInfo()->TriggerSpell;
     if (SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId))
     {
         if (Unit* triggerCaster = triggeredSpellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, target->GetMap()->GetDifficultyID()) ? caster : target)
         {
             int32 basepoints = GetAmount();
             triggerCaster->CastCustomSpell(target, triggerSpellId, &basepoints, &basepoints, &basepoints, true, nullptr, this);
             TC_LOG_DEBUG("spells", "AuraEffect::HandlePeriodicTriggerSpellWithValueAuraTick: Spell %u Trigger %u", GetId(), triggeredSpellInfo->Id);
         }
     }
     else
         TC_LOG_DEBUG("spells","AuraEffect::HandlePeriodicTriggerSpellWithValueAuraTick: Spell %u has non-existent spell %u in EffectTriggered[%d] and is therefor not triggered.", GetId(), triggerSpellId, GetEffIndex());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandlePhase	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     std::set<uint32> const& oldPhases = target->GetPhases();
     target->SetInPhase(GetMiscValueB(), false, apply);
 
     // call functions which may have additional effects after chainging state of unit
     // phase auras normally not expected at BG but anyway better check
     if (apply)
     {
         // drop flag at invisibiliy in bg
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
     }
 
     if (Player* player = target->ToPlayer())
     {
         if (player->IsInWorld())
             player->GetMap()->SendUpdateTransportVisibility(player, oldPhases);
         player->SendUpdatePhasing();
     }
 
     // need triggering visibility update base at phase update of not GM invisible (other GMs anyway see in any phases)
     if (target->IsVisible())
         target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandlePhaseGroup	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     std::set<uint32> const& oldPhases = target->GetPhases();
     std::set<uint32> phases = sDB2Manager.GetPhasesForGroup(GetMiscValueB());
     for (auto phase : phases)
         target->SetInPhase(phase, false, apply);
 
     // call functions which may have additional effects after chainging state of unit
     // phase auras normally not expected at BG but anyway better check
     if (apply)
     {
         // drop flag at invisibiliy in bg
         target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
     }
 
     if (Player* player = target->ToPlayer())
     {
         if (player->IsInWorld())
             player->GetMap()->SendUpdateTransportVisibility(player, oldPhases);
         player->SendUpdatePhasing();
     }
 
     // need triggering visibility update base at phase update of not GM invisible (other GMs anyway see in any phases)
     if (target->IsVisible())
         target->UpdateObjectVisibility();
 }

Here is the call graph for this function:

void AuraEffect::HandlePreventFleeing	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

TODO: find a way to cancel fleeing for assistance. Currently this will only stop creatures fleeing due to low health that could not find nearby allies to flee towards.

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // Since patch 3.0.2 this mechanic no longer affects fear effects. It will ONLY prevent humanoids from fleeing due to low health.
     if (!apply || target->HasAuraType(SPELL_AURA_MOD_FEAR))
         return;
     target->SetControlled(false, UNIT_STATE_FLEEING);
 }

Here is the call graph for this function:

void AuraEffect::HandlePreventResurrection	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     if (aurApp->GetTarget()->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (apply)
         aurApp->GetTarget()->RemoveFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
     else if (!aurApp->GetTarget()->GetBaseMap()->Instanceable())
         aurApp->GetTarget()->SetFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
 }

Here is the call graph for this function:

void AuraEffect::HandleProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     bool prevented = GetBase()->CallScriptEffectProcHandlers(this, aurApp, eventInfo);
     if (prevented)
         return;
 
     switch (GetAuraType())
     {
         case SPELL_AURA_PROC_TRIGGER_SPELL:
             HandleProcTriggerSpellAuraProc(aurApp, eventInfo);
             break;
         case SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE:
             HandleProcTriggerSpellWithValueAuraProc(aurApp, eventInfo);
             break;
         case SPELL_AURA_PROC_TRIGGER_DAMAGE:
             HandleProcTriggerDamageAuraProc(aurApp, eventInfo);
             break;
         case SPELL_AURA_RAID_PROC_FROM_CHARGE:
             HandleRaidProcFromChargeAuraProc(aurApp, eventInfo);
             break;
         case SPELL_AURA_RAID_PROC_FROM_CHARGE_WITH_VALUE:
             HandleRaidProcFromChargeWithValueAuraProc(aurApp, eventInfo);
             break;
         case SPELL_AURA_PROC_ON_POWER_AMOUNT:
             HandleProcTriggerSpellOnPowerAmountAuraProc(aurApp, eventInfo);
             break;
         default:
             break;
     }
 
     GetBase()->CallScriptAfterEffectProcHandlers(this, aurApp, eventInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleProcTriggerDamageAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     Unit* target = aurApp->GetTarget();
     Unit* triggerTarget = eventInfo.GetProcTarget();
     SpellNonMeleeDamage damageInfo(target, triggerTarget, GetId(), GetSpellInfo()->SchoolMask);
     uint32 damage = target->SpellDamageBonusDone(triggerTarget, GetSpellInfo(), GetAmount(), SPELL_DIRECT_DAMAGE, GetSpellEffectInfo());
     damage = triggerTarget->SpellDamageBonusTaken(target, GetSpellInfo(), damage, SPELL_DIRECT_DAMAGE, GetSpellEffectInfo());
     target->CalculateSpellDamageTaken(&damageInfo, damage, GetSpellInfo());
     target->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
     TC_LOG_DEBUG("spells", "AuraEffect::HandleProcTriggerDamageAuraProc: Triggering %u spell damage from aura %u proc", damage, GetId());
     target->DealSpellDamage(&damageInfo, true);
     target->SendSpellNonMeleeDamageLog(&damageInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleProcTriggerSpellAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     Unit* triggerCaster = aurApp->GetTarget();
     Unit* triggerTarget = eventInfo.GetProcTarget();
 
     uint32 triggerSpellId = GetSpellEffectInfo()->TriggerSpell;
     if (SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId))
     {
         TC_LOG_DEBUG("spells", "AuraEffect::HandleProcTriggerSpellAuraProc: Triggering spell %u from aura %u proc", triggeredSpellInfo->Id, GetId());
         triggerCaster->CastSpell(triggerTarget, triggeredSpellInfo, true, NULL, this);
     }
     else
         TC_LOG_DEBUG("spells","AuraEffect::HandleProcTriggerSpellAuraProc: Could not trigger spell %u from aura %u proc, because the spell does not have an entry in Spell.dbc.", triggerSpellId, GetId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleProcTriggerSpellOnPowerAmountAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     // Power amount required to proc the spell
     int32 powerAmountRequired = GetAmount();
     // Power type required to proc
     Powers powerRequired = Powers(_effectInfo->MiscValue);
 
     if (!powerRequired || !powerAmountRequired)
     {
         TC_LOG_ERROR("spells", "AuraEffect::HandleProcTriggerSpellOnPowerAmountAuraProc: Spell %u have 0 PowerAmountRequired in EffectAmount[%d] or 0 PowerRequired in EffectMiscValue", GetId(), GetEffIndex());
         return /*false*/;
     }
 
     Unit* triggerCaster = aurApp->GetTarget();
     Unit* triggerTarget = eventInfo.GetProcTarget();
 
     if (triggerCaster->GetPower(powerRequired) != powerAmountRequired)
         return /*false*/;
 
     uint32 triggerSpellId = _effectInfo->TriggerSpell;
     if (SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId))
     {
         TC_LOG_DEBUG("spells", "AuraEffect::HandleProcTriggerSpellOnPowerAmountAuraProc: Triggering spell %u from aura %u proc", triggeredSpellInfo->Id, GetId());
         triggerCaster->CastSpell(triggerTarget, triggeredSpellInfo, true, nullptr, this);
     }
     else
         TC_LOG_DEBUG("spells", "AuraEffect::HandleProcTriggerSpellOnPowerAmountAuraProc: Could not trigger spell %u from aura %u proc, because the spell does not have an entry in Spell.dbc.", triggerSpellId, GetId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleProcTriggerSpellWithValueAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     Unit* triggerCaster = aurApp->GetTarget();
     Unit* triggerTarget = eventInfo.GetProcTarget();
 
     uint32 triggerSpellId = GetSpellEffectInfo()->TriggerSpell;
     if (SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(triggerSpellId))
     {
         int32 basepoints0 = GetAmount();
         TC_LOG_DEBUG("spells", "AuraEffect::HandleProcTriggerSpellWithValueAuraProc: Triggering spell %u with value %d from aura %u proc", triggeredSpellInfo->Id, basepoints0, GetId());
         triggerCaster->CastCustomSpell(triggerTarget, triggerSpellId, &basepoints0, NULL, NULL, true, NULL, this);
     }
     else
         TC_LOG_DEBUG("spells","AuraEffect::HandleProcTriggerSpellWithValueAuraProc: Could not trigger spell %u from aura %u proc, because the spell does not have an entry in Spell.dbc.", triggerSpellId, GetId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleRaidProcFromChargeAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     Unit* target = aurApp->GetTarget();
 
     uint32 triggerSpellId;
     switch (GetId())
     {
         case 57949:            // Shiver
             triggerSpellId = 57952;
             //animationSpellId = 57951; dummy effects for jump spell have unknown use (see also 41637)
             break;
         case 59978:            // Shiver
             triggerSpellId = 59979;
             break;
         case 43593:            // Cold Stare
             triggerSpellId = 43594;
             break;
         default:
             TC_LOG_DEBUG("spells", "AuraEffect::HandleRaidProcFromChargeAuraProc: received not handled spell: %u", GetId());
             return;
     }
 
     int32 jumps = GetBase()->GetCharges();
 
     // current aura expire on proc finish
     GetBase()->SetCharges(0);
     GetBase()->SetUsingCharges(true);
 
     // next target selection
     if (jumps > 0)
     {
         if (Unit* caster = GetCaster())
         {
             float radius = GetSpellEffectInfo()->CalcRadius(caster);
 
             if (Unit* triggerTarget = target->GetNextRandomRaidMemberOrPet(radius))
             {
                 target->CastSpell(triggerTarget, GetSpellInfo(), true, NULL, this, GetCasterGUID());
                 if (Aura* aura = triggerTarget->GetAura(GetId(), GetCasterGUID()))
                     aura->SetCharges(jumps);
             }
         }
     }
 
     TC_LOG_DEBUG("spells", "AuraEffect::HandleRaidProcFromChargeAuraProc: Triggering spell %u from aura %u proc", triggerSpellId, GetId());
     target->CastSpell(target, triggerSpellId, true, NULL, this, GetCasterGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleRaidProcFromChargeWithValueAuraProc	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

 {
     Unit* target = aurApp->GetTarget();
 
     // Currently only Prayer of Mending
     if (!(GetSpellInfo()->SpellFamilyName == SPELLFAMILY_PRIEST && GetSpellInfo()->SpellFamilyFlags[1] & 0x20))
     {
         TC_LOG_DEBUG("spells", "AuraEffect::HandleRaidProcFromChargeWithValueAuraProc: received not handled spell: %u", GetId());
         return;
     }
     uint32 triggerSpellId = 33110;
 
     int32 value = GetAmount();
 
     int32 jumps = GetBase()->GetCharges();
 
     // current aura expire on proc finish
     GetBase()->SetCharges(0);
     GetBase()->SetUsingCharges(true);
 
     // next target selection
     if (jumps > 0)
     {
         if (Unit* caster = GetCaster())
         {
             float radius = GetSpellEffectInfo()->CalcRadius(caster);
 
             if (Unit* triggerTarget = target->GetNextRandomRaidMemberOrPet(radius))
             {
                 target->CastCustomSpell(triggerTarget, GetId(), &value, NULL, NULL, true, NULL, this, GetCasterGUID());
                 if (Aura* aura = triggerTarget->GetAura(GetId(), GetCasterGUID()))
                     aura->SetCharges(jumps);
             }
         }
     }
 
     TC_LOG_DEBUG("spells", "AuraEffect::HandleRaidProcFromChargeWithValueAuraProc: Triggering spell %u from aura %u proc", triggerSpellId, GetId());
     target->CastCustomSpell(target, triggerSpellId, &value, NULL, NULL, true, NULL, this, GetCasterGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleShapeshiftBoosts	(	Unit *	target,
		bool	apply
	)		const

 {
     uint32 spellId = 0;
     uint32 spellId2 = 0;
 
     switch (GetMiscValue())
     {
         case FORM_CAT:
             spellId = 3025;
             break;
         case FORM_TREE:
             spellId = 34123;
             break;
         case FORM_TRAVEL:
             spellId = 5419;
             break;
         case FORM_AQUA:
             spellId = 5421;
             break;
         case FORM_BEAR:
             spellId = 1178;
             spellId2 = 21178;
             break;
         case FORM_BATTLESTANCE:
             spellId = 21156;
             break;
         case FORM_DEFENSIVESTANCE:
             spellId = 7376;
             break;
         case FORM_BERSERKERSTANCE:
             spellId = 7381;
             break;
         case FORM_MOONKIN:
             spellId = 24905;
             spellId2 = 24907;
             break;
         case FORM_FLIGHT:
             spellId = 33948;
             spellId2 = 34764;
             break;
         case FORM_FLIGHT_EPIC:
             spellId  = 40122;
             spellId2 = 40121;
             break;
         case FORM_METAMORPHOSIS:
             spellId  = 54817;
             spellId2 = 54879;
             break;
         case FORM_SPIRITOFREDEMPTION:
             spellId  = 27792;
             spellId2 = 27795;                               // must be second, this important at aura remove to prevent to early iterator invalidation.
             break;
         case FORM_SHADOW:
             spellId = 49868;
             break;
         case FORM_GHOSTWOLF:
             spellId = 67116;
             break;
         case FORM_GHOUL:
         case FORM_AMBIENT:
         case FORM_STEALTH:
         case FORM_CREATURECAT:
         case FORM_CREATUREBEAR:
             break;
         default:
             break;
     }
 
     if (apply)
     {
         if (spellId)
             target->CastSpell(target, spellId, true, NULL, this);
 
         if (spellId2)
             target->CastSpell(target, spellId2, true, NULL, this);
 
         if (target->GetTypeId() == TYPEID_PLAYER)
         {
             Player* plrTarget = target->ToPlayer();
 
             PlayerSpellMap const& sp_list = plrTarget->GetSpellMap();
             for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
             {
                 if (itr->second->state == PLAYERSPELL_REMOVED || itr->second->disabled)
                     continue;
 
                 if (itr->first == spellId || itr->first == spellId2)
                     continue;
 
                 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first);
                 if (!spellInfo || !(spellInfo->Attributes & (SPELL_ATTR0_PASSIVE | SPELL_ATTR0_HIDDEN_CLIENTSIDE)))
                     continue;
 
                 if ((spellInfo->HasAttribute(SPELL_ATTR8_MASTERY_SPECIALIZATION)) && !plrTarget->IsCurrentSpecMasterySpell(spellInfo))
                     continue;
 
                 if (spellInfo->Stances & (UI64LIT(1) << (GetMiscValue() - 1)))
                     target->CastSpell(target, itr->first, true, NULL, this);
             }
 
             // Also do it for Glyphs
             for (uint32 i = 0; i < MAX_GLYPH_SLOT_INDEX; ++i)
             {
                 if (uint32 glyphId = plrTarget->GetGlyph(plrTarget->GetActiveTalentGroup(), i))
                 {
                     if (GlyphPropertiesEntry const* glyph = sGlyphPropertiesStore.LookupEntry(glyphId))
                     {
                         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(glyph->SpellID);
                         if (!spellInfo || !(spellInfo->Attributes & (SPELL_ATTR0_PASSIVE | SPELL_ATTR0_HIDDEN_CLIENTSIDE)))
                             continue;
 
                         if (spellInfo->Stances & (UI64LIT(1) << (GetMiscValue() - 1)))
                             target->CastSpell(target, glyph->SpellID, true, NULL, this);
                     }
                 }
             }
 
             // Leader of the Pack
             if (plrTarget->HasSpell(17007))
             {
                 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(24932);
                 if (spellInfo && spellInfo->Stances & (UI64LIT(1) << (GetMiscValue() -1)))
                     target->CastSpell(target, 24932, true, NULL, this);
             }
 
             switch (GetMiscValue())
             {
                 case FORM_CAT:
                     // Savage Roar
                     if (target->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_DRUID, flag128(0, 0x10000000, 0)))
                         target->CastSpell(target, 62071, true);
                     // Nurturing Instinct
                     if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT, SPELLFAMILY_DRUID, 2254, EFFECT_0))
                     {
                         uint32 spellId3 = 0;
                         switch (aurEff->GetId())
                         {
                             case 33872:
                                 spellId3 = 47179;
                                 break;
                             case 33873:
                                 spellId3 = 47180;
                                 break;
                         }
                         target->CastSpell(target, spellId3, true, NULL, this);
                     }
                     // Master Shapeshifter - Cat
                     if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_MOD_HEALING_DONE_PERCENT, SPELLFAMILY_GENERIC, 2851, EFFECT_0))
                     {
                         int32 bp = aurEff->GetAmount();
                         target->CastCustomSpell(target, 48420, &bp, NULL, NULL, true);
                     }
                     break;
                 case FORM_BEAR:
                     // Master Shapeshifter - Bear
                     if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_MOD_HEALING_DONE_PERCENT, SPELLFAMILY_GENERIC, 2851, EFFECT_0))
                     {
                         int32 bp = aurEff->GetAmount();
                         target->CastCustomSpell(target, 48418, &bp, NULL, NULL, true);
                     }
                     break;
                 case FORM_MOONKIN:
                     // Master Shapeshifter - Moonkin
                     if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_MOD_HEALING_DONE_PERCENT, SPELLFAMILY_GENERIC, 2851, EFFECT_0))
                     {
                         int32 bp = aurEff->GetAmount();
                         target->CastCustomSpell(target, 48421, &bp, NULL, NULL, true);
                     }
                     break;
                 default:
                     break;
             }
         }
     }
     else
     {
         if (spellId)
             target->RemoveOwnedAura(spellId, target->GetGUID());
         if (spellId2)
             target->RemoveOwnedAura(spellId2, target->GetGUID());
 
         Unit::AuraEffectList const& shapeshifts = target->GetAuraEffectsByType(SPELL_AURA_MOD_SHAPESHIFT);
         AuraEffect* newAura = NULL;
         // Iterate through all the shapeshift auras that the target has, if there is another aura with SPELL_AURA_MOD_SHAPESHIFT, then this aura is being removed due to that one being applied
         for (Unit::AuraEffectList::const_iterator itr = shapeshifts.begin(); itr != shapeshifts.end(); ++itr)
         {
             if ((*itr) != this)
             {
                 newAura = *itr;
                 break;
             }
         }
 
         Unit::AuraApplicationMap& tAuras = target->GetAppliedAuras();
         for (Unit::AuraApplicationMap::iterator itr = tAuras.begin(); itr != tAuras.end();)
         {
             // Use the new aura to see on what stance the target will be
             uint64 newStance = newAura ? (UI64LIT(1) << (newAura->GetMiscValue() - 1)) : 0;
 
             // If the stances are not compatible with the spell, remove it
             if (itr->second->GetBase()->IsRemovedOnShapeLost(target) && !(itr->second->GetBase()->GetSpellInfo()->Stances & newStance))
                 target->RemoveAura(itr);
             else
                 ++itr;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::HandleShieldBlockValue	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & (AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK | AURA_EFFECT_HANDLE_STAT)))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     BaseModType modType = FLAT_MOD;
     if (GetAuraType() == SPELL_AURA_MOD_SHIELD_BLOCKVALUE_PCT)
         modType = PCT_MOD;
 
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->HandleBaseModValue(SHIELD_BLOCK_VALUE, modType, float(GetAmount()), apply);
 }

Here is the call graph for this function:

void AuraEffect::HandleSpiritOfRedemption	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     if (target->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // prepare spirit state
     if (apply)
     {
         if (target->GetTypeId() == TYPEID_PLAYER)
         {
             // disable breath/etc timers
             target->ToPlayer()->StopMirrorTimers();
 
             // set stand state (expected in this form)
             if (!target->IsStandState())
                 target->SetStandState(UNIT_STAND_STATE_STAND);
         }
 
         target->SetHealth(1);
     }
     // die at aura end
     else if (target->IsAlive())
         // call functions which may have additional effects after chainging state of unit
         target->setDeathState(JUST_DIED);
 }

Here is the call graph for this function:

void AuraEffect::HandleUnused	(	AuraApplication const *	,
		uint8	,
		bool
	)		const

inline

         {
             // useless
         }

void AuraEffect::HandleWaterBreathing	(	AuraApplication const *	aurApp,
		uint8	mode,
		bool	apply
	)		const

 {
     if (!(mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK))
         return;
 
     Unit* target = aurApp->GetTarget();
 
     // update timers in client
     if (target->GetTypeId() == TYPEID_PLAYER)
         target->ToPlayer()->UpdateMirrorTimers();
 }

Here is the call graph for this function:

bool AuraEffect::HasSpellClassMask ( ) const

inline

90 { return GetSpellEffectInfo()->SpellClassMask; }

AuraEffect::GetSpellEffectInfo

SpellEffectInfo const * GetSpellEffectInfo() const

Definition: SpellAuraEffects.h:102

SpellEffectInfo::SpellClassMask

flag128 SpellClassMask

Definition: SpellInfo.h:264

bool AuraEffect::IsAffectingSpell ( SpellInfo const * spell ) const

 {
     if (!spell)
         return false;
     // Check family name
     if (spell->SpellFamilyName != m_spellInfo->SpellFamilyName)
         return false;
 
     // Check EffectClassMask
     if (GetSpellEffectInfo()->SpellClassMask & spell->SpellFamilyFlags)
         return true;
     return false;
 }

Here is the call graph for this function:

bool AuraEffect::IsAreaAuraEffect ( ) const

 {
     if (_effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
         _effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID ||
         _effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND ||
         _effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY ||
         _effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_PET ||
         _effectInfo->Effect == SPELL_EFFECT_APPLY_AREA_AURA_OWNER)
         return true;
     return false;
 }

bool AuraEffect::IsEffect ( ) const

inline

104 { return _effectInfo->Effect != 0; }

AuraEffect::_effectInfo

SpellEffectInfo const * _effectInfo

Definition: SpellAuraEffects.h:112

SpellEffectInfo::Effect

uint32 Effect

Definition: SpellInfo.h:243

bool AuraEffect::IsEffect ( SpellEffectName effectName ) const

inline

105 { return _effectInfo->Effect == uint32(effectName); }

AuraEffect::_effectInfo

SpellEffectInfo const * _effectInfo

Definition: SpellAuraEffects.h:112

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

SpellEffectInfo::Effect

uint32 Effect

Definition: SpellInfo.h:243

bool AuraEffect::IsPeriodic ( ) const

inline

87 { return m_isPeriodic; }

AuraEffect::m_isPeriodic

bool m_isPeriodic

Definition: SpellAuraEffects.h:128

Here is the caller graph for this function:

void AuraEffect::PeriodicTick	(	AuraApplication *	aurApp,
		Unit *	caster
	)		const

 {
     bool prevented = GetBase()->CallScriptEffectPeriodicHandlers(this, aurApp);
     if (prevented)
         return;
 
     Unit* target = aurApp->GetTarget();
 
     switch (GetAuraType())
     {
         case SPELL_AURA_PERIODIC_DUMMY:
             HandlePeriodicDummyAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
             HandlePeriodicTriggerSpellAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
             HandlePeriodicTriggerSpellWithValueAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_DAMAGE:
         case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
             HandlePeriodicDamageAurasTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_LEECH:
             HandlePeriodicHealthLeechAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
             HandlePeriodicHealthFunnelAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_HEAL:
         case SPELL_AURA_OBS_MOD_HEALTH:
             HandlePeriodicHealAurasTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_MANA_LEECH:
             HandlePeriodicManaLeechAuraTick(target, caster);
             break;
         case SPELL_AURA_OBS_MOD_POWER:
             HandleObsModPowerAuraTick(target, caster);
             break;
         case SPELL_AURA_PERIODIC_ENERGIZE:
             HandlePeriodicEnergizeAuraTick(target, caster);
             break;
         case SPELL_AURA_POWER_BURN:
             HandlePeriodicPowerBurnAuraTick(target, caster);
             break;
         default:
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::RecalculateAmount ( )

inline

65 { if (!CanBeRecalculated()) return; ChangeAmount(CalculateAmount(GetCaster()), false); }

AuraEffect::CanBeRecalculated

bool CanBeRecalculated() const

Definition: SpellAuraEffects.h:67

AuraEffect::GetCaster

Unit * GetCaster() const

Definition: SpellAuraEffects.h:39

AuraEffect::ChangeAmount

void ChangeAmount(int32 newAmount, bool mark=true, bool onStackOrReapply=false)

Definition: SpellAuraEffects.cpp:828

AuraEffect::CalculateAmount

int32 CalculateAmount(Unit *caster)

Definition: SpellAuraEffects.cpp:589

void AuraEffect::RecalculateAmount ( Unit * caster )

inline

66 { if (!CanBeRecalculated()) return; ChangeAmount(CalculateAmount(caster), false); }

AuraEffect::CanBeRecalculated

bool CanBeRecalculated() const

Definition: SpellAuraEffects.h:67

AuraEffect::ChangeAmount

void ChangeAmount(int32 newAmount, bool mark=true, bool onStackOrReapply=false)

Definition: SpellAuraEffects.cpp:828

AuraEffect::CalculateAmount

int32 CalculateAmount(Unit *caster)

Definition: SpellAuraEffects.cpp:589

void AuraEffect::ResetPeriodic ( bool resetPeriodicTimer = false )

inline

85 { if (resetPeriodicTimer) m_periodicTimer = m_period; m_tickNumber = 0;}

AuraEffect::m_periodicTimer

int32 m_periodicTimer

Definition: SpellAuraEffects.h:122

AuraEffect::m_tickNumber

uint32 m_tickNumber

Definition: SpellAuraEffects.h:124

AuraEffect::m_period

int32 m_period

Definition: SpellAuraEffects.h:123

Here is the caller graph for this function:

void AuraEffect::SendTickImmune	(	Unit *	target,
		Unit *	caster
	)		const

 {
     if (caster)
         caster->SendSpellDamageImmune(target, m_spellInfo->Id, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AuraEffect::SetAmount ( int32 amount )

inline

56 { m_amount = amount; m_canBeRecalculated = false;}

AuraEffect::m_amount

int32 m_amount

Definition: SpellAuraEffects.h:115

AuraEffect::m_canBeRecalculated

bool m_canBeRecalculated

Definition: SpellAuraEffects.h:127

Here is the caller graph for this function:

void AuraEffect::SetCanBeRecalculated ( bool val )

inline

68 { m_canBeRecalculated = val; }

AuraEffect::m_canBeRecalculated

bool m_canBeRecalculated

Definition: SpellAuraEffects.h:127

void AuraEffect::SetCritChance ( float val )

inline

75 { m_critChance = val; }

AuraEffect::m_critChance

float m_critChance

Definition: SpellAuraEffects.h:117

void AuraEffect::SetDamage ( int32 val )

inline

73 { m_damage = val; }

AuraEffect::m_damage

int32 m_damage

Definition: SpellAuraEffects.h:116

void AuraEffect::SetDonePct ( float val )

inline

77 { m_donePct = val; }

AuraEffect::m_donePct

float m_donePct

Definition: SpellAuraEffects.h:118

void AuraEffect::SetPeriodic ( bool isPeriodic )

inline

88 { m_isPeriodic = isPeriodic; }

AuraEffect::m_isPeriodic

bool m_isPeriodic

Definition: SpellAuraEffects.h:128

void AuraEffect::SetPeriodicTimer ( int32 periodicTimer )

inline

59 { m_periodicTimer = periodicTimer; }

AuraEffect::m_periodicTimer

int32 m_periodicTimer

Definition: SpellAuraEffects.h:122

Here is the caller graph for this function:

void AuraEffect::Update	(	uint32	diff,
		Unit *	caster
	)

 {
     if (m_isPeriodic && (GetBase()->GetDuration() >=0 || GetBase()->IsPassive() || GetBase()->IsPermanent()))
     {
         if (m_periodicTimer > int32(diff))
             m_periodicTimer -= diff;
         else // tick also at m_periodicTimer == 0 to prevent lost last tick in case max m_duration == (max m_periodicTimer)*N
         {
             ++m_tickNumber;
 
             // update before tick (aura can be removed in TriggerSpell or PeriodicTick calls)
             m_periodicTimer += m_period - diff;
             UpdatePeriodic(caster);
 
             std::list<AuraApplication*> effectApplications;
             GetApplicationList(effectApplications);
             // tick on targets of effects
             for (std::list<AuraApplication*>::const_iterator apptItr = effectApplications.begin(); apptItr != effectApplications.end(); ++apptItr)
                 if ((*apptItr)->HasEffect(GetEffIndex()))
                     PeriodicTick(*apptItr, caster);
         }
     }
 }

Here is the call graph for this function:

void AuraEffect::UpdatePeriodic ( Unit * caster )

 {
     switch (GetAuraType())
     {
         case SPELL_AURA_PERIODIC_DUMMY:
             switch (GetSpellInfo()->SpellFamilyName)
             {
                 case SPELLFAMILY_GENERIC:
                     switch (GetId())
                     {
                         // Drink
                         case 430:
                         case 431:
                         case 432:
                         case 1133:
                         case 1135:
                         case 1137:
                         case 10250:
                         case 22734:
                         case 27089:
                         case 34291:
                         case 43182:
                         case 43183:
                         case 46755:
                         case 49472: // Drink Coffee
                         case 57073:
                         case 61830:
                         case 69176:
                         case 72623:
                         case 80166:
                         case 80167:
                         case 87958:
                         case 87959:
                         case 92736:
                         case 92797:
                         case 92800:
                         case 92803:
                             if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
                                 return;
                             // Get SPELL_AURA_MOD_POWER_REGEN aura from spell
                             if (AuraEffect* aurEff = GetBase()->GetEffect(0))
                             {
                                 if (aurEff->GetAuraType() != SPELL_AURA_MOD_POWER_REGEN)
                                 {
                                     m_isPeriodic = false;
                                     TC_LOG_ERROR("spells", "Aura %d structure has been changed - first aura is no longer SPELL_AURA_MOD_POWER_REGEN", GetId());
                                 }
                                 else
                                 {
                                     // default case - not in arena
                                     if (!caster->ToPlayer()->InArena())
                                     {
                                         aurEff->ChangeAmount(GetAmount());
                                         m_isPeriodic = false;
                                     }
                                     else
                                     {
                                         // **********************************************
                                         // This feature uses only in arenas
                                         // **********************************************
                                         // Here need increase mana regen per tick (6 second rule)
                                         // on 0 tick -   0  (handled in 2 second)
                                         // on 1 tick - 166% (handled in 4 second)
                                         // on 2 tick - 133% (handled in 6 second)
 
                                         // Apply bonus for 1 - 4 tick
                                         switch (m_tickNumber)
                                         {
                                             case 1:   // 0%
                                                 aurEff->ChangeAmount(0);
                                                 break;
                                             case 2:   // 166%
                                                 aurEff->ChangeAmount(GetAmount() * 5 / 3);
                                                 break;
                                             case 3:   // 133%
                                                 aurEff->ChangeAmount(GetAmount() * 4 / 3);
                                                 break;
                                             default:  // 100% - normal regen
                                                 aurEff->ChangeAmount(GetAmount());
                                                 // No need to update after 4th tick
                                                 m_isPeriodic = false;
                                                 break;
                                         }
                                     }
                                 }
                             }
                             break;
                         case 58549: // Tenacity
                         case 59911: // Tenacity (vehicle)
                            GetBase()->RefreshDuration();
                            break;
                         case 66823: case 67618: case 67619: case 67620: // Paralytic Toxin
                             // Get 0 effect aura
                             if (AuraEffect* slow = GetBase()->GetEffect(0))
                             {
                                 int32 newAmount = slow->GetAmount() - 10;
                                 if (newAmount < -100)
                                     newAmount = -100;
                                 slow->ChangeAmount(newAmount);
                             }
                             break;
                         default:
                             break;
                     }
                     break;
                 case SPELLFAMILY_MAGE:
                     if (GetId() == 55342)// Mirror Image
                         m_isPeriodic = false;
                     break;
                 case SPELLFAMILY_DEATHKNIGHT:
                     // Chains of Ice
                     if (GetSpellInfo()->SpellFamilyFlags[1] & 0x00004000)
                     {
                         // Get 0 effect aura
                         if (AuraEffect* slow = GetBase()->GetEffect(0))
                         {
                             int32 newAmount = slow->GetAmount() + GetAmount();
                             if (newAmount > 0)
                                 newAmount = 0;
                             slow->ChangeAmount(newAmount);
                         }
                         return;
                     }
                     break;
                 default:
                     break;
            }
        default:
            break;
     }
     GetBase()->CallScriptEffectUpdatePeriodicHandlers(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

void Aura::_InitEffects	(	uint32	effMask,
		Unit *	caster,
		int32 *	baseAmount
	)

friend

Aura* Unit::_TryStackingOrRefreshingExistingAura	(	SpellInfo const *	newAura,
		uint32	effMask,
		Unit *	caster,
		int32 *	baseAmount,
		Item *	castItem,
		ObjectGuid	casterGUID,
		int32	castItemLevel
	)

friend

Member Data Documentation

SpellEffectInfo const* AuraEffect::_effectInfo

private

int32 AuraEffect::m_amount

private

Aura* const AuraEffect::m_base

private

int32 const AuraEffect::m_baseAmount

private

bool AuraEffect::m_canBeRecalculated

private

float AuraEffect::m_critChance

private

int32 AuraEffect::m_damage

private

float AuraEffect::m_donePct

private

uint8 const AuraEffect::m_effIndex

private

bool AuraEffect::m_isPeriodic

private

int32 AuraEffect::m_period

private

int32 AuraEffect::m_periodicTimer

private

SpellInfo const* const AuraEffect::m_spellInfo

private

SpellModifier* AuraEffect::m_spellmod

private

uint32 AuraEffect::m_tickNumber

private

The documentation for this class was generated from the following files:

src/server/game/Spells/Auras/SpellAuraEffects.h
src/server/game/Spells/Auras/SpellAuraEffects.cpp

Public Member Functions

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation