TrinityCore: Unit Class Reference

MovementInfo::AddExtraMovementFlag

MovementInfo m_movementInfo

Definition: Object.h:612

void AddExtraMovementFlag(uint16 flag)

Definition: Object.h:334

Here is the caller graph for this function:

void Unit::addFollower ( FollowerReference * pRef )

inline

2098 { m_FollowingRefManager.insertFirst(pRef); }

Unit::m_FollowingRefManager

FollowerRefManager m_FollowingRefManager

Definition: Unit.h:2348

LinkedListHead::insertFirst

void insertFirst(LinkedListElement *pElem)

Definition: LinkedList.h:110

Here is the caller graph for this function:

void Unit::AddGameObject ( GameObject * gameObj )

 {
     if (!gameObj || !gameObj->GetOwnerGUID().IsEmpty())
         return;
 
     m_gameObj.push_back(gameObj);
     gameObj->SetOwnerGUID(GetGUID());
 
     if (gameObj->GetSpellId())
     {
         SpellInfo const* createBySpell = sSpellMgr->GetSpellInfo(gameObj->GetSpellId());
         // Need disable spell use for owner
         if (createBySpell && createBySpell->IsCooldownStartedOnEvent())
             // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existing cases)
             GetSpellHistory()->StartCooldown(createBySpell, 0, nullptr, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::addHatedBy ( HostileReference * pHostileReference )

inline

1999 { m_HostileRefManager.insertFirst(pHostileReference); }

Unit::m_HostileRefManager

HostileRefManager m_HostileRefManager

Definition: Unit.h:2346

LinkedListHead::insertFirst

void insertFirst(LinkedListElement *pElem)

Definition: LinkedList.h:110

Here is the caller graph for this function:

void Unit::AddInterruptMask ( uint32 mask )

inline

2009 { m_interruptMask |= mask; }

Unit::m_interruptMask

uint32 m_interruptMask

Definition: Unit.h:2283

Here is the caller graph for this function:

void Unit::AddPetAura ( PetAura const * petSpell )

 {
     if (GetTypeId() != TYPEID_PLAYER)
         return;
 
     m_petAuras.insert(petSpell);
     if (Pet* pet = ToPlayer()->GetPet())
         pet->CastPetAura(petSpell);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::AddPlayerToVision ( Player * player )

 {
     if (m_sharedVision.empty())
     {
         setActive(true);
         SetWorldObject(true);
     }
     m_sharedVision.push_back(player);
 }

Here is the call graph for this function:

void Unit::AddThreat	(	Unit *	victim,
		float	fThreat,
		SpellSchoolMask	schoolMask = `SPELL_SCHOOL_MASK_NORMAL`,
		SpellInfo const *	threatSpell = `NULL`
	)

 {
     // Only mobs can manage threat lists
     if (CanHaveThreatList())
         m_ThreatManager.addThreat(victim, fThreat, schoolMask, threatSpell);
 }

Here is the call graph for this function:

void Unit::AddToWorld ( )

overridevirtual

Reimplemented from Object.

 {
     if (!IsInWorld())
     {
         WorldObject::AddToWorld();
     }
     RebuildTerrainSwaps();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::AddUnitMovementFlag ( uint32 f )

inline

2107 { m_movementInfo.AddMovementFlag(f); }

MovementInfo::AddMovementFlag

MovementInfo m_movementInfo

Definition: Object.h:612

void AddMovementFlag(uint32 flag)

Definition: Object.h:328

Here is the caller graph for this function:

void Unit::AddUnitState ( uint32 f )

inline

1394 { m_state |= f; }

Unit::m_state

uint32 m_state

Definition: Unit.h:2340

Here is the caller graph for this function:

void Unit::AddUnitTypeMask ( uint32 mask )

inline

1400 { m_unitTypeMask |= mask; }

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

void Unit::ApplyAttackTimePercentMod	(	WeaponAttackType	att,
		float	val,
		bool	apply
	)

 {
     float remainingTimePct = (float)m_attackTimer[att] / (GetAttackTime(att) * m_modAttackSpeedPct[att]);
     if (val > 0)
     {
         ApplyPercentModFloatVar(m_modAttackSpeedPct[att], val, !apply);
         ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME+att, val, !apply);
 
         if (GetTypeId() == TYPEID_PLAYER)
         {
             if (att == BASE_ATTACK)
                 ApplyPercentModFloatValue(UNIT_FIELD_MOD_HASTE, val, !apply);
             else if (att == RANGED_ATTACK)
                 ApplyPercentModFloatValue(UNIT_FIELD_MOD_RANGED_HASTE, val, !apply);
         }
     }
     else
     {
         ApplyPercentModFloatVar(m_modAttackSpeedPct[att], -val, apply);
         ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME+att, -val, apply);
 
         if (GetTypeId() == TYPEID_PLAYER)
         {
             if (att == BASE_ATTACK)
                 ApplyPercentModFloatValue(UNIT_FIELD_MOD_HASTE, -val, apply);
             else if (att == RANGED_ATTACK)
                 ApplyPercentModFloatValue(UNIT_FIELD_MOD_RANGED_HASTE, -val, apply);
         }
     }
     m_attackTimer[att] = uint32(GetAttackTime(att) * m_modAttackSpeedPct[att] * remainingTimePct);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyCastTimePercentMod	(	float	val,
		bool	apply
	)

 {
     if (val > 0)
     {
         ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, val, !apply);
         ApplyPercentModFloatValue(UNIT_MOD_CAST_HASTE, val, !apply);
     }
     else
     {
         ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, -val, apply);
         ApplyPercentModFloatValue(UNIT_MOD_CAST_HASTE, -val, apply);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyDiminishingAura	(	DiminishingGroup	group,
		bool	apply
	)

 {
     // Checking for existing in the table
     for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
     {
         if (i->DRGroup != group)
             continue;
 
         if (apply)
             i->stack += 1;
         else if (i->stack)
         {
             i->stack -= 1;
             // Remember time after last aura from group removed
             if (i->stack == 0)
                 i->hitTime = getMSTime();
         }
         break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::ApplyDiminishingToDuration	(	DiminishingGroup	group,
		int32 &	duration,
		Unit *	caster,
		DiminishingLevels	Level,
		int32	limitduration
	)

 {
     if (duration == -1 || group == DIMINISHING_NONE)
         return 1.0f;
 
     // test pet/charm masters instead pets/charmeds
     Unit const* targetOwner = GetCharmerOrOwner();
     Unit const* casterOwner = caster->GetCharmerOrOwner();
 
     if (limitduration > 0 && duration > limitduration)
     {
         Unit const* target = targetOwner ? targetOwner : this;
         Unit const* source = casterOwner ? casterOwner : caster;
 
         if ((target->GetTypeId() == TYPEID_PLAYER
             || (target->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH))
             && source->GetTypeId() == TYPEID_PLAYER)
             duration = limitduration;
     }
 
     float mod = 1.0f;
 
     switch (group)
     {
         case DIMINISHING_TAUNT:
         {
             if (GetTypeId() == TYPEID_UNIT && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_TAUNT_DIMINISH))
             {
                 DiminishingLevels diminish = Level;
                 switch (diminish)
                 {
                     case DIMINISHING_LEVEL_1: break;
                     case DIMINISHING_LEVEL_2: mod = 0.65f; break;
                     case DIMINISHING_LEVEL_3: mod = 0.4225f; break;
                     case DIMINISHING_LEVEL_4: mod = 0.274625f; break;
                     case DIMINISHING_LEVEL_TAUNT_IMMUNE: mod = 0.0f; break;
                     default: break;
                 }
             }
             break;
         }
         case DIMINISHING_AOE_KNOCKBACK:
         {
             if ((GetDiminishingReturnsGroupType(group) == DRTYPE_PLAYER && (((targetOwner ? targetOwner : this)->ToPlayer())
                 || (ToCreature() && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH))))
                 || GetDiminishingReturnsGroupType(group) == DRTYPE_ALL)
             {
                 DiminishingLevels diminish = Level;
                 switch (diminish)
                 {
                     case DIMINISHING_LEVEL_1: break;
                     case DIMINISHING_LEVEL_2: mod = 0.0f; break;
                     default: break;
                 }
             }
             break;
         }
         default:
         {
             if ((GetDiminishingReturnsGroupType(group) == DRTYPE_PLAYER && (((targetOwner ? targetOwner : this)->ToPlayer())
                 || (ToCreature() && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH))))
                 || GetDiminishingReturnsGroupType(group) == DRTYPE_ALL)
             {
                 DiminishingLevels diminish = Level;
                 switch (diminish)
                 {
                     case DIMINISHING_LEVEL_1: break;
                     case DIMINISHING_LEVEL_2: mod = 0.5f; break;
                     case DIMINISHING_LEVEL_3: mod = 0.25f; break;
                     case DIMINISHING_LEVEL_IMMUNE: mod = 0.0f; break;
                     default: break;
                 }
             }
             break;
         }
     }
 
     duration = int32(duration * mod);
     return mod;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::ApplyEffectModifiers	(	SpellInfo const *	spellProto,
		uint8	effect_index,
		float	value
	)		const

 {
     if (Player* modOwner = GetSpellModOwner())
     {
         modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_ALL_EFFECTS, value);
         switch (effect_index)
         {
             case 0:
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT1, value);
                 break;
             case 1:
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT2, value);
                 break;
             case 2:
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT3, value);
                 break;
             case 3:
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT4, value);
                 break;
             case 4:
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT5, value);
                 break;
         }
     }
     return value;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyResilience	(	Unit const *	victim,
		int32 *	damage
	)		const

 {
     // player mounted on multi-passenger mount is also classified as vehicle
     if (IsVehicle() || (victim->IsVehicle() && victim->GetTypeId() != TYPEID_PLAYER))
         return;
 
     // Don't consider resilience if not in PvP - player or pet
     if (!GetCharmerOrOwnerPlayerOrPlayerItself())
         return;
 
     Unit const* target = NULL;
     if (victim->GetTypeId() == TYPEID_PLAYER)
         target = victim;
     else if (victim->GetTypeId() == TYPEID_UNIT && victim->GetOwner() && victim->GetOwner()->GetTypeId() == TYPEID_PLAYER)
         target = victim->GetOwner();
 
     if (!target)
         return;
 
     *damage -= target->GetDamageReduction(*damage);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyResistanceBuffModsMod	(	SpellSchools	school,
		bool	positive,
		float	val,
		bool	apply
	)

 {
     ApplyModSignedFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyResistanceBuffModsPercentMod	(	SpellSchools	school,
		bool	positive,
		float	val,
		bool	apply
	)

 {
     ApplyPercentModFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplySpellDispelImmunity	(	const SpellInfo *	spellProto,
		DispelType	type,
		bool	apply
	)

 {
     ApplySpellImmune(spellProto->Id, IMMUNITY_DISPEL, type, apply);
 
     if (apply && spellProto->HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY))
     {
         // Create dispel mask by dispel type
         uint32 dispelMask = SpellInfo::GetDispelMask(type);
         // Dispel all existing auras vs current dispel type
         AuraApplicationMap& auras = GetAppliedAuras();
         for (AuraApplicationMap::iterator itr = auras.begin(); itr != auras.end();)
         {
             SpellInfo const* spell = itr->second->GetBase()->GetSpellInfo();
             if (spell->GetDispelMask() & dispelMask)
             {
                 // Dispel aura
                 RemoveAura(itr);
             }
             else
                 ++itr;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplySpellImmune	(	uint32	spellId,
		uint32	op,
		uint32	type,
		bool	apply
	)

 {
     if (apply)
     {
         for (SpellImmuneList::iterator itr = m_spellImmune[op].begin(), next; itr != m_spellImmune[op].end(); itr = next)
         {
             next = itr; ++next;
             if (itr->type == type)
             {
                 m_spellImmune[op].erase(itr);
                 next = m_spellImmune[op].begin();
             }
         }
         SpellImmune Immune;
         Immune.spellId = spellId;
         Immune.type = type;
         m_spellImmune[op].push_back(Immune);
     }
     else
     {
         for (SpellImmuneList::iterator itr = m_spellImmune[op].begin(); itr != m_spellImmune[op].end(); ++itr)
         {
             if (itr->spellId == spellId && itr->type == type)
             {
                 m_spellImmune[op].erase(itr);
                 break;
             }
         }
     }
 }

Here is the call graph for this function:

void Unit::ApplyStatBuffMod	(	Stats	stat,
		float	val,
		bool	apply
	)

 {
     ApplyModSignedFloatValue((val > 0 ? UNIT_FIELD_POSSTAT+stat : UNIT_FIELD_NEGSTAT+stat), val, apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ApplyStatPercentBuffMod	(	Stats	stat,
		float	val,
		bool	apply
	)

 {
     ApplyPercentModFloatValue(UNIT_FIELD_POSSTAT+stat, val, apply);
     ApplyPercentModFloatValue(UNIT_FIELD_NEGSTAT+stat, val, apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::ApplyTotalThreatModifier	(	float	fThreat,
		SpellSchoolMask	schoolMask = `SPELL_SCHOOL_MASK_NORMAL`
	)

 {
     if (!HasAuraType(SPELL_AURA_MOD_THREAT) || fThreat < 0)
         return fThreat;
 
     SpellSchools school = GetFirstSchoolInMask(schoolMask);
 
     return fThreat * m_threatModifier[school];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::Attack	(	Unit *	victim,
		bool	meleeAttack
	)

 {
     if (!victim || victim == this)
         return false;
 
     // dead units can neither attack nor be attacked
     if (!IsAlive() || !victim->IsInWorld() || !victim->IsAlive())
         return false;
 
     // player cannot attack in mount state
     if (GetTypeId() == TYPEID_PLAYER && IsMounted())
         return false;
 
     if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
         return false;
 
     // nobody can attack GM in GM-mode
     if (victim->GetTypeId() == TYPEID_PLAYER)
     {
         if (victim->ToPlayer()->IsGameMaster())
             return false;
     }
     else
     {
         if (victim->ToCreature()->IsInEvadeMode())
             return false;
     }
 
     // remove SPELL_AURA_MOD_UNATTACKABLE at attack (in case non-interruptible spells stun aura applied also that not let attack)
     if (HasAuraType(SPELL_AURA_MOD_UNATTACKABLE))
         RemoveAurasByType(SPELL_AURA_MOD_UNATTACKABLE);
 
     if (m_shouldReacquireTarget)
     {
         SetTarget(victim->GetGUID());
         m_shouldReacquireTarget = false;
     }
 
     if (m_attacking)
     {
         if (m_attacking == victim)
         {
             // switch to melee attack from ranged/magic
             if (meleeAttack)
             {
                 if (!HasUnitState(UNIT_STATE_MELEE_ATTACKING))
                 {
                     AddUnitState(UNIT_STATE_MELEE_ATTACKING);
                     SendMeleeAttackStart(victim);
                     return true;
                 }
             }
             else if (HasUnitState(UNIT_STATE_MELEE_ATTACKING))
             {
                 ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                 SendMeleeAttackStop(victim);
                 return true;
             }
             return false;
         }
 
         // switch target
         InterruptSpell(CURRENT_MELEE_SPELL);
         if (!meleeAttack)
             ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
     }
 
     if (m_attacking)
         m_attacking->_removeAttacker(this);
 
     m_attacking = victim;
     m_attacking->_addAttacker(this);
 
     // Set our target
     SetTarget(victim->GetGUID());
 
     if (meleeAttack)
         AddUnitState(UNIT_STATE_MELEE_ATTACKING);
 
     // set position before any AI calls/assistance
     //if (GetTypeId() == TYPEID_UNIT)
     //    ToCreature()->SetCombatStartPosition(GetPositionX(), GetPositionY(), GetPositionZ());
 
     if (GetTypeId() == TYPEID_UNIT && !IsPet())
     {
         // should not let player enter combat by right clicking target - doesn't helps
         SetInCombatWith(victim);
         if (victim->GetTypeId() == TYPEID_PLAYER)
             victim->SetInCombatWith(this);
         AddThreat(victim, 0.0f);
 
         ToCreature()->SendAIReaction(AI_REACTION_HOSTILE);
         ToCreature()->CallAssistance();
     }
 
     // delay offhand weapon attack to next attack time
     if (haveOffhandWeapon())
         resetAttackTimer(OFF_ATTACK);
 
     if (meleeAttack)
         SendMeleeAttackStart(victim);
 
     // Let the pet know we've started attacking someting. Handles melee attacks only
     // Spells such as auto-shot and others handled in WorldSession::HandleCastSpellOpcode
     if (this->GetTypeId() == TYPEID_PLAYER)
     {
         Pet* playerPet = this->ToPlayer()->GetPet();
 
         if (playerPet && playerPet->IsAlive())
             playerPet->AI()->OwnerAttacked(victim);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::AttackerStateUpdate	(	Unit *	victim,
		WeaponAttackType	attType = `BASE_ATTACK`,
		bool	extra = `false`
	)

 {
     if (HasUnitState(UNIT_STATE_CANNOT_AUTOATTACK) || HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
         return;
 
     if (!victim->IsAlive())
         return;
 
     if ((attType == BASE_ATTACK || attType == OFF_ATTACK) && !IsWithinLOSInMap(victim))
         return;
 
     CombatStart(victim);
     RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MELEE_ATTACK);
 
     if (attType != BASE_ATTACK && attType != OFF_ATTACK)
         return;                                             // ignore ranged case
 
     if (GetTypeId() == TYPEID_UNIT && !HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED))
         SetFacingToObject(victim); // update client side facing to face the target (prevents visual glitches when casting untargeted spells)
 
     // melee attack spell cast at main hand attack only - no normal melee dmg dealt
     if (attType == BASE_ATTACK && m_currentSpells[CURRENT_MELEE_SPELL] && !extra)
         m_currentSpells[CURRENT_MELEE_SPELL]->cast();
     else
     {
         // attack can be redirected to another target
         victim = GetMeleeHitRedirectTarget(victim);
 
         CalcDamageInfo damageInfo;
         CalculateMeleeDamage(victim, 0, &damageInfo, attType);
         // Send log damage message to client
         DealDamageMods(victim, damageInfo.damage, &damageInfo.absorb);
         SendAttackStateUpdate(&damageInfo);
 
         //TriggerAurasProcOnEvent(damageInfo);
         ProcDamageAndSpell(damageInfo.target, damageInfo.procAttacker, damageInfo.procVictim, damageInfo.procEx, damageInfo.damage, damageInfo.attackType);
 
         DealMeleeDamage(&damageInfo, true);
 
         TC_LOG_DEBUG("entities.unit", "AttackerStateUpdate: %s attacked %s for %u dmg, absorbed %u, blocked %u, resisted %u.",
             GetGUID().ToString().c_str(), victim->GetGUID().ToString().c_str(), damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount, damageInfo.resist);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::AttackStop ( )

 {
     if (!m_attacking)
         return false;
 
     Unit* victim = m_attacking;
 
     m_attacking->_removeAttacker(this);
     m_attacking = nullptr;
 
     // Clear our target
     SetTarget(ObjectGuid::Empty);
 
     ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
 
     InterruptSpell(CURRENT_MELEE_SPELL);
 
     // reset only at real combat stop
     if (Creature* creature = ToCreature())
     {
         creature->SetNoCallAssistance(false);
 
         if (creature->HasSearchedAssistance())
         {
             creature->SetNoSearchAssistance(false);
             UpdateSpeed(MOVE_RUN, false);
         }
     }
 
     SendMeleeAttackStop(victim);
 
     return true;
 }

Here is the call graph for this function:

uint32 Unit::BuildAuraStateUpdateForTarget ( Unit * target ) const

 {
     uint32 auraStates = GetUInt32Value(UNIT_FIELD_AURASTATE) &~(PER_CASTER_AURA_STATE_MASK);
     for (AuraStateAurasMap::const_iterator itr = m_auraStateAuras.begin(); itr != m_auraStateAuras.end(); ++itr)
         if ((1<<(itr->first-1)) & PER_CASTER_AURA_STATE_MASK)
             if (itr->second->GetBase()->GetCasterGUID() == target->GetGUID())
                 auraStates |= (1<<(itr->first-1));
 
     return auraStates;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::BuildValuesUpdate	(	uint8	updatetype,
		ByteBuffer *	data,
		Player *	target
	)		const

overrideprotectedvirtual

Reimplemented from Object.

 {
     if (!target)
         return;
 
     ByteBuffer fieldBuffer;
     UpdateMask updateMask;
 
     uint32 valCount = m_valuesCount;
 
     uint32* flags = UnitUpdateFieldFlags;
     uint32 visibleFlag = UF_FLAG_PUBLIC;
 
     if (target == this)
         visibleFlag |= UF_FLAG_PRIVATE;
     else if (GetTypeId() == TYPEID_PLAYER)
         valCount = PLAYER_FIELD_END_NOT_SELF;
 
     updateMask.SetCount(valCount);
 
     Player* plr = GetCharmerOrOwnerPlayerOrPlayerItself();
     if (GetOwnerGUID() == target->GetGUID())
         visibleFlag |= UF_FLAG_OWNER;
 
     if (HasFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO))
         if (HasAuraTypeWithCaster(SPELL_AURA_EMPATHY, target->GetGUID()))
             visibleFlag |= UF_FLAG_SPECIAL_INFO;
 
     if (plr && plr->IsInSameRaidWith(target))
         visibleFlag |= UF_FLAG_PARTY_MEMBER;
 
     Creature const* creature = ToCreature();
     for (uint16 index = 0; index < valCount; ++index)
     {
         if (_fieldNotifyFlags & flags[index] ||
             ((flags[index] & visibleFlag) & UF_FLAG_SPECIAL_INFO) ||
             ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
             (index == UNIT_FIELD_AURASTATE && HasFlag(UNIT_FIELD_AURASTATE, PER_CASTER_AURA_STATE_MASK)))
         {
             updateMask.SetBit(index);
 
             if (index == UNIT_NPC_FLAGS)
             {
                 uint32 appendValue = m_uint32Values[UNIT_NPC_FLAGS];
 
                 if (creature)
                     if (!target->CanSeeSpellClickOn(creature))
                         appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
 
                 fieldBuffer << uint32(appendValue);
             }
             else if (index == UNIT_FIELD_AURASTATE)
             {
                 // Check per caster aura states to not enable using a spell in client if specified aura is not by target
                 fieldBuffer << BuildAuraStateUpdateForTarget(target);
             }
             // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
             else if (index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
             {
                 // convert from float to uint32 and send
                 fieldBuffer << uint32(m_floatValues[index] < 0 ? 0 : m_floatValues[index]);
             }
             // there are some float values which may be negative or can't get negative due to other checks
             else if ((index >= UNIT_FIELD_NEGSTAT && index < UNIT_FIELD_NEGSTAT + 5) ||
                 (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
                 (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
                 (index >= UNIT_FIELD_POSSTAT && index < UNIT_FIELD_POSSTAT + 5))
             {
                 fieldBuffer << uint32(m_floatValues[index]);
             }
             // Gamemasters should be always able to select units - remove not selectable flag
             else if (index == UNIT_FIELD_FLAGS)
             {
                 uint32 appendValue = m_uint32Values[UNIT_FIELD_FLAGS];
                 if (target->IsGameMaster())
                     appendValue &= ~UNIT_FLAG_NOT_SELECTABLE;
 
                 fieldBuffer << uint32(appendValue);
             }
             // use modelid_a if not gm, _h if gm for CREATURE_FLAG_EXTRA_TRIGGER creatures
             else if (index == UNIT_FIELD_DISPLAYID)
             {
                 uint32 displayId = m_uint32Values[UNIT_FIELD_DISPLAYID];
                 if (creature)
                 {
                     CreatureTemplate const* cinfo = creature->GetCreatureTemplate();
 
                     // this also applies for transform auras
                     if (SpellInfo const* transform = sSpellMgr->GetSpellInfo(getTransForm()))
                         for (SpellEffectInfo const* effect : transform->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
                             if (effect && effect->IsAura(SPELL_AURA_TRANSFORM))
                                 if (CreatureTemplate const* transformInfo = sObjectMgr->GetCreatureTemplate(effect->MiscValue))
                                 {
                                     cinfo = transformInfo;
                                     break;
                                 }
 
                     if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER)
                         if (target->IsGameMaster())
                             displayId = cinfo->GetFirstVisibleModel();
                 }
 
                 fieldBuffer << uint32(displayId);
             }
             // hide lootable animation for unallowed players
             else if (index == OBJECT_DYNAMIC_FLAGS)
             {
                 uint32 dynamicFlags = m_uint32Values[OBJECT_DYNAMIC_FLAGS] & ~(UNIT_DYNFLAG_TAPPED | UNIT_DYNFLAG_TAPPED_BY_PLAYER);
 
                 if (creature)
                 {
                     if (creature->hasLootRecipient())
                     {
                         dynamicFlags |= UNIT_DYNFLAG_TAPPED;
                         if (creature->isTappedBy(target))
                             dynamicFlags |= UNIT_DYNFLAG_TAPPED_BY_PLAYER;
                     }
 
                     if (!target->isAllowedToLoot(creature))
                         dynamicFlags &= ~UNIT_DYNFLAG_LOOTABLE;
                 }
 
                 // unit UNIT_DYNFLAG_TRACK_UNIT should only be sent to caster of SPELL_AURA_MOD_STALKED auras
                 if (dynamicFlags & UNIT_DYNFLAG_TRACK_UNIT)
                     if (!HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, target->GetGUID()))
                         dynamicFlags &= ~UNIT_DYNFLAG_TRACK_UNIT;
 
                 fieldBuffer << dynamicFlags;
             }
             // FG: pretend that OTHER players in own group are friendly ("blue")
             else if (index == UNIT_FIELD_BYTES_2 || index == UNIT_FIELD_FACTIONTEMPLATE)
             {
                 if (IsControlledByPlayer() && target != this && sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && IsInRaidWith(target))
                 {
                     FactionTemplateEntry const* ft1 = GetFactionTemplateEntry();
                     FactionTemplateEntry const* ft2 = target->GetFactionTemplateEntry();
                     if (ft1 && ft2 && !ft1->IsFriendlyTo(*ft2))
                     {
                         if (index == UNIT_FIELD_BYTES_2)
                             // Allow targetting opposite faction in party when enabled in config
                             fieldBuffer << (m_uint32Values[UNIT_FIELD_BYTES_2] & ((UNIT_BYTE2_FLAG_SANCTUARY /*| UNIT_BYTE2_FLAG_AURAS | UNIT_BYTE2_FLAG_UNK5*/) << 8)); // this flag is at uint8 offset 1 !!
                         else
                             // pretend that all other HOSTILE players have own faction, to allow follow, heal, rezz (trade wont work)
                             fieldBuffer << uint32(target->getFaction());
                     }
                     else
                         fieldBuffer << m_uint32Values[index];
                 }
                 else
                     fieldBuffer << m_uint32Values[index];
             }
             else
             {
                 // send in current format (float as float, uint32 as uint32)
                 fieldBuffer << m_uint32Values[index];
             }
         }
     }
 
     *data << uint8(updateMask.GetBlockCount());
     updateMask.AppendToPacket(data);
     data->append(fieldBuffer);
 }

Here is the call graph for this function:

void Unit::CalcAbsorbResist	(	Unit *	victim,
		SpellSchoolMask	schoolMask,
		DamageEffectType	damagetype,
		uint32 const	damage,
		uint32 *	absorb,
		uint32 *	resist,
		SpellInfo const *	spellInfo = `NULL`
	)

 {
     if (!victim || !victim->IsAlive() || !damage)
         return;
 
     DamageInfo dmgInfo = DamageInfo(this, victim, damage, spellInfo, schoolMask, damagetype);
 
     uint32 spellResistance = CalcSpellResistance(victim, schoolMask, spellInfo);
     dmgInfo.ResistDamage(CalculatePct(damage, spellResistance));
 
     // Ignore Absorption Auras
     float auraAbsorbMod = 0;
     AuraEffectList const& AbsIgnoreAurasA = GetAuraEffectsByType(SPELL_AURA_MOD_TARGET_ABSORB_SCHOOL);
     for (AuraEffectList::const_iterator itr = AbsIgnoreAurasA.begin(); itr != AbsIgnoreAurasA.end(); ++itr)
     {
         if (!((*itr)->GetMiscValue() & schoolMask))
             continue;
 
         if ((*itr)->GetAmount() > auraAbsorbMod)
             auraAbsorbMod = float((*itr)->GetAmount());
     }
 
     AuraEffectList const& AbsIgnoreAurasB = GetAuraEffectsByType(SPELL_AURA_MOD_TARGET_ABILITY_ABSORB_SCHOOL);
     for (AuraEffectList::const_iterator itr = AbsIgnoreAurasB.begin(); itr != AbsIgnoreAurasB.end(); ++itr)
     {
         if (!((*itr)->GetMiscValue() & schoolMask))
             continue;
 
         if (((*itr)->GetAmount() > auraAbsorbMod) && (*itr)->IsAffectingSpell(spellInfo))
             auraAbsorbMod = float((*itr)->GetAmount());
     }
 
     RoundToInterval(auraAbsorbMod, 0.0f, 100.0f);
 
     int32 absorbIgnoringDamage = CalculatePct(dmgInfo.GetDamage(), auraAbsorbMod);
     dmgInfo.ModifyDamage(-absorbIgnoringDamage);
 
     // We're going to call functions which can modify content of the list during iteration over it's elements
     // Let's copy the list so we can prevent iterator invalidation
     AuraEffectList vSchoolAbsorbCopy(victim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_ABSORB));
     vSchoolAbsorbCopy.sort(Trinity::AbsorbAuraOrderPred());
 
     // absorb without mana cost
     for (AuraEffectList::iterator itr = vSchoolAbsorbCopy.begin(); (itr != vSchoolAbsorbCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
     {
         AuraEffect* absorbAurEff = *itr;
         // Check if aura was removed during iteration - we don't need to work on such auras
         AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
         if (!aurApp)
             continue;
         if (!(absorbAurEff->GetMiscValue() & schoolMask))
             continue;
 
         // get amount which can be still absorbed by the aura
         int32 currentAbsorb = absorbAurEff->GetAmount();
         // aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
         if (currentAbsorb < 0)
             currentAbsorb = 0;
 
         uint32 tempAbsorb = uint32(currentAbsorb);
 
         bool defaultPrevented = false;
 
         absorbAurEff->GetBase()->CallScriptEffectAbsorbHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb, defaultPrevented);
         currentAbsorb = tempAbsorb;
 
         if (defaultPrevented)
             continue;
 
         // absorb must be smaller than the damage itself
         currentAbsorb = RoundToInterval(currentAbsorb, 0, int32(dmgInfo.GetDamage()));
 
         dmgInfo.AbsorbDamage(currentAbsorb);
 
         tempAbsorb = currentAbsorb;
         absorbAurEff->GetBase()->CallScriptEffectAfterAbsorbHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb);
 
         // Check if our aura is using amount to count damage
         if (absorbAurEff->GetAmount() >= 0)
         {
             // Reduce shield amount
             absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
             // Aura cannot absorb anything more - remove it
             if (absorbAurEff->GetAmount() <= 0)
                 absorbAurEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
         }
     }
 
     // absorb by mana cost
     AuraEffectList vManaShieldCopy(victim->GetAuraEffectsByType(SPELL_AURA_MANA_SHIELD));
     for (AuraEffectList::const_iterator itr = vManaShieldCopy.begin(); (itr != vManaShieldCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
     {
         AuraEffect* absorbAurEff = *itr;
         // Check if aura was removed during iteration - we don't need to work on such auras
         AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
         if (!aurApp)
             continue;
         // check damage school mask
         if (!(absorbAurEff->GetMiscValue() & schoolMask))
             continue;
 
         // get amount which can be still absorbed by the aura
         int32 currentAbsorb = absorbAurEff->GetAmount();
         // aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
         if (currentAbsorb < 0)
             currentAbsorb = 0;
 
         uint32 tempAbsorb = currentAbsorb;
 
         bool defaultPrevented = false;
 
         absorbAurEff->GetBase()->CallScriptEffectManaShieldHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb, defaultPrevented);
         currentAbsorb = tempAbsorb;
 
         if (defaultPrevented)
             continue;
 
         // absorb must be smaller than the damage itself
         currentAbsorb = RoundToInterval(currentAbsorb, 0, int32(dmgInfo.GetDamage()));
 
         int32 manaReduction = currentAbsorb;
 
         // lower absorb amount by talents
         if (float manaMultiplier = absorbAurEff->GetSpellEffectInfo()->CalcValueMultiplier(absorbAurEff->GetCaster()))
             manaReduction = int32(float(manaReduction) * manaMultiplier);
 
         int32 manaTaken = -victim->ModifyPower(POWER_MANA, -manaReduction);
 
         // take case when mana has ended up into account
         currentAbsorb = currentAbsorb ? int32(float(currentAbsorb) * (float(manaTaken) / float(manaReduction))) : 0;
 
         dmgInfo.AbsorbDamage(currentAbsorb);
 
         tempAbsorb = currentAbsorb;
         absorbAurEff->GetBase()->CallScriptEffectAfterManaShieldHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb);
 
         // Check if our aura is using amount to count damage
         if (absorbAurEff->GetAmount() >= 0)
         {
             absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
             if ((absorbAurEff->GetAmount() <= 0))
                 absorbAurEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
         }
     }
 
     dmgInfo.ModifyDamage(absorbIgnoringDamage);
 
     // split damage auras - only when not damaging self
     if (victim != this)
     {
         // We're going to call functions which can modify content of the list during iteration over it's elements
         // Let's copy the list so we can prevent iterator invalidation
         AuraEffectList vSplitDamagePctCopy(victim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_PCT));
         for (AuraEffectList::iterator itr = vSplitDamagePctCopy.begin(); itr != vSplitDamagePctCopy.end() && dmgInfo.GetDamage() > 0; ++itr)
         {
             // Check if aura was removed during iteration - we don't need to work on such auras
             AuraApplication const* aurApp = (*itr)->GetBase()->GetApplicationOfTarget(victim->GetGUID());
             if (!aurApp)
                 continue;
 
             // check damage school mask
             if (!((*itr)->GetMiscValue() & schoolMask))
                 continue;
 
             // Damage can be splitted only if aura has an alive caster
             Unit* caster = (*itr)->GetCaster();
             if (!caster || (caster == victim) || !caster->IsInWorld() || !caster->IsAlive())
                 continue;
 
             uint32 splitDamage = CalculatePct(dmgInfo.GetDamage(), (*itr)->GetAmount());
 
             (*itr)->GetBase()->CallScriptEffectSplitHandlers((*itr), aurApp, dmgInfo, splitDamage);
 
             // absorb must be smaller than the damage itself
             splitDamage = RoundToInterval(splitDamage, uint32(0), uint32(dmgInfo.GetDamage()));
 
             dmgInfo.AbsorbDamage(splitDamage);
 
             // check if caster is immune to damage
             if (caster->IsImmunedToDamage(schoolMask))
             {
                 victim->SendSpellMiss(caster, (*itr)->GetSpellInfo()->Id, SPELL_MISS_IMMUNE);
                 continue;
             }
 
             uint32 split_absorb = 0;
             DealDamageMods(caster, splitDamage, &split_absorb);
 
             SpellNonMeleeDamage log(this, caster, (*itr)->GetSpellInfo()->Id, schoolMask);
             CleanDamage cleanDamage = CleanDamage(splitDamage, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
             DealDamage(caster, splitDamage, &cleanDamage, DIRECT_DAMAGE, schoolMask, (*itr)->GetSpellInfo(), false);
             log.damage = splitDamage;
             log.absorb = split_absorb;
             SendSpellNonMeleeDamageLog(&log);
 
             // break 'Fear' and similar auras
             caster->ProcDamageAndSpellFor(true, this, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_NORMAL_HIT, BASE_ATTACK, (*itr)->GetSpellInfo(), splitDamage);
         }
     }
 
     *resist = dmgInfo.GetResist();
     *absorb = dmgInfo.GetAbsorb();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::CalcArmorReducedDamage	(	Unit *	victim,
		const uint32	damage,
		SpellInfo const *	spellInfo,
		WeaponAttackType	attackType = `MAX_ATTACK`
	)

 {
     float armor = float(victim->GetArmor());
 
     // bypass enemy armor by SPELL_AURA_BYPASS_ARMOR_FOR_CASTER
     int32 armorBypassPct = 0;
     AuraEffectList const & reductionAuras = victim->GetAuraEffectsByType(SPELL_AURA_BYPASS_ARMOR_FOR_CASTER);
     for (AuraEffectList::const_iterator i = reductionAuras.begin(); i != reductionAuras.end(); ++i)
         if ((*i)->GetCasterGUID() == GetGUID())
             armorBypassPct += (*i)->GetAmount();
     armor = CalculatePct(armor, 100 - std::min(armorBypassPct, 100));
 
     // Ignore enemy armor by SPELL_AURA_MOD_TARGET_RESISTANCE aura
     armor += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, SPELL_SCHOOL_MASK_NORMAL);
 
     if (spellInfo)
         if (Player* modOwner = GetSpellModOwner())
             modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_IGNORE_ARMOR, armor);
 
     AuraEffectList const& resIgnoreAuras = GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
     for (AuraEffectList::const_iterator j = resIgnoreAuras.begin(); j != resIgnoreAuras.end(); ++j)
     {
         if ((*j)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
             armor = std::floor(AddPct(armor, -(*j)->GetAmount()));
     }
 
     // Apply Player CR_ARMOR_PENETRATION rating
     if (GetTypeId() == TYPEID_PLAYER)
     {
         float maxArmorPen = 0;
         if (victim->getLevel() < 60)
             maxArmorPen = float(400 + 85 * victim->getLevel());
         else
             maxArmorPen = 400 + 85 * victim->getLevel() + 4.5f * 85 * (victim->getLevel() - 59);
 
         // Cap armor penetration to this number
         maxArmorPen = std::min((armor + maxArmorPen) / 3, armor);
         // Figure out how much armor do we ignore
         float armorPen = CalculatePct(maxArmorPen, ToPlayer()->GetRatingBonusValue(CR_ARMOR_PENETRATION));
         // Got the value, apply it
         armor -= std::min(armorPen, maxArmorPen);
     }
 
     if (armor < 0.0f)
         armor = 0.0f;
 
     float levelModifier = getLevel();
     if (levelModifier > 59)
         levelModifier = levelModifier + 4.5f * (levelModifier - 59);
 
     float tmpvalue = 0.1f * armor / (8.5f * levelModifier + 40);
     tmpvalue = tmpvalue / (1.0f + tmpvalue);
 
     if (tmpvalue < 0.0f)
         tmpvalue = 0.0f;
     if (tmpvalue > 0.75f)
         tmpvalue = 0.75f;
 
     return std::max<uint32>(uint32(damage * (1.0f - tmpvalue)), 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CalcHealAbsorb	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		uint32 &	healAmount,
		uint32 &	absorb
	)

 {
     if (!healAmount)
         return;
 
     int32 RemainingHeal = healAmount;
 
     // Need remove expired auras after
     bool existExpired = false;
 
     // absorb without mana cost
     AuraEffectList const& vHealAbsorb = victim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_HEAL_ABSORB);
     for (AuraEffectList::const_iterator i = vHealAbsorb.begin(); i != vHealAbsorb.end() && RemainingHeal > 0; ++i)
     {
         if (!((*i)->GetMiscValue() & healSpell->SchoolMask))
             continue;
 
         // Max Amount can be absorbed by this aura
         int32 currentAbsorb = (*i)->GetAmount();
 
         // Found empty aura (impossible but..)
         if (currentAbsorb <= 0)
         {
             existExpired = true;
             continue;
         }
 
         // currentAbsorb - damage can be absorbed by shield
         // If need absorb less damage
         if (RemainingHeal < currentAbsorb)
             currentAbsorb = RemainingHeal;
 
         RemainingHeal -= currentAbsorb;
 
         // Reduce shield amount
         (*i)->SetAmount((*i)->GetAmount() - currentAbsorb);
         // Need remove it later
         if ((*i)->GetAmount() <= 0)
             existExpired = true;
     }
 
     // Remove all expired absorb auras
     if (existExpired)
     {
         for (AuraEffectList::const_iterator i = vHealAbsorb.begin(); i != vHealAbsorb.end();)
         {
             AuraEffect* auraEff = *i;
             ++i;
             if (auraEff->GetAmount() <= 0)
             {
                 uint32 removedAuras = victim->m_removedAurasCount;
                 auraEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
                 if (removedAuras+1 < victim->m_removedAurasCount)
                     i = vHealAbsorb.begin();
             }
         }
     }
 
     absorb = RemainingHeal > 0 ? (healAmount - RemainingHeal) : healAmount;
     healAmount = RemainingHeal;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::CalcSpellDuration ( SpellInfo const * spellProto )

 {
     uint32 comboPoints = m_movedPlayer ? m_movedPlayer->GetComboPoints() : 0;
 
     int32 minduration = spellProto->GetDuration();
     int32 maxduration = spellProto->GetMaxDuration();
 
     int32 duration;
 
     if (comboPoints && minduration != -1 && minduration != maxduration)
         duration = minduration + int32((maxduration - minduration) * comboPoints / 5);
     else
         duration = minduration;
 
     return duration;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::CalcSpellResistance	(	Unit *	victim,
		SpellSchoolMask	schoolMask,
		SpellInfo const *	spellInfo
	)		const

 {
     // Magic damage, check for resists
     if (!(schoolMask & SPELL_SCHOOL_MASK_SPELL))
         return 0;
 
     // Ignore spells that can't be resisted
     if (spellInfo && spellInfo->HasAttribute(SPELL_ATTR4_IGNORE_RESISTANCES))
         return 0;
 
     uint8 const bossLevel = 83;
     uint32 const bossResistanceConstant = 510;
     uint32 resistanceConstant = 0;
     uint8 level = victim->getLevel();
 
     if (level == bossLevel)
         resistanceConstant = bossResistanceConstant;
     else
         resistanceConstant = level * 5;
 
     int32 baseVictimResistance = victim->GetResistance(schoolMask);
     baseVictimResistance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask);
 
     if (Player const* player = ToPlayer())
         baseVictimResistance -= player->GetSpellPenetrationItemMod();
 
     // Resistance can't be lower then 0
     int32 victimResistance = std::max<int32>(baseVictimResistance, 0);
 
     if (victimResistance > 0)
     {
         int32 ignoredResistance = 0;
 
         AuraEffectList const& ResIgnoreAuras = GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
         for (AuraEffectList::const_iterator itr = ResIgnoreAuras.begin(); itr != ResIgnoreAuras.end(); ++itr)
             if ((*itr)->GetMiscValue() & schoolMask)
                 ignoredResistance += (*itr)->GetAmount();
 
         ignoredResistance = std::min<int32>(ignoredResistance, 100);
         ApplyPct(victimResistance, 100 - ignoredResistance);
     }
 
     if (victimResistance <= 0)
         return 0;
 
     float averageResist = float(victimResistance) / float(victimResistance + resistanceConstant);
 
     float discreteResistProbability[11];
     for (uint32 i = 0; i < 11; ++i)
     {
         discreteResistProbability[i] = 0.5f - 2.5f * std::fabs(0.1f * i - averageResist);
         if (discreteResistProbability[i] < 0.0f)
             discreteResistProbability[i] = 0.0f;
     }
 
     if (averageResist <= 0.1f)
     {
         discreteResistProbability[0] = 1.0f - 7.5f * averageResist;
         discreteResistProbability[1] = 5.0f * averageResist;
         discreteResistProbability[2] = 2.5f * averageResist;
     }
 
     uint32 resistance = 0;
     float r = float(rand_norm());
     float probabilitySum = discreteResistProbability[0];
 
     while (r >= probabilitySum && resistance < 10)
         probabilitySum += discreteResistProbability[++resistance];
 
     return resistance * 10;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::CalculateDamage	(	WeaponAttackType	attType,
		bool	normalized,
		bool	addTotalPct
	)

 {
     float minDamage = 0.0f;
     float maxDamage = 0.0f;
 
     if (normalized || !addTotalPct)
         CalculateMinMaxDamage(attType, normalized, addTotalPct, minDamage, maxDamage);
     else
     {
         switch (attType)
         {
             case RANGED_ATTACK:
                 minDamage = GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
                 maxDamage = GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
                 break;
             case BASE_ATTACK:
                 minDamage = GetFloatValue(UNIT_FIELD_MINDAMAGE);
                 maxDamage = GetFloatValue(UNIT_FIELD_MAXDAMAGE);
                 break;
             case OFF_ATTACK:
                 minDamage = GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE);
                 maxDamage = GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE);
                 break;
             default:
                 break;
         }
     }
 
     minDamage = std::max(0.f, minDamage);
     maxDamage = std::max(0.f, maxDamage);
 
     if (minDamage > maxDamage)
         std::swap(minDamage, maxDamage);
 
     if (maxDamage == 0.0f)
         maxDamage = 5.0f;
 
     return urand(uint32(minDamage), uint32(maxDamage));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::CalculateDefaultCoefficient	(	SpellInfo const *	spellInfo,
		DamageEffectType	damagetype
	)		const

 {
     // Damage over Time spells bonus calculation
     float DotFactor = 1.0f;
     if (damagetype == DOT)
     {
 
         int32 DotDuration = spellInfo->GetDuration();
         if (!spellInfo->IsChanneled() && DotDuration > 0)
             DotFactor = DotDuration / 15000.0f;
 
         if (uint32 DotTicks = spellInfo->GetMaxTicks(GetMap()->GetDifficultyID()))
             DotFactor /= DotTicks;
     }
 
     int32 CastingTime = spellInfo->IsChanneled() ? spellInfo->GetDuration() : spellInfo->CalcCastTime(getLevel());
     // Distribute Damage over multiple effects, reduce by AoE
     CastingTime = GetCastingTimeForBonus(spellInfo, damagetype, CastingTime);
 
     // As wowwiki says: C = (Cast Time / 3.5)
     return (CastingTime / 3500.0f) * DotFactor;
 }

Here is the call graph for this function:

float Unit::CalculateLevelPenalty ( SpellInfo const * spellProto ) const

 {
     if (spellProto->SpellLevel <= 0 || spellProto->SpellLevel >= spellProto->MaxLevel)
         return 1.0f;
 
     float LvlPenalty = 0.0f;
 
     if (spellProto->SpellLevel < 20)
         LvlPenalty = 20.0f - spellProto->SpellLevel * 3.75f;
     float LvlFactor = (float(spellProto->SpellLevel) + 6.0f) / float(getLevel());
     if (LvlFactor > 1.0f)
         LvlFactor = 1.0f;
 
     return AddPct(LvlFactor, -LvlPenalty);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CalculateMeleeDamage	(	Unit *	victim,
		uint32	damage,
		CalcDamageInfo *	damageInfo,
		WeaponAttackType	attackType = `BASE_ATTACK`
	)

Todo:: for melee need create structure as in

 {
     damageInfo->attacker         = this;
     damageInfo->target           = victim;
     damageInfo->damageSchoolMask = GetMeleeDamageSchoolMask();
     damageInfo->attackType       = attackType;
     damageInfo->damage           = 0;
     damageInfo->cleanDamage      = 0;
     damageInfo->absorb           = 0;
     damageInfo->resist           = 0;
     damageInfo->blocked_amount   = 0;
 
     damageInfo->TargetState      = 0;
     damageInfo->HitInfo          = 0;
     damageInfo->procAttacker     = PROC_FLAG_NONE;
     damageInfo->procVictim       = PROC_FLAG_NONE;
     damageInfo->procEx           = PROC_EX_NONE;
     damageInfo->hitOutCome       = MELEE_HIT_EVADE;
 
     if (!victim)
         return;
 
     if (!IsAlive() || !victim->IsAlive())
         return;
 
     // Select HitInfo/procAttacker/procVictim flag based on attack type
     switch (attackType)
     {
         case BASE_ATTACK:
             damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_MAINHAND_ATTACK;
             damageInfo->procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
             break;
         case OFF_ATTACK:
             damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_OFFHAND_ATTACK;
             damageInfo->procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
             damageInfo->HitInfo      = HITINFO_OFFHAND;
             break;
         default:
             return;
     }
 
     // Physical Immune check
     if (damageInfo->target->IsImmunedToDamage(SpellSchoolMask(damageInfo->damageSchoolMask)))
     {
        damageInfo->HitInfo       |= HITINFO_NORMALSWING;
        damageInfo->TargetState    = VICTIMSTATE_IS_IMMUNE;
 
        damageInfo->procEx        |= PROC_EX_IMMUNE;
        damageInfo->damage         = 0;
        damageInfo->cleanDamage    = 0;
        return;
     }
 
     damage += CalculateDamage(damageInfo->attackType, false, true);
     // Add melee damage bonus
     damage = MeleeDamageBonusDone(damageInfo->target, damage, damageInfo->attackType);
     damage = damageInfo->target->MeleeDamageBonusTaken(this, damage, damageInfo->attackType);
 
     // Script Hook For CalculateMeleeDamage -- Allow scripts to change the Damage pre class mitigation calculations
     sScriptMgr->ModifyMeleeDamage(damageInfo->target, damageInfo->attacker, damage);
 
     // Calculate armor reduction
     if (IsDamageReducedByArmor((SpellSchoolMask)(damageInfo->damageSchoolMask)))
     {
         damageInfo->damage = CalcArmorReducedDamage(damageInfo->target, damage, NULL, damageInfo->attackType);
         damageInfo->cleanDamage += damage - damageInfo->damage;
     }
     else
         damageInfo->damage = damage;
 
     damageInfo->hitOutCome = RollMeleeOutcomeAgainst(damageInfo->target, damageInfo->attackType);
 
     switch (damageInfo->hitOutCome)
     {
         case MELEE_HIT_EVADE:
             damageInfo->HitInfo        |= HITINFO_MISS | HITINFO_SWINGNOHITSOUND;
             damageInfo->TargetState     = VICTIMSTATE_EVADES;
             damageInfo->procEx         |= PROC_EX_EVADE;
             damageInfo->damage = 0;
             damageInfo->cleanDamage = 0;
             return;
         case MELEE_HIT_MISS:
             damageInfo->HitInfo        |= HITINFO_MISS;
             damageInfo->TargetState     = VICTIMSTATE_INTACT;
             damageInfo->procEx         |= PROC_EX_MISS;
             damageInfo->damage          = 0;
             damageInfo->cleanDamage     = 0;
             break;
         case MELEE_HIT_NORMAL:
             damageInfo->TargetState     = VICTIMSTATE_HIT;
             damageInfo->procEx         |= PROC_EX_NORMAL_HIT;
             break;
         case MELEE_HIT_CRIT:
         {
             damageInfo->HitInfo        |= HITINFO_CRITICALHIT;
             damageInfo->TargetState     = VICTIMSTATE_HIT;
 
             damageInfo->procEx         |= PROC_EX_CRITICAL_HIT;
             // Crit bonus calc
             damageInfo->damage += damageInfo->damage;
             float mod = 0.0f;
             // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
             if (damageInfo->attackType == RANGED_ATTACK)
                 mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
             else
                 mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
 
             // Increase crit damage from SPELL_AURA_MOD_CRIT_DAMAGE_BONUS
             mod += (GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, damageInfo->damageSchoolMask) - 1.0f) * 100;
 
             if (mod != 0)
                 AddPct(damageInfo->damage, mod);
             break;
         }
         case MELEE_HIT_PARRY:
             damageInfo->TargetState  = VICTIMSTATE_PARRY;
             damageInfo->procEx      |= PROC_EX_PARRY;
             damageInfo->cleanDamage += damageInfo->damage;
             damageInfo->damage = 0;
             break;
         case MELEE_HIT_DODGE:
             damageInfo->TargetState  = VICTIMSTATE_DODGE;
             damageInfo->procEx      |= PROC_EX_DODGE;
             damageInfo->cleanDamage += damageInfo->damage;
             damageInfo->damage = 0;
             break;
         case MELEE_HIT_BLOCK:
             damageInfo->TargetState = VICTIMSTATE_HIT;
             damageInfo->HitInfo    |= HITINFO_BLOCK;
             damageInfo->procEx     |= PROC_EX_BLOCK | PROC_EX_NORMAL_HIT;
             // 30% damage blocked, double blocked amount if block is critical
             damageInfo->blocked_amount = CalculatePct(damageInfo->damage, damageInfo->target->isBlockCritical() ? damageInfo->target->GetBlockPercent() * 2 : damageInfo->target->GetBlockPercent());
             damageInfo->damage      -= damageInfo->blocked_amount;
             damageInfo->cleanDamage += damageInfo->blocked_amount;
             break;
         case MELEE_HIT_GLANCING:
         {
             damageInfo->HitInfo     |= HITINFO_GLANCING;
             damageInfo->TargetState  = VICTIMSTATE_HIT;
             damageInfo->procEx      |= PROC_EX_NORMAL_HIT;
             int32 leveldif = int32(victim->getLevel()) - int32(getLevel());
             if (leveldif > 3)
                 leveldif = 3;
             float reducePercent = 1 - leveldif * 0.1f;
             damageInfo->cleanDamage += damageInfo->damage - uint32(reducePercent * damageInfo->damage);
             damageInfo->damage = uint32(reducePercent * damageInfo->damage);
             break;
         }
         case MELEE_HIT_CRUSHING:
             damageInfo->HitInfo     |= HITINFO_CRUSHING;
             damageInfo->TargetState  = VICTIMSTATE_HIT;
             damageInfo->procEx      |= PROC_EX_NORMAL_HIT;
             // 150% normal damage
             damageInfo->damage += (damageInfo->damage / 2);
             break;
         default:
             break;
     }
 
     // Always apply HITINFO_AFFECTS_VICTIM in case its not a miss
     if (!(damageInfo->HitInfo & HITINFO_MISS))
         damageInfo->HitInfo |= HITINFO_AFFECTS_VICTIM;
 
     int32 resilienceReduction = damageInfo->damage;
     ApplyResilience(victim, &resilienceReduction);
     resilienceReduction = damageInfo->damage - resilienceReduction;
     damageInfo->damage      -= resilienceReduction;
     damageInfo->cleanDamage += resilienceReduction;
 
     // Calculate absorb resist
     if (int32(damageInfo->damage) > 0)
     {
         damageInfo->procVictim |= PROC_FLAG_TAKEN_DAMAGE;
         // Calculate absorb & resists
         CalcAbsorbResist(damageInfo->target, SpellSchoolMask(damageInfo->damageSchoolMask), DIRECT_DAMAGE, damageInfo->damage, &damageInfo->absorb, &damageInfo->resist);
 
         if (damageInfo->absorb)
         {
             damageInfo->HitInfo |= (damageInfo->damage - damageInfo->absorb == 0 ? HITINFO_FULL_ABSORB : HITINFO_PARTIAL_ABSORB);
             damageInfo->procEx  |= PROC_EX_ABSORB;
         }
 
         if (damageInfo->resist)
             damageInfo->HitInfo |= (damageInfo->damage - damageInfo->resist == 0 ? HITINFO_FULL_RESIST : HITINFO_PARTIAL_RESIST);
 
         damageInfo->damage -= damageInfo->absorb + damageInfo->resist;
     }
     else // Impossible get negative result but....
         damageInfo->damage = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Unit::CalculateMinMaxDamage	(	WeaponAttackType	attType,
		bool	normalized,
		bool	addTotalPct,
		float &	minDamage,
		float &	maxDamage
	)

pure virtual

Implemented in Creature.

Here is the caller graph for this function:

int32 Unit::CalculateSpellDamage	(	Unit const *	target,
		SpellInfo const *	spellProto,
		uint8	effect_index,
		int32 const *	basePoints = `nullptr`,
		float *	variance = `nullptr`,
		int32	itemLevel = `-1`
	)		const

 {
     SpellEffectInfo const* effect = spellProto->GetEffect(GetMap()->GetDifficultyID(), effect_index);
     if (variance)
         *variance = 0.0f;
 
     return effect ? effect->CalcValue(this, basePoints, target, variance, itemLevel) : 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CalculateSpellDamageTaken	(	SpellNonMeleeDamage *	damageInfo,
		int32	damage,
		SpellInfo const *	spellInfo,
		WeaponAttackType	attackType = `BASE_ATTACK`,
		bool	crit = `false`
	)

 {
     if (damage < 0)
         return;
 
     Unit* victim = damageInfo->target;
     if (!victim || !victim->IsAlive())
         return;
 
     SpellSchoolMask damageSchoolMask = SpellSchoolMask(damageInfo->schoolMask);
 
     // Spells with SPELL_ATTR4_FIXED_DAMAGE ignore resilience because their damage is based off another spell's damage.
     if (!spellInfo->HasAttribute(SPELL_ATTR4_FIXED_DAMAGE))
     {
         if (IsDamageReducedByArmor(damageSchoolMask, spellInfo))
             damage = CalcArmorReducedDamage(victim, damage, spellInfo, attackType);
 
         bool blocked = false;
         // Per-school calc
         switch (spellInfo->DmgClass)
         {
             // Melee and Ranged Spells
             case SPELL_DAMAGE_CLASS_RANGED:
             case SPELL_DAMAGE_CLASS_MELEE:
             {
                 // Physical Damage
                 if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
                 {
                     // Get blocked status
                     blocked = isSpellBlocked(victim, spellInfo, attackType);
                 }
 
                 if (crit)
                 {
                     damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
 
                     // Calculate crit bonus
                     uint32 crit_bonus = damage;
                     // Apply crit_damage bonus for melee spells
                     if (Player* modOwner = GetSpellModOwner())
                         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
                     damage += crit_bonus;
 
                     // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
                     float critPctDamageMod = 0.0f;
                     if (attackType == RANGED_ATTACK)
                         critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
                     else
                         critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
 
                     // Increase crit damage from SPELL_AURA_MOD_CRIT_DAMAGE_BONUS
                     critPctDamageMod += (GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, spellInfo->GetSchoolMask()) - 1.0f) * 100;
 
                     if (critPctDamageMod != 0)
                         AddPct(damage, critPctDamageMod);
                 }
 
                 // Spell weapon based damage CAN BE crit & blocked at same time
                 if (blocked)
                 {
                     // double blocked amount if block is critical
                     uint32 value = victim->GetBlockPercent();
                     if (victim->isBlockCritical())
                         value *= 2; // double blocked percent
                     damageInfo->blocked = CalculatePct(damage, value);
                     damage -= damageInfo->blocked;
                 }
 
                 ApplyResilience(victim, &damage);
                 break;
             }
             // Magical Attacks
             case SPELL_DAMAGE_CLASS_NONE:
             case SPELL_DAMAGE_CLASS_MAGIC:
             {
                 // If crit add critical bonus
                 if (crit)
                 {
                     damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
                     damage = SpellCriticalDamageBonus(spellInfo, damage, victim);
                 }
 
                 ApplyResilience(victim, &damage);
                 break;
 
             }
             default:
                 break;
         }
     }
 
     // Script Hook For CalculateSpellDamageTaken -- Allow scripts to change the Damage post class mitigation calculations
     sScriptMgr->ModifySpellDamageTaken(damageInfo->target, damageInfo->attacker, damage);
 
     // Calculate absorb resist
     if (damage > 0)
     {
         CalcAbsorbResist(victim, damageSchoolMask, SPELL_DIRECT_DAMAGE, damage, &damageInfo->absorb, &damageInfo->resist, spellInfo);
         damage -= damageInfo->absorb + damageInfo->resist;
     }
     else
         damage = 0;
 
     damageInfo->damage = damage;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::CanDualWield ( ) const

inline

1359 { return m_canDualWield; }

Unit::m_canDualWield

bool m_canDualWield

Definition: Unit.h:1367

Here is the caller graph for this function:

virtual bool Unit::CanFly ( ) const

pure virtual

Implemented in Creature.

Here is the caller graph for this function:

bool Unit::CanFreeMove ( ) const

 {
     return !HasUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_FLEEING | UNIT_STATE_IN_FLIGHT |
         UNIT_STATE_ROOT | UNIT_STATE_STUNNED | UNIT_STATE_DISTRACTED) && GetOwnerGUID().IsEmpty();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::CanHaveThreatList ( bool skipAliveCheck = false ) const

 {
     // only creatures can have threat list
     if (GetTypeId() != TYPEID_UNIT)
         return false;
 
     // only alive units can have threat list
     if (!skipAliveCheck && !IsAlive())
         return false;
 
     // totems can not have threat list
     if (IsTotem())
         return false;
 
     // vehicles can not have threat list
     //if (ToCreature()->IsVehicle())
     //    return false;
 
     // summons can not have a threat list, unless they are controlled by a creature
     if (HasUnitTypeMask(UNIT_MASK_MINION | UNIT_MASK_GUARDIAN | UNIT_MASK_CONTROLABLE_GUARDIAN) && ((Pet*)this)->GetOwnerGUID().IsPlayer())
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::CanModifyStats ( ) const

inline

1959 { return m_canModifyStats; }

Unit::m_canModifyStats

bool m_canModifyStats

Definition: Unit.h:2287

Here is the caller graph for this function:

bool Unit::CanProc ( ) const

inline

2141 {return !m_procDeep;}

Unit::m_procDeep

int32 m_procDeep

Definition: Unit.h:2261

Here is the caller graph for this function:

bool Unit::CanUseAttackType ( uint8 attacktype ) const

 {
     switch (attacktype)
     {
         case BASE_ATTACK:
             return !HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED);
         case OFF_ATTACK:
             return !HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_DISARM_OFFHAND);
         case RANGED_ATTACK:
             return !HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_DISARM_RANGED);
         default:
             return true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CastCustomSpell	(	Unit *	victim,
		uint32	spellId,
		int32 const *	bp0,
		int32 const *	bp1,
		int32 const *	bp2,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     CustomSpellValues values;
     if (bp0)
         values.AddSpellMod(SPELLVALUE_BASE_POINT0, *bp0);
     if (bp1)
         values.AddSpellMod(SPELLVALUE_BASE_POINT1, *bp1);
     if (bp2)
         values.AddSpellMod(SPELLVALUE_BASE_POINT2, *bp2);
     CastCustomSpell(spellId, values, target, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastCustomSpell	(	uint32	spellId,
		SpellValueMod	mod,
		int32	value,
		Unit *	victim,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     CustomSpellValues values;
     values.AddSpellMod(mod, value);
     CastCustomSpell(spellId, values, target, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastCustomSpell	(	uint32	spellId,
		SpellValueMod	mod,
		int32	value,
		Unit *	victim = `NULL`,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     CustomSpellValues values;
     values.AddSpellMod(mod, value);
     CastCustomSpell(spellId, values, target, triggerFlags, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastCustomSpell	(	uint32	spellId,
		CustomSpellValues const &	value,
		Unit *	victim = `NULL`,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     if (!spellInfo)
     {
         TC_LOG_ERROR("entities.unit", "CastSpell: unknown spell id %u by caster: %s", spellId, GetGUID().ToString().c_str());
         return;
     }
     SpellCastTargets targets;
     targets.SetUnitTarget(victim);
 
     CastSpell(targets, spellInfo, &value, triggerFlags, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	SpellCastTargets const &	targets,
		SpellInfo const *	spellInfo,
		CustomSpellValues const *	value,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Todo:: this is a workaround - not needed anymore, but required for some scripts :(

 {
     if (!spellInfo)
     {
         TC_LOG_ERROR("entities.unit", "CastSpell: unknown spell by caster: %s", GetGUID().ToString().c_str());
         return;
     }
 
     if (!originalCaster && triggeredByAura)
         originalCaster = triggeredByAura->GetCasterGUID();
 
     Spell* spell = new Spell(this, spellInfo, triggerFlags, originalCaster);
 
     if (value)
         for (CustomSpellValues::const_iterator itr = value->begin(); itr != value->end(); ++itr)
             spell->SetSpellValue(itr->first, itr->second);
 
     spell->m_CastItem = castItem;
     spell->prepare(&targets, triggeredByAura);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	Unit *	victim,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     CastSpell(victim, spellId, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	Unit *	victim,
		uint32	spellId,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     if (!spellInfo)
     {
         TC_LOG_ERROR("entities.unit", "CastSpell: unknown spell id %u by caster: %s", spellId, GetGUID().ToString().c_str());
         return;
     }
 
     CastSpell(victim, spellInfo, triggerFlags, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     CastSpell(victim, spellInfo, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     SpellCastTargets targets;
     targets.SetUnitTarget(victim);
     CastSpell(targets, spellInfo, NULL, triggerFlags, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	float	x,
		float	y,
		float	z,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect const *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     if (!spellInfo)
     {
         TC_LOG_ERROR("entities.unit", "CastSpell: unknown spell id %u by caster: %s", spellId, GetGUID().ToString().c_str());
         return;
     }
     SpellCastTargets targets;
     targets.SetDst(x, y, z, GetOrientation());
 
     CastSpell(targets, spellInfo, NULL, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastSpell	(	GameObject *	go,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `NULL`,
		AuraEffect *	triggeredByAura = `NULL`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     if (!spellInfo)
     {
         TC_LOG_ERROR("entities.unit", "CastSpell: unknown spell id %u by caster: %s", spellId, GetGUID().ToString().c_str());
         return;
     }
     SpellCastTargets targets;
     targets.SetGOTarget(go);
 
     CastSpell(targets, spellInfo, NULL, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
 }

Here is the call graph for this function:

void Unit::CastStop ( uint32 except_spellid = 0 )

 {
     for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
         if (m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id != except_spellid)
             InterruptSpell(CurrentSpellTypes(i), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ChangeSeat	(	int8	seatId,
		bool	next = `true`
	)

 {
     if (!m_vehicle)
         return;
 
     // Don't change if current and new seat are identical
     if (seatId == GetTransSeat())
         return;
 
     SeatMap::const_iterator seat = (seatId < 0 ? m_vehicle->GetNextEmptySeat(GetTransSeat(), next) : m_vehicle->Seats.find(seatId));
     // The second part of the check will only return true if seatId >= 0. @Vehicle::GetNextEmptySeat makes sure of that.
     if (seat == m_vehicle->Seats.end() || !seat->second.IsEmpty())
         return;
 
     AuraEffect* rideVehicleEffect = NULL;
     AuraEffectList const& vehicleAuras = m_vehicle->GetBase()->GetAuraEffectsByType(SPELL_AURA_CONTROL_VEHICLE);
     for (AuraEffectList::const_iterator itr = vehicleAuras.begin(); itr != vehicleAuras.end(); ++itr)
     {
         if ((*itr)->GetCasterGUID() != GetGUID())
             continue;
 
         // Make sure there is only one ride vehicle aura on target cast by the unit changing seat
         ASSERT(!rideVehicleEffect);
         rideVehicleEffect = *itr;
     }
 
     // Unit riding a vehicle must always have control vehicle aura on target
     ASSERT(rideVehicleEffect);
 
     rideVehicleEffect->ChangeAmount(seat->first + 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CleanupBeforeRemoveFromMap ( bool finalCleanup )

 {
     // This needs to be before RemoveFromWorld to make GetCaster() return a valid pointer on aura removal
     InterruptNonMeleeSpells(true);
 
     if (IsInWorld())
         RemoveFromWorld();
 
     ASSERT(GetGUID());
 
     // A unit may be in removelist and not in world, but it is still in grid
     // and may have some references during delete
     RemoveAllAuras();
     RemoveAllGameObjects();
 
     if (finalCleanup)
         m_cleanupDone = true;
 
     m_Events.KillAllEvents(false);                      // non-delatable (currently cast spells) will not deleted now but it will deleted at call in Map::RemoveAllObjectsInRemoveList
     CombatStop();
     DeleteThreatList();
     getHostileRefManager().setOnlineOfflineState(false);
     GetMotionMaster()->Clear(false);                    // remove different non-standard movement generators.
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CleanupsBeforeDelete ( bool finalCleanup = true )

overridevirtual

Reimplemented from WorldObject.

 {
     CleanupBeforeRemoveFromMap(finalCleanup);
 
     WorldObject::CleanupsBeforeDelete(finalCleanup);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ClearAllReactives ( )

 {
     for (uint8 i = 0; i < MAX_REACTIVE; ++i)
         m_reactiveTimer[i] = 0;
 
     if (HasAuraState(AURA_STATE_DEFENSE))
         ModifyAuraState(AURA_STATE_DEFENSE, false);
     if (getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_PARRY))
         ModifyAuraState(AURA_STATE_HUNTER_PARRY, false);
     if (getClass() == CLASS_WARRIOR && GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->ClearComboPoints();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ClearDiminishings ( )

inline

1346 { m_Diminishing.clear(); }

Unit::m_Diminishing

Diminishing m_Diminishing

Definition: Unit.h:2344

Here is the caller graph for this function:

void Unit::ClearInCombat ( )

 {
     m_CombatTimer = 0;
     RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
 
     // Reset rune flags after combat
     if (GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_DEATH_KNIGHT)
     {
         for (uint8 i = 0; i < MAX_RUNES; ++i)
         {
             ToPlayer()->SetRuneTimer(i, 0xFFFFFFFF);
             ToPlayer()->SetLastRuneGraceTimer(i, 0);
         }
     }
 
     // Player's state will be cleared in Player::UpdateContestedPvP
     if (Creature* creature = ToCreature())
     {
         if (creature->GetCreatureTemplate() && creature->GetCreatureTemplate()->unit_flags & UNIT_FLAG_IMMUNE_TO_PC)
             SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC); // set immunity state to the one from db on evade
 
         ClearUnitState(UNIT_STATE_ATTACK_PLAYER);
         if (HasFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED))
             SetUInt32Value(OBJECT_DYNAMIC_FLAGS, creature->GetCreatureTemplate()->dynamicflags);
 
         if (creature->IsPet() || creature->IsGuardian())
         {
             if (Unit* owner = GetOwner())
                 for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
                     if (owner->GetSpeedRate(UnitMoveType(i)) > GetSpeedRate(UnitMoveType(i)))
                         SetSpeed(UnitMoveType(i), owner->GetSpeedRate(UnitMoveType(i)), true);
         }
         else if (!IsCharmed())
             return;
     }
     else
         ToPlayer()->OnCombatExit();
 
     RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ClearUnitState ( uint32 f )

inline

1396 { m_state &= ~f; }

Unit::m_state

uint32 m_state

Definition: Unit.h:2340

void Unit::CombatStart	(	Unit *	target,
		bool	initialAggro = `true`
	)

 {
     if (initialAggro)
     {
         if (!target->IsStandState())
             target->SetStandState(UNIT_STAND_STATE_STAND);
 
         if (!target->IsInCombat() && target->GetTypeId() != TYPEID_PLAYER
             && !target->ToCreature()->HasReactState(REACT_PASSIVE) && target->ToCreature()->IsAIEnabled)
         {
             if (target->IsPet())
                 target->ToCreature()->AI()->AttackedBy(this); // PetAI has special handler before AttackStart()
             else
                 target->ToCreature()->AI()->AttackStart(this);
         }
 
         SetInCombatWith(target);
         target->SetInCombatWith(this);
     }
     Unit* who = target->GetCharmerOrOwnerOrSelf();
     if (who->GetTypeId() == TYPEID_PLAYER)
       SetContestedPvP(who->ToPlayer());
 
     Player* me = GetCharmerOrOwnerPlayerOrPlayerItself();
     if (me && who->IsPvP()
         && (who->GetTypeId() != TYPEID_PLAYER
         || !me->duel || me->duel->opponent != who))
     {
         me->UpdatePvP(true);
         me->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::CombatStop ( bool includingCast = false )

 {
     if (includingCast && IsNonMeleeSpellCast(false))
         InterruptNonMeleeSpells(false);
 
     AttackStop();
     RemoveAllAttackers();
     if (GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->SendAttackSwingCancelAttack();     // melee and ranged forced attack cancel
     ClearInCombat();
 }

Here is the call graph for this function:

void Unit::CombatStopWithPets ( bool includingCast = false )

 {
     CombatStop(includingCast);
 
     for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
         (*itr)->CombatStop(includingCast);
 }

Here is the call graph for this function:

uint32 Unit::CountPctFromCurHealth ( int32 pct ) const

inline

1436 { return CalculatePct(GetHealth(), pct); }

CalculatePct

T CalculatePct(T base, U pct)

Definition: Util.h:92

uint32 GetHealth() const

Definition: Unit.h:1426

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::CountPctFromMaxHealth ( int32 pct ) const

inline

1435 { return CalculatePct(GetMaxHealth(), pct); }

UNIT_FIELD_CHANNEL_OBJECT

uint32 GetMaxHealth() const

Definition: Unit.h:1427

CalculatePct

T CalculatePct(T base, U pct)

Definition: Util.h:92

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::CountPctFromMaxPower	(	Powers	power,
		int32	pct
	)		const

inline

1450 { return CalculatePct(GetMaxPower(power), pct); }

CalculatePct

T CalculatePct(T base, U pct)

Definition: Util.h:92

Unit::GetMaxPower

int32 GetMaxPower(Powers power) const

Definition: Unit.cpp:11598

Here is the call graph for this function:

Pet * Unit::CreateTamedPetFrom	(	Creature *	creatureTarget,
		uint32	spell_id = `0`
	)

 {
     if (GetTypeId() != TYPEID_PLAYER)
         return NULL;
 
     Pet* pet = new Pet(ToPlayer(), HUNTER_PET);
 
     if (!pet->CreateBaseAtCreature(creatureTarget))
     {
         delete pet;
         return NULL;
     }
 
     uint8 level = creatureTarget->getLevel() + 5 < getLevel() ? (getLevel() - 5) : creatureTarget->getLevel();
 
     InitTamedPet(pet, level, spell_id);
 
     return pet;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pet * Unit::CreateTamedPetFrom	(	uint32	creatureEntry,
		uint32	spell_id = `0`
	)

 {
     if (GetTypeId() != TYPEID_PLAYER)
         return NULL;
 
     CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(creatureEntry);
     if (!creatureInfo)
         return NULL;
 
     Pet* pet = new Pet(ToPlayer(), HUNTER_PET);
 
     if (!pet->CreateBaseAtCreatureInfo(creatureInfo, this) || !InitTamedPet(pet, getLevel(), spell_id))
     {
         delete pet;
         return NULL;
     }
 
     return pet;
 }

Here is the call graph for this function:

bool Unit::CreateVehicleKit	(	uint32	id,
		uint32	creatureEntry,
		bool	loading = `false`
	)

 {
     VehicleEntry const* vehInfo = sVehicleStore.LookupEntry(id);
     if (!vehInfo)
         return false;
 
     m_vehicleKit = new Vehicle(this, vehInfo, creatureEntry);
     m_updateFlag |= UPDATEFLAG_VEHICLE;
     m_unitTypeMask |= UNIT_MASK_VEHICLE;
 
     if (!loading)
         SendSetVehicleRecId(id);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::DealDamage	(	Unit *	victim,
		uint32	damage,
		CleanDamage const *	cleanDamage = `NULL`,
		DamageEffectType	damagetype = `DIRECT_DAMAGE`,
		SpellSchoolMask	damageSchoolMask = `SPELL_SCHOOL_MASK_NORMAL`,
		SpellInfo const *	spellProto = `NULL`,
		bool	durabilityLoss = `true`
	)

Todo:: check packets if damage is done by victim, or by attacker of victim

 {
     if (victim->IsAIEnabled)
         victim->GetAI()->DamageTaken(this, damage);
 
     if (IsAIEnabled)
         GetAI()->DamageDealt(victim, damage, damagetype);
 
     // Hook for OnDamage Event
     sScriptMgr->OnDamage(this, victim, damage);
 
     if (victim->GetTypeId() == TYPEID_PLAYER && this != victim)
     {
         // Signal to pets that their owner was attacked
         Pet* pet = victim->ToPlayer()->GetPet();
 
         if (pet && pet->IsAlive())
             pet->AI()->OwnerAttackedBy(this);
 
         if (victim->ToPlayer()->GetCommandStatus(CHEAT_GOD))
             return 0;
     }
 
     // Signal the pet it was attacked so the AI can respond if needed
     if (victim->GetTypeId() == TYPEID_UNIT && this != victim && victim->IsPet() && victim->IsAlive())
         victim->ToPet()->AI()->AttackedBy(this);
 
     if (damagetype != NODAMAGE)
     {
         // interrupting auras with AURA_INTERRUPT_FLAG_DAMAGE before checking !damage (absorbed damage breaks that type of auras)
         if (spellProto)
         {
             if (!spellProto->HasAttribute(SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS))
                 victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, spellProto->Id);
         }
         else
             victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, 0);
 
         // We're going to call functions which can modify content of the list during iteration over it's elements
         // Let's copy the list so we can prevent iterator invalidation
         AuraEffectList vCopyDamageCopy(victim->GetAuraEffectsByType(SPELL_AURA_SHARE_DAMAGE_PCT));
         // copy damage to casters of this aura
         for (AuraEffectList::iterator i = vCopyDamageCopy.begin(); i != vCopyDamageCopy.end(); ++i)
         {
             // Check if aura was removed during iteration - we don't need to work on such auras
             if (!((*i)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
                 continue;
             // check damage school mask
             if (((*i)->GetMiscValue() & damageSchoolMask) == 0)
                 continue;
 
             Unit* shareDamageTarget = (*i)->GetCaster();
             if (!shareDamageTarget)
                 continue;
             SpellInfo const* spell = (*i)->GetSpellInfo();
 
             uint32 share = CalculatePct(damage, (*i)->GetAmount());
 
             DealDamageMods(shareDamageTarget, share, NULL);
             DealDamage(shareDamageTarget, share, NULL, NODAMAGE, spell->GetSchoolMask(), spell, false);
         }
     }
 
     // Rage from Damage made (only from direct weapon damage)
     if (cleanDamage && damagetype == DIRECT_DAMAGE && this != victim && getPowerType() == POWER_RAGE)
     {
         uint32 rage = uint32(GetAttackTime(cleanDamage->attackType) / 1000.f * 8.125f);
         switch (cleanDamage->attackType)
         {
             case OFF_ATTACK:
                 rage /= 2;
             case BASE_ATTACK:
                 RewardRage(rage, true);
                 break;
             default:
                 break;
         }
     }
 
     if (!damage)
     {
         // Rage from absorbed damage
         if (cleanDamage && cleanDamage->absorbed_damage && victim->getPowerType() == POWER_RAGE)
             victim->RewardRage(cleanDamage->absorbed_damage, false);
 
         return 0;
     }
 
     TC_LOG_DEBUG("entities.unit", "DealDamageStart");
 
     uint32 health = victim->GetHealth();
     TC_LOG_DEBUG("entities.unit", "%s dealt %u damage to %s", GetGUID().ToString().c_str(), damage, victim->GetGUID().ToString().c_str());
 
     // duel ends when player has 1 or less hp
     bool duel_hasEnded = false;
     bool duel_wasMounted = false;
     if (victim->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->duel && damage >= (health-1))
     {
         // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
         if (victim->ToPlayer()->duel->opponent == this || victim->ToPlayer()->duel->opponent->GetGUID() == GetOwnerGUID())
             damage = health - 1;
 
         duel_hasEnded = true;
     }
     else if (victim->IsVehicle() && damage >= (health-1) && victim->GetCharmer() && victim->GetCharmer()->GetTypeId() == TYPEID_PLAYER)
     {
         Player* victimRider = victim->GetCharmer()->ToPlayer();
 
         if (victimRider && victimRider->duel && victimRider->duel->isMounted)
         {
             // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
             if (victimRider->duel->opponent == this || victimRider->duel->opponent->GetGUID() == GetCharmerGUID())
                 damage = health - 1;
 
             duel_wasMounted = true;
             duel_hasEnded = true;
         }
     }
 
     if (GetTypeId() == TYPEID_PLAYER && this != victim)
     {
         Player* killer = ToPlayer();
 
         // in bg, count dmg if victim is also a player
         if (victim->GetTypeId() == TYPEID_PLAYER)
             if (Battleground* bg = killer->GetBattleground())
                 bg->UpdatePlayerScore(killer, SCORE_DAMAGE_DONE, damage);
 
         killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE, damage, 0, 0, victim);
         killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT, damage);
     }
 
     if (victim->GetTypeId() == TYPEID_PLAYER)
         victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED, damage);
     else if (!victim->IsControlledByPlayer() || victim->IsVehicle())
     {
         if (!victim->ToCreature()->hasLootRecipient())
             victim->ToCreature()->SetLootRecipient(this);
 
         if (IsControlledByPlayer())
             victim->ToCreature()->LowerPlayerDamageReq(health < damage ?  health : damage);
     }
 
     if (health <= damage)
     {
         TC_LOG_DEBUG("entities.unit", "DealDamage: victim just died");
 
         if (victim->GetTypeId() == TYPEID_PLAYER && victim != this)
             victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, health);
 
         Kill(victim, durabilityLoss);
     }
     else
     {
         TC_LOG_DEBUG("entities.unit", "DealDamageAlive");
 
         if (victim->GetTypeId() == TYPEID_PLAYER)
             victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, damage);
 
         victim->ModifyHealth(-(int32)damage);
 
         if (damagetype == DIRECT_DAMAGE || damagetype == SPELL_DIRECT_DAMAGE)
         {
             victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_DIRECT_DAMAGE, spellProto ? spellProto->Id : 0);
             if (victim->GetTypeId() == TYPEID_UNIT && !victim->IsPet())
                 victim->SetLastDamagedTime(time(NULL));
         }
 
         if (victim->GetTypeId() != TYPEID_PLAYER)
             victim->AddThreat(this, float(damage), damageSchoolMask, spellProto);
         else                                                // victim is a player
         {
             // random durability for items (HIT TAKEN)
             if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
             {
                 EquipmentSlots slot = EquipmentSlots(urand(0, EQUIPMENT_SLOT_END-1));
                 victim->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
             }
         }
 
         // Rage from damage received
         if (this != victim && victim->getPowerType() == POWER_RAGE)
         {
             uint32 rage_damage = damage + (cleanDamage ? cleanDamage->absorbed_damage : 0);
             victim->RewardRage(rage_damage, false);
         }
 
         if (GetTypeId() == TYPEID_PLAYER)
         {
             // random durability for items (HIT DONE)
             if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
             {
                 EquipmentSlots slot = EquipmentSlots(urand(0, EQUIPMENT_SLOT_END-1));
                 ToPlayer()->DurabilityPointLossForEquipSlot(slot);
             }
         }
 
         if (damagetype != NODAMAGE && damage)
         {
             if (victim != this && victim->GetTypeId() == TYPEID_PLAYER && // does not support creature push_back
                 (!spellProto || !spellProto->HasAttribute(SPELL_ATTR7_NO_PUSHBACK_ON_DAMAGE)))
             {
                 if (damagetype != DOT)
                     if (Spell* spell = victim->m_currentSpells[CURRENT_GENERIC_SPELL])
                         if (spell->getState() == SPELL_STATE_PREPARING)
                         {
                             uint32 interruptFlags = spell->m_spellInfo->InterruptFlags;
                             if (interruptFlags & SPELL_INTERRUPT_FLAG_ABORT_ON_DMG)
                                 victim->InterruptNonMeleeSpells(false);
                             else if (interruptFlags & SPELL_INTERRUPT_FLAG_PUSH_BACK)
                                 spell->Delayed();
                         }
 
                 if (Spell* spell = victim->m_currentSpells[CURRENT_CHANNELED_SPELL])
                     if (spell->getState() == SPELL_STATE_CASTING)
                     {
                         uint32 channelInterruptFlags = spell->m_spellInfo->ChannelInterruptFlags;
                         if (((channelInterruptFlags & CHANNEL_FLAG_DELAY) != 0) && (damagetype != DOT))
                             spell->DelayedChannel();
                     }
             }
         }
 
         // last damage from duel opponent
         if (duel_hasEnded)
         {
             Player* he = duel_wasMounted ? victim->GetCharmer()->ToPlayer() : victim->ToPlayer();
 
             ASSERT(he && he->duel);
 
             if (duel_wasMounted) // In this case victim==mount
                 victim->SetHealth(1);
             else
                 he->SetHealth(1);
 
             he->duel->opponent->CombatStopWithPets(true);
             he->CombatStopWithPets(true);
 
             he->CastSpell(he, 7267, true);                  // beg
             he->DuelComplete(DUEL_WON);
         }
     }
 
     TC_LOG_DEBUG("entities.unit", "DealDamageEnd returned %d damage", damage);
 
     return damage;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DealDamageMods	(	Unit *	victim,
		uint32 &	damage,
		uint32 *	absorb
	)

 {
     if (!victim || !victim->IsAlive() || victim->HasUnitState(UNIT_STATE_IN_FLIGHT) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
     {
         if (absorb)
             *absorb += damage;
         damage = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::DealHeal	(	Unit *	victim,
		uint32	addhealth
	)

 {
     int32 gain = 0;
 
     if (victim->IsAIEnabled)
         victim->GetAI()->HealReceived(this, addhealth);
 
     if (IsAIEnabled)
         GetAI()->HealDone(victim, addhealth);
 
     if (addhealth)
         gain = victim->ModifyHealth(int32(addhealth));
 
     // Hook for OnHeal Event
     sScriptMgr->OnHeal(this, victim, (uint32&)gain);
 
     Unit* unit = this;
 
     if (GetTypeId() == TYPEID_UNIT && IsTotem())
         unit = GetOwner();
 
     if (Player* player = unit->ToPlayer())
     {
         if (Battleground* bg = player->GetBattleground())
             bg->UpdatePlayerScore(player, SCORE_HEALING_DONE, gain);
 
         // use the actual gain, as the overheal shall not be counted, skip gain 0 (it ignored anyway in to criteria)
         if (gain)
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE, gain, 0, 0, victim);
 
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CAST, addhealth);
     }
 
     if (Player* player = victim->ToPlayer())
     {
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED, gain);
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED, addhealth);
     }
 
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DealMeleeDamage	(	CalcDamageInfo *	damageInfo,
		bool	durabilityLoss
	)

 {
     Unit* victim = damageInfo->target;
 
     if (!victim->IsAlive() || victim->HasUnitState(UNIT_STATE_IN_FLIGHT) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
         return;
 
     // Hmmmm dont like this emotes client must by self do all animations
     if (damageInfo->HitInfo & HITINFO_CRITICALHIT)
         victim->HandleEmoteCommand(EMOTE_ONESHOT_WOUND_CRITICAL);
     if (damageInfo->blocked_amount && damageInfo->TargetState != VICTIMSTATE_BLOCKS)
         victim->HandleEmoteCommand(EMOTE_ONESHOT_PARRY_SHIELD);
 
     if (damageInfo->TargetState == VICTIMSTATE_PARRY)
     {
         // Get attack timers
         float offtime  = float(victim->getAttackTimer(OFF_ATTACK));
         float basetime = float(victim->getAttackTimer(BASE_ATTACK));
         // Reduce attack time
         if (victim->haveOffhandWeapon() && offtime < basetime)
         {
             float percent20 = victim->GetAttackTime(OFF_ATTACK) * 0.20f;
             float percent60 = 3.0f * percent20;
             if (offtime > percent20 && offtime <= percent60)
                 victim->setAttackTimer(OFF_ATTACK, uint32(percent20));
             else if (offtime > percent60)
             {
                 offtime -= 2.0f * percent20;
                 victim->setAttackTimer(OFF_ATTACK, uint32(offtime));
             }
         }
         else
         {
             float percent20 = victim->GetAttackTime(BASE_ATTACK) * 0.20f;
             float percent60 = 3.0f * percent20;
             if (basetime > percent20 && basetime <= percent60)
                 victim->setAttackTimer(BASE_ATTACK, uint32(percent20));
             else if (basetime > percent60)
             {
                 basetime -= 2.0f * percent20;
                 victim->setAttackTimer(BASE_ATTACK, uint32(basetime));
             }
         }
     }
 
     // Call default DealDamage
     CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb, damageInfo->attackType, damageInfo->hitOutCome);
     DealDamage(victim, damageInfo->damage, &cleanDamage, DIRECT_DAMAGE, SpellSchoolMask(damageInfo->damageSchoolMask), NULL, durabilityLoss);
 
     // If this is a creature and it attacks from behind it has a probability to daze it's victim
     if ((damageInfo->hitOutCome == MELEE_HIT_CRIT || damageInfo->hitOutCome == MELEE_HIT_CRUSHING || damageInfo->hitOutCome == MELEE_HIT_NORMAL || damageInfo->hitOutCome == MELEE_HIT_GLANCING) &&
         GetTypeId() != TYPEID_PLAYER && !ToCreature()->IsControlledByPlayer() && !victim->HasInArc(float(M_PI), this)
         && (victim->GetTypeId() == TYPEID_PLAYER || !victim->ToCreature()->isWorldBoss())&& !victim->IsVehicle())
     {
         // -probability is between 0% and 40%
         // 20% base chance
         float Probability = 20.0f;
 
         // there is a newbie protection, at level 10 just 7% base chance; assuming linear function
         if (victim->getLevel() < 30)
             Probability = 0.65f * victim->getLevel() + 0.5f;
 
         uint32 VictimDefense = victim->GetMaxSkillValueForLevel(this);
         uint32 AttackerMeleeSkill = GetMaxSkillValueForLevel();
 
         Probability *= AttackerMeleeSkill/(float)VictimDefense*0.16f;
 
         if (Probability < 0)
             Probability = 0;
 
         if (Probability > 40.0f)
             Probability = 40.0f;
 
         if (roll_chance_f(Probability))
             CastSpell(victim, 1604, true);
     }
 
     if (GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->CastItemCombatSpell(victim, damageInfo->attackType, damageInfo->procVictim, damageInfo->procEx);
 
     // Do effect if any damage done to target
     if (damageInfo->damage)
     {
         // We're going to call functions which can modify content of the list during iteration over it's elements
         // Let's copy the list so we can prevent iterator invalidation
         AuraEffectList vDamageShieldsCopy(victim->GetAuraEffectsByType(SPELL_AURA_DAMAGE_SHIELD));
         for (AuraEffectList::const_iterator dmgShieldItr = vDamageShieldsCopy.begin(); dmgShieldItr != vDamageShieldsCopy.end(); ++dmgShieldItr)
         {
             SpellInfo const* i_spellProto = (*dmgShieldItr)->GetSpellInfo();
             // Damage shield can be resisted...
             if (SpellMissInfo missInfo = victim->SpellHitResult(this, i_spellProto, false))
             {
                 victim->SendSpellMiss(this, i_spellProto->Id, missInfo);
                 continue;
             }
 
             // ...or immuned
             if (IsImmunedToDamage(i_spellProto))
             {
                 victim->SendSpellDamageImmune(this, i_spellProto->Id, false);
                 continue;
             }
 
             uint32 damage = (*dmgShieldItr)->GetAmount();
 
             if (Unit* caster = (*dmgShieldItr)->GetCaster())
             {
                 damage = caster->SpellDamageBonusDone(this, i_spellProto, damage, SPELL_DIRECT_DAMAGE, (*dmgShieldItr)->GetSpellEffectInfo());
                 damage = this->SpellDamageBonusTaken(caster, i_spellProto, damage, SPELL_DIRECT_DAMAGE, (*dmgShieldItr)->GetSpellEffectInfo());
             }
 
             uint32 absorb = 0, resist = 0;
             victim->CalcAbsorbResist(this, SpellSchoolMask(i_spellProto->SchoolMask), SPELL_DIRECT_DAMAGE, damage, &absorb, &resist, i_spellProto);
             // No Unit::CalcAbsorbResist here - opcode doesn't send that data - this damage is probably not affected by that
             victim->DealDamageMods(this, damage, NULL);
 
             WorldPackets::CombatLog::SpellDamageShield damageShield;
             damageShield.Attacker = victim->GetGUID();
             damageShield.Defender = GetGUID();
             damageShield.SpellID = i_spellProto->Id;
             damageShield.TotalDamage = damage;
             damageShield.OverKill = std::max(int32(damage) - int32(GetHealth()), 0);
             damageShield.SchoolMask = i_spellProto->SchoolMask;
             damageShield.LogAbsorbed = absorb;
 
             victim->DealDamage(this, damage, 0, SPELL_DIRECT_DAMAGE, i_spellProto->GetSchoolMask(), i_spellProto, true);
 
             damageShield.LogData.Initialize(this);
             victim->SendCombatLogMessage(&damageShield);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DealSpellDamage	(	SpellNonMeleeDamage const *	damageInfo,
		bool	durabilityLoss
	)

 {
     if (!damageInfo)
         return;
 
     Unit* victim = damageInfo->target;
 
     if (!victim)
         return;
 
     if (!victim->IsAlive() || victim->HasUnitState(UNIT_STATE_IN_FLIGHT) || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode()))
         return;
 
     SpellInfo const* spellProto = sSpellMgr->GetSpellInfo(damageInfo->SpellID);
     if (!spellProto)
     {
         TC_LOG_DEBUG("entities.unit", "Unit::DealSpellDamage has wrong damageInfo->SpellID: %u", damageInfo->SpellID);
         return;
     }
 
     // Call default DealDamage
     CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb, BASE_ATTACK, MELEE_HIT_NORMAL);
     DealDamage(victim, damageInfo->damage, &cleanDamage, SPELL_DIRECT_DAMAGE, SpellSchoolMask(damageInfo->schoolMask), spellProto, durabilityLoss);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DelayOwnedAuras	(	uint32	spellId,
		ObjectGuid	caster,
		int32	delaytime
	)

Todo:: : once we support variadic templates use them here

 {
     AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
     for (; range.first != range.second; ++range.first)
     {
         Aura* aura = range.first->second;
         if (!caster || aura->GetCasterGUID() == caster)
         {
             if (aura->GetDuration() < delaytime)
                 aura->SetDuration(0);
             else
                 aura->SetDuration(aura->GetDuration() - delaytime);
 
             // update for out of range group members (on 1 slot use)
             aura->SetNeedClientUpdateForTargets();
             TC_LOG_DEBUG("spells", "Aura %u partially interrupted on %s, new duration: %u ms", aura->GetId(), GetGUID().ToString().c_str(), aura->GetDuration());
         }
     }
 }

Here is the call graph for this function:

void Unit::DeleteCharmInfo ( )

 {
     if (!m_charmInfo)
         return;
 
     m_charmInfo->RestoreState();
     delete m_charmInfo;
     m_charmInfo = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DeleteThreatList ( )

 {
     if (CanHaveThreatList(true) && !m_ThreatManager.isThreatListEmpty())
         SendClearThreatListOpcode();
     m_ThreatManager.clearReferences();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DeMorph ( )

 {
     SetDisplayId(GetNativeDisplayId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::DestroyForPlayer ( Player * target ) const

overrideprotectedvirtual

Reimplemented from Object.

 {
     if (Battleground* bg = target->GetBattleground())
     {
         if (bg->isArena())
         {
             WorldPackets::Battleground::DestroyArenaUnit destroyArenaUnit;
             destroyArenaUnit.Guid = GetGUID();
             target->GetSession()->SendPacket(destroyArenaUnit.Write());
         }
     }
 
     WorldObject::DestroyForPlayer(target);
 }

Here is the call graph for this function:

void Unit::DisableSpline ( )

protected

 {
     m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_FORWARD);
     movespline->_Interrupt();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::Dismount ( )

 {
     if (!IsMounted())
         return;
 
     SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 0);
     RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT);
 
     if (Player* thisPlayer = ToPlayer())
         thisPlayer->SendMovementSetCollisionHeight(thisPlayer->GetCollisionHeight(false));
 
     WorldPackets::Misc::Dismount data;
     data.Guid = GetGUID();
     SendMessageToSet(data.Write(), true);
 
     // dismount as a vehicle
     if (GetTypeId() == TYPEID_PLAYER && GetVehicleKit())
     {
         // Remove vehicle from player
         RemoveVehicleKit();
     }
 
     RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_MOUNTED);
 
     // only resummon old pet if the player is already added to a map
     // this prevents adding a pet to a not created map which would otherwise cause a crash
     // (it could probably happen when logging in after a previous crash)
     if (Player* player = ToPlayer())
     {
         if (Pet* pPet = player->GetPet())
         {
             if (pPet->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED) && !pPet->HasUnitState(UNIT_STATE_STUNNED))
                 pPet->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
         }
         else
             player->ResummonPetTemporaryUnSummonedIfAny();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::EnergizeBySpell	(	Unit *	victim,
		uint32	SpellID,
		int32	Damage,
		Powers	powertype
	)

 {
     victim->ModifyPower(powerType, damage);
 
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     victim->getHostileRefManager().threatAssist(this, float(damage) * 0.5f, spellInfo);
 
     SendEnergizeSpellLog(victim, spellId, damage, powerType);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit* Unit::EnsureVictim ( ) const

inline

         {
             ASSERT(m_attacking);
             return m_attacking;
         }

Here is the caller graph for this function:

void Unit::EnterVehicle	(	Unit *	base,
		int8	seatId = `-1`
	)

 {
     CastCustomSpell(VEHICLE_SPELL_RIDE_HARDCODED, SPELLVALUE_BASE_POINT0, seatId + 1, base, TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ExitVehicle ( Position const * exitPosition = NULL )

This function can be called at upper level code to initialize an exit from the passenger's side.

The following call would not even be executed successfully as the SPELL_AURA_CONTROL_VEHICLE unapply handler already calls _ExitVehicle without specifying an exitposition. The subsequent call below would return on if (!m_vehicle).

To do: We need to allow SPELL_AURA_CONTROL_VEHICLE unapply handlers in spellscripts to specify exit coordinates and either store those per passenger, or we need to init spline movement based on those coordinates in unapply handlers, and relocate exiting passengers based on Unit::moveSpline data. Either way, Coming Soon(TM)

 {
     if (!m_vehicle)
         return;
 
     GetVehicleBase()->RemoveAurasByType(SPELL_AURA_CONTROL_VEHICLE, GetGUID());
     /*_ExitVehicle(exitPosition);*/
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Spell * Unit::FindCurrentSpellBySpellId ( uint32 spell_id ) const

 {
     for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
         if (m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id == spell_id)
             return m_currentSpells[i];
     return NULL;
 }

Here is the caller graph for this function:

void Unit::FinishSpell	(	CurrentSpellTypes	spellType,
		bool	ok = `true`
	)

 {
     Spell* spell = m_currentSpells[spellType];
     if (!spell)
         return;
 
     if (spellType == CURRENT_CHANNELED_SPELL)
         spell->SendChannelUpdate(0);
 
     spell->finish(ok);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Player * Unit::GetAffectingPlayer ( ) const

 {
     if (!GetCharmerOrOwnerGUID())
         return const_cast<Unit*>(this)->ToPlayer();
 
     if (Unit* owner = GetCharmerOrOwner())
         return owner->GetCharmerOrOwnerPlayerOrPlayerItself();
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

UnitAI* Unit::GetAI ( )

inline

1331 { return i_AI; }

Unit::i_AI

UnitAI * i_AI

Definition: Unit.h:2242

uint16 Unit::GetAIAnimKitId ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1505 { return _aiAnimKitId; }

Unit::_aiAnimKitId

uint16 _aiAnimKitId

Definition: Unit.h:2358

void Unit::GetAllMinionsByEntry	(	std::list< TempSummon * > &	Minions,
		uint32	entry
	)

 {
     for (Unit::ControlList::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
     {
         Unit* unit = *itr;
         if (unit->GetEntry() == entry && unit->IsSummon()) // minion, actually
             Minions.push_back(unit->ToTempSummon());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetAPMultiplier	(	WeaponAttackType	attType,
		bool	normalized
	)

 {
     if (!normalized || GetTypeId() != TYPEID_PLAYER)
         return float(GetAttackTime(attType)) / 1000.0f;
 
     Item* Weapon = ToPlayer()->GetWeaponForAttack(attType, true);
     if (!Weapon)
         return 2.4f;                                         // fist attack
 
     switch (Weapon->GetTemplate()->GetInventoryType())
     {
         case INVTYPE_2HWEAPON:
             return 3.3f;
         case INVTYPE_RANGED:
         case INVTYPE_RANGEDRIGHT:
         case INVTYPE_THROWN:
             return 2.8f;
         case INVTYPE_WEAPON:
         case INVTYPE_WEAPONMAINHAND:
         case INVTYPE_WEAPONOFFHAND:
         default:
             return Weapon->GetTemplate()->GetSubClass() == ITEM_SUBCLASS_WEAPON_DAGGER ? 1.7f : 2.4f;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraApplicationMap& Unit::GetAppliedAuras ( )

inline

1789 { return m_appliedAuras; }

Unit::m_appliedAuras

AuraApplicationMap m_appliedAuras

Definition: Unit.h:2274

Here is the caller graph for this function:

AuraApplicationMap const& Unit::GetAppliedAuras ( ) const

inline

1790 { return m_appliedAuras; }

Unit::m_appliedAuras

AuraApplicationMap m_appliedAuras

Definition: Unit.h:2274

uint32 Unit::GetArmor ( ) const

inline

1419 { return GetResistance(SPELL_SCHOOL_NORMAL); }

SPELL_SCHOOL_NORMAL

Definition: SharedDefines.h:274

Unit::GetResistance

uint32 GetResistance(SpellSchools school) const

Definition: Unit.h:1422

Here is the caller graph for this function:

Unit * Unit::getAttackerForHelper ( ) const

 {
     if (GetVictim() != NULL)
         return GetVictim();
 
     if (!m_attackers.empty())
         return *(m_attackers.begin());
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AttackerSet const& Unit::getAttackers ( ) const

inline

1377 { return m_attackers; }

Unit::m_attackers

AttackerSet m_attackers

Definition: Unit.h:2255

Here is the caller graph for this function:

uint32 Unit::GetAttackTime ( WeaponAttackType att ) const

 {
     float f_BaseAttackTime = GetFloatValue(UNIT_FIELD_BASEATTACKTIME+att) / m_modAttackSpeedPct[att];
     return (uint32)f_BaseAttackTime;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::getAttackTimer ( WeaponAttackType type ) const

inline

1356 { return m_attackTimer[type]; }

Unit::m_attackTimer

uint32 m_attackTimer[MAX_ATTACK]

Definition: Unit.h:2251

Here is the caller graph for this function:

Aura * Unit::GetAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`
	)		const

 {
     AuraApplication * aurApp = GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask);
     return aurApp ? aurApp->GetBase() : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraApplication * Unit::GetAuraApplication	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		AuraApplication *	except = `NULL`
	)		const

 {
     AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
     for (; range.first != range.second; ++range.first)
     {
         AuraApplication* app = range.first->second;
         Aura const* aura = app->GetBase();
 
         if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
                 && (!casterGUID || aura->GetCasterGUID() == casterGUID)
                 && (!itemCasterGUID || aura->GetCastItemGUID() == itemCasterGUID)
                 && (!except || except != app))
         {
             return app;
         }
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraApplication * Unit::GetAuraApplicationOfRankedSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		AuraApplication *	except = `NULL`
	)		const

 {
     uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
     while (rankSpell)
     {
         if (AuraApplication * aurApp = GetAuraApplication(rankSpell, casterGUID, itemCasterGUID, reqEffMask, except))
             return aurApp;
         rankSpell = sSpellMgr->GetNextSpellInChain(rankSpell);
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetAuraCount ( uint32 spellId ) const

 {
     uint32 count = 0;
     AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
 
     for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
     {
         if (itr->second->GetBase()->GetStackAmount() == 0)
             ++count;
         else
             count += (uint32)itr->second->GetBase()->GetStackAmount();
     }
 
     return count;
 }

Here is the caller graph for this function:

AuraEffect * Unit::GetAuraEffect	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

 {
     AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
     for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
     {
         if (itr->second->HasEffect(effIndex)
                 && (!caster || itr->second->GetBase()->GetCasterGUID() == caster))
         {
             return itr->second->GetBase()->GetEffect(effIndex);
         }
     }
     return NULL;
 }

Here is the caller graph for this function:

AuraEffect * Unit::GetAuraEffect	(	AuraType	type,
		SpellFamilyNames	name,
		uint32	iconId,
		uint8	effIndex
	)		const

 {
     AuraEffectList const& auras = GetAuraEffectsByType(type);
     for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
     {
         if (effIndex != (*itr)->GetEffIndex())
             continue;
         SpellInfo const* spell = (*itr)->GetSpellInfo();
         if (spell->SpellIconID == iconId && spell->SpellFamilyName == uint32(name) && !spell->SpellFamilyFlags)
             return *itr;
     }
     return NULL;
 }

Here is the call graph for this function:

AuraEffect * Unit::GetAuraEffect	(	AuraType	type,
		SpellFamilyNames	family,
		flag128 const &	familyFlag,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

 {
     AuraEffectList const& auras = GetAuraEffectsByType(type);
     for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
     {
         SpellInfo const* spell = (*i)->GetSpellInfo();
         if (spell->SpellFamilyName == uint32(family) && spell->SpellFamilyFlags & familyFlag)
         {
             if (!casterGUID.IsEmpty() && (*i)->GetCasterGUID() != casterGUID)
                 continue;
             return (*i);
         }
     }
     return NULL;
 }

Here is the call graph for this function:

AuraEffect * Unit::GetAuraEffectOfRankedSpell	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

 {
     uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
     while (rankSpell)
     {
         if (AuraEffect* aurEff = GetAuraEffect(rankSpell, effIndex, caster))
             return aurEff;
         rankSpell = sSpellMgr->GetNextSpellInChain(rankSpell);
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraEffectList const& Unit::GetAuraEffectsByType ( AuraType type ) const

inline

1832 { return m_modAuras[type]; }

Unit::m_modAuras

AuraEffectList m_modAuras[TOTAL_AURAS]

Definition: Unit.h:2279

Aura * Unit::GetAuraOfRankedSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`
	)		const

 {
     AuraApplication * aurApp = GetAuraApplicationOfRankedSpell(spellId, casterGUID, itemCasterGUID, reqEffMask);
     return aurApp ? aurApp->GetBase() : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual uint32 Unit::GetBlockPercent ( ) const

inlinevirtual

1557 { return 30; }

Here is the caller graph for this function:

uint32 Unit::GetCastingTimeForBonus	(	SpellInfo const *	spellProto,
		DamageEffectType	damagetype,
		uint32	CastingTime
	)		const

 {
     // Not apply this to creature cast spells with casttime == 0
     if (CastingTime == 0 && GetTypeId() == TYPEID_UNIT && !IsPet())
         return 3500;
 
     if (CastingTime > 7000) CastingTime = 7000;
     if (CastingTime < 1500) CastingTime = 1500;
 
     if (damagetype == DOT && !spellProto->IsChanneled())
         CastingTime = 3500;
 
     int32 overTime    = 0;
     uint8 effects     = 0;
     bool DirectDamage = false;
     bool AreaEffect   = false;
 
     for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect)
             continue;
         switch (effect->Effect)
         {
             case SPELL_EFFECT_SCHOOL_DAMAGE:
             case SPELL_EFFECT_POWER_DRAIN:
             case SPELL_EFFECT_HEALTH_LEECH:
             case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
             case SPELL_EFFECT_POWER_BURN:
             case SPELL_EFFECT_HEAL:
                 DirectDamage = true;
                 break;
             case SPELL_EFFECT_APPLY_AURA:
                 switch (effect->ApplyAuraName)
                 {
                     case SPELL_AURA_PERIODIC_DAMAGE:
                     case SPELL_AURA_PERIODIC_HEAL:
                     case SPELL_AURA_PERIODIC_LEECH:
                         if (spellProto->GetDuration())
                             overTime = spellProto->GetDuration();
                         break;
                     default:
                         // -5% per additional effect
                         ++effects;
                         break;
                 }
             default:
                 break;
         }
 
         if (effect->IsTargetingArea())
             AreaEffect = true;
     }
 
     // Combined Spells with Both Over Time and Direct Damage
     if (overTime > 0 && CastingTime > 0 && DirectDamage)
     {
         // mainly for DoTs which are 3500 here otherwise
         uint32 OriginalCastTime = spellProto->CalcCastTime(getLevel());
         if (OriginalCastTime > 7000) OriginalCastTime = 7000;
         if (OriginalCastTime < 1500) OriginalCastTime = 1500;
         // Portion to Over Time
         float PtOT = (overTime / 15000.0f) / ((overTime / 15000.0f) + (OriginalCastTime / 3500.0f));
 
         if (damagetype == DOT)
             CastingTime = uint32(CastingTime * PtOT);
         else if (PtOT < 1.0f)
             CastingTime  = uint32(CastingTime * (1 - PtOT));
         else
             CastingTime = 0;
     }
 
     // Area Effect Spells receive only half of bonus
     if (AreaEffect)
         CastingTime /= 2;
 
     // 50% for damage and healing spells for leech spells from damage bonus and 0% from healing
     for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect)
             continue;
         if (effect->Effect == SPELL_EFFECT_HEALTH_LEECH ||
             (effect->Effect == SPELL_EFFECT_APPLY_AURA && effect->ApplyAuraName == SPELL_AURA_PERIODIC_LEECH))
         {
             CastingTime /= 2;
             break;
         }
     }
 
     // -5% of total per any additional effect
     for (uint8 i = 0; i < effects; ++i)
         CastingTime *= 0.95f;
 
     return CastingTime;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellInfo const * Unit::GetCastSpellInfo ( SpellInfo const * spellInfo ) const

virtual

 {
     Unit::AuraEffectList swaps = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_ACTIONBAR_SPELLS);
     Unit::AuraEffectList const& swaps2 = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_ACTIONBAR_SPELLS_2);
     if (!swaps2.empty())
         swaps.insert(swaps.end(), swaps2.begin(), swaps2.end());
 
     for (AuraEffect const* auraEffect : swaps)
     {
         if ((!auraEffect->GetSpellEffectInfo()->SpellClassMask && uint32(auraEffect->GetMiscValue()) == spellInfo->Id) ||
             (auraEffect->GetSpellEffectInfo()->SpellClassMask && auraEffect->IsAffectingSpell(spellInfo)))
                 if (SpellInfo const* newInfo = sSpellMgr->GetSpellInfo(auraEffect->GetAmount()))
                     return newInfo;
     }
 
     return spellInfo;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetChannelObjectGuid ( ) const

inline

1904 { return GetGuidValue(UNIT_FIELD_CHANNEL_OBJECT); }

Definition: UpdateFields.h:92

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Unit::GetCharm ( ) const

 {
     ObjectGuid charm_guid = GetCharmGUID();
     if (!charm_guid.IsEmpty())
     {
         if (Unit* pet = ObjectAccessor::GetUnit(*this, charm_guid))
             return pet;
 
         TC_LOG_ERROR("entities.unit", "Unit::GetCharm: Charmed creature %s not exist.", charm_guid.ToString().c_str());
         const_cast<Unit*>(this)->SetGuidValue(UNIT_FIELD_CHARM, ObjectGuid::Empty);
     }
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Unit::GetCharmer ( ) const

 {
     ObjectGuid charmerGUID = GetCharmerGUID();
     if (!charmerGUID.IsEmpty())
         return ObjectAccessor::GetUnit(*this, charmerGUID);
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetCharmerGUID ( ) const

inline

1704 { return GetGuidValue(UNIT_FIELD_CHARMEDBY); }

UNIT_FIELD_CHARMEDBY

Definition: UpdateFields.h:85

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Unit::GetCharmerOrOwner ( ) const

 {
     return !GetCharmerGUID().IsEmpty() ? GetCharmer() : GetOwner();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetCharmerOrOwnerGUID ( ) const

 {
     return !GetCharmerGUID().IsEmpty() ? GetCharmerGUID() : GetOwnerGUID();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetCharmerOrOwnerOrOwnGUID ( ) const

 {
     ObjectGuid guid = GetCharmerOrOwnerGUID();
     if (!guid.IsEmpty())
         return guid;
 
     return GetGUID();
 }

Here is the call graph for this function:

Unit * Unit::GetCharmerOrOwnerOrSelf ( ) const

 {
     if (Unit* u = GetCharmerOrOwner())
         return u;
 
     return (Unit*)this;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Player * Unit::GetCharmerOrOwnerPlayerOrPlayerItself ( ) const

 {
     ObjectGuid guid = GetCharmerOrOwnerGUID();
     if (guid.IsPlayer())
         return ObjectAccessor::GetPlayer(*this, guid);
 
     return const_cast<Unit*>(this)->ToPlayer();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetCharmGUID ( ) const

inline

1706 { return GetGuidValue(UNIT_FIELD_CHARM); }

UNIT_FIELD_CHARM

Definition: UpdateFields.h:82

UNIT_BYTES_0_OFFSET_CLASS

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the call graph for this function:

Here is the caller graph for this function:

CharmInfo* Unit::GetCharmInfo ( )

inline

1748 { return m_charmInfo; }

Unit::m_charmInfo

CharmInfo * m_charmInfo

Definition: Unit.h:2292

Here is the caller graph for this function:

uint8 Unit::getClass ( ) const

inline

1413 { return GetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_CLASS); }

UNIT_FIELD_BYTES_0

Definition: UpdateFields.h:96

Definition: Unit.h:233

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::getClassMask ( ) const

inline

1414 { return 1 << (getClass()-1); }

Unit::getClass

uint8 getClass() const

Definition: Unit.h:1413

Here is the caller graph for this function:

uint32 Unit::GetCombatRatingDamageReduction	(	CombatRating	cr,
		float	rate,
		float	cap,
		uint32	damage
	)		const

private

 {
     float percent = std::min(GetCombatRatingReduction(cr) * rate, cap);
     return CalculatePct(damage, percent);
 }

Here is the call graph for this function:

float Unit::GetCombatRatingReduction ( CombatRating cr ) const

private

 {
     if (Player const* player = ToPlayer())
         return player->GetRatingBonusValue(cr);
     // Player's pet get resilience from owner
     else if (IsPet() && GetOwner())
         if (Player* owner = GetOwner()->ToPlayer())
             return owner->GetRatingBonusValue(cr);
 
     return 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetCombatReach ( ) const

inline

1361 { return m_floatValues[UNIT_FIELD_COMBATREACH]; }

UNIT_FIELD_COMBATREACH

Definition: UpdateFields.h:116

Object::m_floatValues

float * m_floatValues

Definition: Object.h:236

Here is the caller graph for this function:

uint32 Unit::GetCombatTimer ( ) const

inline

1590 { return m_CombatTimer; }

Unit::m_CombatTimer

uint32 m_CombatTimer

Definition: Unit.h:2341

Here is the caller graph for this function:

uint32 Unit::GetCreateHealth ( ) const

inline

1895 { return GetUInt32Value(UNIT_FIELD_BASE_HEALTH); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_BASE_HEALTH

Definition: UpdateFields.h:145

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetCreateMana ( ) const

inline

1897 { return GetUInt32Value(UNIT_FIELD_BASE_MANA); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_BASE_MANA

Definition: UpdateFields.h:144

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetCreatePowers ( Powers power ) const

 {
     switch (power)
     {
         case POWER_MANA:
             return GetCreateMana();
         case POWER_RAGE:
             return 1000;
         case POWER_FOCUS:
             if (GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_HUNTER)
                 return 100;
             return (GetTypeId() == TYPEID_PLAYER || !((Creature const*)this)->IsPet() || ((Pet const*)this)->getPetType() != HUNTER_PET ? 0 : 100);
         case POWER_ENERGY:
             return 100;
         case POWER_COMBO_POINTS:
             return 5;
         case POWER_RUNIC_POWER:
             return 1000;
         case POWER_RUNES:
             return 0;
         case POWER_SOUL_SHARDS:
             return 400;
         case POWER_ECLIPSE:
             return 100;
         case POWER_HOLY_POWER:
             return 3;
         case POWER_CHI:
             return 4;
         case POWER_SHADOW_ORBS:
             return 3;
         case POWER_BURNING_EMBERS:
             return 40;
         case POWER_DEMONIC_FURY:
             return 1000;
         case POWER_ARCANE_CHARGES:
             return 4;
         case POWER_HEALTH:
             return 0;
         default:
             break;
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetCreateStat ( Stats stat ) const

inline

1902 { return m_createStats[stat]; }

Unit::m_createStats

float m_createStats[MAX_STATS]

Definition: Unit.h:2253

Here is the caller graph for this function:

ObjectGuid Unit::GetCreatorGUID ( ) const

inline

1700 { return GetGuidValue(UNIT_FIELD_CREATEDBY); }

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

UNIT_FIELD_CREATEDBY

Definition: UpdateFields.h:87

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetCreatureType ( ) const

 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
         ShapeshiftForm form = GetShapeshiftForm();
         SpellShapeshiftFormEntry const* ssEntry = sSpellShapeshiftFormStore.LookupEntry(form);
         if (ssEntry && ssEntry->CreatureType > 0)
             return ssEntry->CreatureType;
         else
             return CREATURE_TYPE_HUMANOID;
     }
     else
         return ToCreature()->GetCreatureTemplate()->type;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetCreatureTypeMask ( ) const

 {
     uint32 creatureType = GetCreatureType();
     return (creatureType >= 1) ? (1 << (creatureType - 1)) : 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Unit::GetCritterGUID ( ) const

inline

1710 { return GetGuidValue(UNIT_FIELD_CRITTER); }

UNIT_FIELD_CRITTER

Definition: UpdateFields.h:84

CR_RESILIENCE_PLAYER_DAMAGE_TAKEN

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the call graph for this function:

Here is the caller graph for this function:

Spell* Unit::GetCurrentSpell ( CurrentSpellTypes spellType ) const

inline

1920 { return m_currentSpells[spellType]; }

Unit::m_currentSpells

Spell * m_currentSpells[CURRENT_MAX_SPELL]

Definition: Unit.h:2271

Here is the caller graph for this function:

Spell* Unit::GetCurrentSpell ( uint32 spellType ) const

inline

1921 { return m_currentSpells[spellType]; }

Unit::m_currentSpells

Spell * m_currentSpells[CURRENT_MAX_SPELL]

Definition: Unit.h:2271

int32 Unit::GetCurrentSpellCastTime ( uint32 spell_id ) const

 {
     if (Spell const* spell = FindCurrentSpellBySpellId(spell_id))
         return spell->GetCastTime();
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetDamageReduction ( uint32 damage ) const

inline

1540 { return GetCombatRatingDamageReduction(CR_RESILIENCE_PLAYER_DAMAGE_TAKEN, 1.0f, 100.0f, damage); }

Definition: Unit.h:640

Unit::GetCombatRatingDamageReduction

uint32 GetCombatRatingDamageReduction(CombatRating cr, float rate, float cap, uint32 damage) const

Definition: Unit.cpp:14690

Here is the caller graph for this function:

DeathState Unit::getDeathState ( ) const

inline

1695 { return m_deathState; }

DeathState m_deathState

Definition: Unit.h:2259

Here is the caller graph for this function:

DiminishingLevels Unit::GetDiminishing ( DiminishingGroup group )

 {
     for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
     {
         if (i->DRGroup != group)
             continue;
 
         if (!i->hitCount)
             return DIMINISHING_LEVEL_1;
 
         if (!i->hitTime)
             return DIMINISHING_LEVEL_1;
 
         // If last spell was cast more than 18 seconds ago - reset the count.
         if (i->stack == 0 && getMSTimeDiff(i->hitTime, getMSTime()) > 18 * IN_MILLISECONDS)
         {
             i->hitCount = DIMINISHING_LEVEL_1;
             return DIMINISHING_LEVEL_1;
         }
         // or else increase the count.
         else
             return DiminishingLevels(i->hitCount);
     }
     return DIMINISHING_LEVEL_1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TransportBase * Unit::GetDirectTransport ( ) const

Returns the transport this unit is on directly (if on vehicle and transport, return vehicle)

 {
     if (Vehicle* veh = GetVehicle())
         return veh;
     return GetTransport();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetDiseasesByCaster	(	ObjectGuid	casterGUID,
		bool	remove = `false`
	)

 {
     static const AuraType diseaseAuraTypes[] =
     {
         SPELL_AURA_PERIODIC_DAMAGE, // Frost Fever and Blood Plague
         SPELL_AURA_LINKED,          // Crypt Fever and Ebon Plague
         SPELL_AURA_NONE
     };
 
     uint32 diseases = 0;
     for (AuraType const* itr = diseaseAuraTypes; *itr != SPELL_AURA_NONE; ++itr)
     {
         for (AuraEffectList::iterator i = m_modAuras[*itr].begin(); i != m_modAuras[*itr].end();)
         {
             // Get auras with disease dispel type by caster
             if ((*i)->GetSpellInfo()->Dispel == DISPEL_DISEASE
                 && (*i)->GetCasterGUID() == casterGUID)
             {
                 ++diseases;
 
                 if (remove)
                 {
                     RemoveAura((*i)->GetId(), (*i)->GetCasterGUID());
                     i = m_modAuras[*itr].begin();
                     continue;
                 }
             }
             ++i;
         }
     }
     return diseases;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::GetDispellableAuraList	(	Unit *	caster,
		uint32	dispelMask,
		DispelChargesList &	dispelList
	)

 {
     AuraMap const& auras = GetOwnedAuras();
     for (AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
     {
         Aura* aura = itr->second;
         AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID());
         if (!aurApp)
             continue;
 
         // don't try to remove passive auras
         if (aura->IsPassive())
             continue;
 
         if (aura->GetSpellInfo()->GetDispelMask() & dispelMask)
         {
             if (aura->GetSpellInfo()->Dispel == DISPEL_MAGIC)
             {
                 // do not remove positive auras if friendly target
                 //               negative auras if non-friendly target
                 if (aurApp->IsPositive() == IsFriendlyTo(caster))
                     continue;
             }
 
             // The charges / stack amounts don't count towards the total number of auras that can be dispelled.
             // Ie: A dispel on a target with 5 stacks of Winters Chill and a Polymorph has 1 / (1 + 1) -> 50% chance to dispell
             // Polymorph instead of 1 / (5 + 1) -> 16%.
             bool dispel_charges = (aura->GetSpellInfo()->AttributesEx7 & SPELL_ATTR7_DISPEL_CHARGES) != 0;
             uint8 charges = dispel_charges ? aura->GetCharges() : aura->GetStackAmount();
             if (charges > 0)
                 dispelList.push_back(std::make_pair(aura, charges));
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetDisplayId ( ) const

inline

2012 { return GetUInt32Value(UNIT_FIELD_DISPLAYID); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_DISPLAYID

Definition: UpdateFields.h:117

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetDoTsByCaster ( ObjectGuid casterGUID ) const

 {
     static const AuraType diseaseAuraTypes[] =
     {
         SPELL_AURA_PERIODIC_DAMAGE,
         SPELL_AURA_PERIODIC_DAMAGE_PERCENT,
         SPELL_AURA_NONE
     };
 
     uint32 dots = 0;
     for (AuraType const* itr = &diseaseAuraTypes[0]; itr && itr[0] != SPELL_AURA_NONE; ++itr)
     {
         Unit::AuraEffectList const& auras = GetAuraEffectsByType(*itr);
         for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
         {
             // Get auras by caster
             if ((*i)->GetCasterGUID() == casterGUID)
                 ++dots;
         }
     }
     return dots;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraEffect * Unit::GetDummyAuraEffect	(	SpellFamilyNames	name,
		uint32	iconId,
		uint8	effIndex
	)		const

 {
     return GetAuraEffect(SPELL_AURA_DUMMY, name, iconId, effIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DynamicObject * Unit::GetDynObject ( uint32 spellId )

 {
     if (m_dynObj.empty())
         return NULL;
     for (DynObjectList::const_iterator i = m_dynObj.begin(); i != m_dynObj.end();++i)
     {
         DynamicObject* dynObj = *i;
         if (dynObj->GetSpellId() == spellId)
             return dynObj;
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Unit::GetExtraUnitMovementFlags ( ) const

inline

2116 { return m_movementInfo.GetExtraMovementFlags(); }

MovementInfo::GetExtraMovementFlags

MovementInfo m_movementInfo

Definition: Object.h:612

uint16 GetExtraMovementFlags() const

Definition: Object.h:332

Here is the caller graph for this function:

uint32 Unit::getFaction ( ) const

inline

1466 { return GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE); }

UNIT_FIELD_FACTIONTEMPLATE

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

Definition: UpdateFields.h:107

Here is the call graph for this function:

ReputationRank Unit::GetFactionReactionTo	(	FactionTemplateEntry const *	factionTemplateEntry,
		Unit const *	target
	)

static

 {
     // always neutral when no template entry found
     if (!factionTemplateEntry)
         return REP_NEUTRAL;
 
     FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry();
     if (!targetFactionTemplateEntry)
         return REP_NEUTRAL;
 
     if (Player const* targetPlayerOwner = target->GetAffectingPlayer())
     {
         // check contested flags
         if (factionTemplateEntry->Flags & FACTION_TEMPLATE_FLAG_CONTESTED_GUARD
             && targetPlayerOwner->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP))
             return REP_HOSTILE;
         if (ReputationRank const* repRank = targetPlayerOwner->GetReputationMgr().GetForcedRankIfAny(factionTemplateEntry))
             return *repRank;
         if (!target->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_IGNORE_REPUTATION))
         {
             if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplateEntry->Faction))
             {
                 if (factionEntry->CanHaveReputation())
                 {
                     // CvP case - check reputation, don't allow state higher than neutral when at war
                     ReputationRank repRank = targetPlayerOwner->GetReputationMgr().GetRank(factionEntry);
                     if (targetPlayerOwner->GetReputationMgr().IsAtWar(factionEntry))
                         repRank = std::min(REP_NEUTRAL, repRank);
                     return repRank;
                 }
             }
         }
     }
 
     // common faction based check
     if (factionTemplateEntry->IsHostileTo(*targetFactionTemplateEntry))
         return REP_HOSTILE;
     if (factionTemplateEntry->IsFriendlyTo(*targetFactionTemplateEntry))
         return REP_FRIENDLY;
     if (targetFactionTemplateEntry->IsFriendlyTo(*factionTemplateEntry))
         return REP_FRIENDLY;
     if (factionTemplateEntry->Flags & FACTION_TEMPLATE_FLAG_HOSTILE_BY_DEFAULT)
         return REP_HOSTILE;
     // neutral by default
     return REP_NEUTRAL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

FactionTemplateEntry const * Unit::GetFactionTemplateEntry ( ) const

 {
     FactionTemplateEntry const* entry = sFactionTemplateStore.LookupEntry(getFaction());
     if (!entry)
     {
         if (Player const* player = ToPlayer())
             TC_LOG_ERROR("entities.unit", "Player %s has invalid faction (faction template id) #%u", player->GetName().c_str(), getFaction());
         else if (Creature const* creature = ToCreature())
             TC_LOG_ERROR("entities.unit", "Creature (template id: %u) has invalid faction (faction template id) #%u", creature->GetCreatureTemplate()->Entry, getFaction());
         else
             TC_LOG_ERROR("entities.unit", "Unit (name=%s, type=%u) has invalid faction (faction template id) #%u", GetName().c_str(), uint32(GetTypeId()), getFaction());
     }
     return entry;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Unit::GetFirstControlled ( ) const

 {
     // Sequence: charmed, pet, other guardians
     Unit* unit = GetCharm();
     if (!unit)
     {
         ObjectGuid guid = GetMinionGUID();
         if (!guid.IsEmpty())
             unit = ObjectAccessor::GetUnit(*this, guid);
     }
 
     return unit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Minion * Unit::GetFirstMinion ( ) const

 {
     ObjectGuid pet_guid = GetMinionGUID();
     if (!pet_guid.IsEmpty())
     {
         if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid))
             if (pet->HasUnitTypeMask(UNIT_MASK_MINION))
                 return (Minion*)pet;
 
         TC_LOG_ERROR("entities.unit", "Unit::GetFirstMinion: Minion %s not exist.", pet_guid.ToString().c_str());
         const_cast<Unit*>(this)->SetMinionGUID(ObjectGuid::Empty);
     }
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual float Unit::GetFollowAngle ( ) const

inlinevirtual

Reimplemented in Minion.

2194 { return static_cast<float>(M_PI/2); }

M_PI

#define M_PI

Definition: Common.h:163

Here is the caller graph for this function:

GameObject * Unit::GetGameObject ( uint32 spellId ) const

 {
     for (GameObjectList::const_iterator i = m_gameObj.begin(); i != m_gameObj.end(); ++i)
         if ((*i)->GetSpellId() == spellId)
             return *i;
 
     return NULL;
 }

Here is the caller graph for this function:

uint8 Unit::getGender ( ) const

inline

1415 { return GetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER); }

UNIT_BYTES_0_OFFSET_GENDER

Definition: Unit.h:234

UNIT_FIELD_BYTES_0

Definition: UpdateFields.h:96

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

Here is the caller graph for this function:

Guardian * Unit::GetGuardianPet ( ) const

 {
     ObjectGuid pet_guid = GetPetGUID();
     if (!pet_guid.IsEmpty())
     {
         if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid))
             if (pet->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
                 return (Guardian*)pet;
 
         TC_LOG_FATAL("entities.unit", "Unit::GetGuardianPet: Guardian %s not exist.", pet_guid.ToString().c_str());
         const_cast<Unit*>(this)->SetPetGUID(ObjectGuid::Empty);
     }
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetHealth ( ) const

inline

1426 { return GetUInt32Value(UNIT_FIELD_HEALTH); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_HEALTH

Definition: UpdateFields.h:99

Here is the call graph for this function:

int32 Unit::GetHealthGain ( int32 dVal )

 {
     int32 gain = 0;
 
     if (dVal == 0)
         return 0;
 
     int32 curHealth = (int32)GetHealth();
 
     int32 val = dVal + curHealth;
     if (val <= 0)
     {
         return -curHealth;
     }
 
     int32 maxHealth = (int32)GetMaxHealth();
 
     if (val < maxHealth)
         gain = dVal;
     else if (curHealth != maxHealth)
         gain = maxHealth - curHealth;
 
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetHealthPct ( ) const

inline

1434 { return GetMaxHealth() ? 100.f * GetHealth() / GetMaxHealth() : 0.0f; }

uint32 GetMaxHealth() const

Definition: Unit.h:1427

Unit::m_HostileRefManager

uint32 GetHealth() const

Definition: Unit.h:1426

Here is the caller graph for this function:

int32 Unit::GetHighestExclusiveSameEffectSpellGroupValue	(	AuraEffect const *	aurEff,
		AuraType	auraType,
		bool	checkMiscValue = `false`,
		int32	miscValue = `0`
	)		const

 {
     int32 val = 0;
     SpellSpellGroupMapBounds spellGroup = sSpellMgr->GetSpellSpellGroupMapBounds(aurEff->GetSpellInfo()->GetFirstRankSpell()->Id);
     for (SpellSpellGroupMap::const_iterator itr = spellGroup.first; itr != spellGroup.second ; ++itr)
     {
         if (sSpellMgr->GetSpellGroupStackRule(itr->second) == SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT)
         {
             AuraEffectList const& auraEffList = GetAuraEffectsByType(auraType);
             for (AuraEffectList::const_iterator auraItr = auraEffList.begin(); auraItr != auraEffList.end(); ++auraItr)
             {
                 if (aurEff != (*auraItr) && (!checkMiscValue || (*auraItr)->GetMiscValue() == miscValue) &&
                     sSpellMgr->IsSpellMemberOfSpellGroup((*auraItr)->GetSpellInfo()->Id, itr->second))
                 {
                     // absolute value only
                     if (abs(val) < abs((*auraItr)->GetAmount()))
                         val = (*auraItr)->GetAmount();
                 }
             }
         }
     }
     return val;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

HostileRefManager& Unit::getHostileRefManager ( )

inline

2001 { return m_HostileRefManager; }

HostileRefManager m_HostileRefManager

Definition: Unit.h:2346

Here is the caller graph for this function:

uint32 Unit::GetInterruptMask ( ) const

inline

2008 { return m_interruptMask; }

Unit::m_interruptMask

uint32 m_interruptMask

Definition: Unit.h:2283

time_t Unit::GetLastDamagedTime ( ) const

inline

2216 { return _lastDamagedTime; }

Unit::_lastDamagedTime

time_t _lastDamagedTime

Definition: Unit.h:2362

Here is the caller graph for this function:

uint8 Unit::getLevel ( ) const

inline

1408 { return uint8(GetUInt32Value(UNIT_FIELD_LEVEL)); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_LEVEL

Definition: UpdateFields.h:105

G3D::uint8

uint8_t uint8

Definition: g3dmath.h:164

Here is the call graph for this function:

uint8 Unit::getLevelForTarget ( WorldObject const * ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1409 { return getLevel(); }

Unit::getLevel

uint8 getLevel() const

Definition: Unit.h:1408

Here is the caller graph for this function:

Unit * Unit::GetMagicHitRedirectTarget	(	Unit *	victim,
		SpellInfo const *	spellInfo
	)

Todo:: handle this charge drop by proc in cast phase on explicit target

 {
     // Patch 1.2 notes: Spell Reflection no longer reflects abilities
     if (spellInfo->HasAttribute(SPELL_ATTR0_ABILITY) || spellInfo->HasAttribute(SPELL_ATTR1_CANT_BE_REDIRECTED) || spellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY))
         return victim;
 
     Unit::AuraEffectList const& magnetAuras = victim->GetAuraEffectsByType(SPELL_AURA_SPELL_MAGNET);
     for (Unit::AuraEffectList::const_iterator itr = magnetAuras.begin(); itr != magnetAuras.end(); ++itr)
     {
         if (Unit* magnet = (*itr)->GetBase()->GetCaster())
             if (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK
                 && _IsValidAttackTarget(magnet, spellInfo))
             {
                 if (spellInfo->Speed > 0.0f)
                 {
                     // Set up missile speed based delay
                     uint32 delay = uint32(std::floor(std::max<float>(victim->GetDistance(this), 5.0f) / spellInfo->Speed * 1000.0f));
                     // Schedule charge drop
                     (*itr)->GetBase()->DropChargeDelayed(delay, AURA_REMOVE_BY_EXPIRE);
                 }
                 else
                     (*itr)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE);
 
                 return magnet;
             }
     }
     return victim;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetMaxHealth ( ) const

inline

1427 { return GetUInt32Value(UNIT_FIELD_MAXHEALTH); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_MAXHEALTH

Definition: UpdateFields.h:101

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMaxNegativeAuraModifier ( AuraType auratype ) const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if ((*i)->GetAmount() < modifier)
             modifier = (*i)->GetAmount();
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMaxNegativeAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->IsAffectingSpell(affectedSpell) && (*i)->GetAmount() < modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

int32 Unit::GetMaxNegativeAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetMiscValue()& miscMask && (*i)->GetAmount() < modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

int32 Unit::GetMaxNegativeAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetMiscValue() == miscValue && (*i)->GetAmount() < modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMaxPositiveAuraModifier ( AuraType auratype ) const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetAmount() > modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMaxPositiveAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->IsAffectingSpell(affectedSpell) && (*i)->GetAmount() > modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

int32 Unit::GetMaxPositiveAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask,
		const AuraEffect *	except = `NULL`
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if (except != (*i) && (*i)->GetMiscValue()& miscMask && (*i)->GetAmount() > modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMaxPositiveAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

 {
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetMiscValue() == miscValue && (*i)->GetAmount() > modifier)
             modifier = (*i)->GetAmount();
     }
 
     return modifier;
 }

Here is the call graph for this function:

int32 Unit::GetMaxPower ( Powers power ) const

 {
     uint32 powerIndex = GetPowerIndex(power);
     if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
         return 0;
 
     return GetInt32Value(UNIT_FIELD_MAXPOWER + powerIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Unit::GetMaxSkillValueForLevel ( Unit const * target = NULL ) const

inline

1511 { return (target ? getLevelForTarget(target) : getLevel()) * 5; }

Unit::getLevelForTarget

uint8 getLevelForTarget(WorldObject const *) const override

Definition: Unit.h:1409

Unit::getLevel

uint8 getLevel() const

Definition: Unit.h:1408

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetMechanicImmunityMask ( ) const

 {
     uint32 mask = 0;
     SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
     for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
         mask |= (1 << itr->type);
 
     return mask;
 }

int32 Unit::GetMechanicResistChance ( SpellInfo const * spellInfo ) const

 {
     if (!spellInfo)
         return 0;
 
     int32 resistMech = 0;
     for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect || !effect->IsEffect())
             break;
 
         int32 effectMech = spellInfo->GetEffectMechanic(effect->EffectIndex, GetMap()->GetDifficultyID());
         if (effectMech)
         {
             int32 temp = GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effectMech);
             if (resistMech < temp)
                 resistMech = temp;
         }
     }
     return resistMech;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Unit::GetMeleeAnimKitId ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1509 { return _meleeAnimKitId; }

Unit::_meleeAnimKitId

uint16 _meleeAnimKitId

Definition: Unit.h:2360

SpellSchoolMask Unit::GetMeleeDamageSchoolMask ( ) const

protectedvirtual

Reimplemented in Creature.

 {
     return SPELL_SCHOOL_MASK_NORMAL;
 }

Here is the caller graph for this function:

Unit * Unit::GetMeleeHitRedirectTarget	(	Unit *	victim,
		SpellInfo const *	spellInfo = `NULL`
	)

 {
     AuraEffectList const& hitTriggerAuras = victim->GetAuraEffectsByType(SPELL_AURA_ADD_CASTER_HIT_TRIGGER);
     for (AuraEffectList::const_iterator i = hitTriggerAuras.begin(); i != hitTriggerAuras.end(); ++i)
     {
         if (Unit* magnet = (*i)->GetBase()->GetCaster())
             if (_IsValidAttackTarget(magnet, spellInfo) && magnet->IsWithinLOSInMap(this)
                 && (!spellInfo || (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK
                 && spellInfo->CheckTarget(this, magnet, false) == SPELL_CAST_OK)))
                 if (roll_chance_i((*i)->GetAmount()))
                 {
                     (*i)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE);
                     return magnet;
                 }
     }
     return victim;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetMeleeReach ( ) const

 {
     float reach = m_floatValues[UNIT_FIELD_COMBATREACH];
     return reach > MIN_MELEE_REACH ? reach : MIN_MELEE_REACH;
 }

Here is the caller graph for this function:

ObjectGuid Unit::GetMinionGUID ( ) const

inline

1702 { return GetGuidValue(UNIT_FIELD_SUMMON); }

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

UNIT_FIELD_SUMMON

Definition: UpdateFields.h:83

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetMinPower ( Powers power ) const

inline

1447 { return power == POWER_ECLIPSE ? -100 : 0; }

POWER_ECLIPSE

Definition: SharedDefines.h:256

Here is the caller graph for this function:

uint32 Unit::GetModelForForm ( ShapeshiftForm form ) const

Glyph of Arctic Wolf

 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
         switch (form)
         {
             case FORM_CAT:
                 // Based on Hair color
                 if (getRace() == RACE_NIGHTELF)
                 {
                     uint8 hairColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID);
                     switch (hairColor)
                     {
                         case 7: // Violet
                         case 8:
                             return 29405;
                         case 3: // Light Blue
                             return 29406;
                         case 0: // Green
                         case 1: // Light Green
                         case 2: // Dark Green
                             return 29407;
                         case 4: // White
                             return 29408;
                         default: // original - Dark Blue
                             return 892;
                     }
                 }
                 else if (getRace() == RACE_TROLL)
                 {
                     uint8 hairColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID);
                     switch (hairColor)
                     {
                         case 0: // Red
                         case 1:
                             return 33668;
                         case 2: // Yellow
                         case 3:
                             return 33667;
                         case 4: // Blue
                         case 5:
                         case 6:
                             return 33666;
                         case 7: // Purple
                         case 10:
                             return 33665;
                         default: // original - white
                             return 33669;
                     }
                 }
                 else if (getRace() == RACE_WORGEN)
                 {
                     // Based on Skin color
                     uint8 skinColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID);
                     // Male
                     if (getGender() == GENDER_MALE)
                     {
                         switch (skinColor)
                         {
                             case 1: // Brown
                                 return 33662;
                             case 2: // Black
                             case 7:
                                 return 33661;
                             case 4: // yellow
                                 return 33664;
                             case 3: // White
                             case 5:
                                 return 33663;
                             default: // original - Gray
                                 return 33660;
                         }
                     }
                     // Female
                     else
                     {
                         switch (skinColor)
                         {
                             case 5: // Brown
                             case 6:
                                 return 33662;
                             case 7: // Black
                             case 8:
                                 return 33661;
                             case 3: // yellow
                             case 4:
                                 return 33664;
                             case 2: // White
                                 return 33663;
                             default: // original - Gray
                                 return 33660;
                         }
                     }
                 }
                 // Based on Skin color
                 else if (getRace() == RACE_TAUREN)
                 {
                     uint8 skinColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID);
                     // Male
                     if (getGender() == GENDER_MALE)
                     {
                         switch (skinColor)
                         {
                             case 12: // White
                             case 13:
                             case 14:
                             case 18: // Completly White
                                 return 29409;
                             case 9: // Light Brown
                             case 10:
                             case 11:
                                 return 29410;
                             case 6: // Brown
                             case 7:
                             case 8:
                                 return 29411;
                             case 0: // Dark
                             case 1:
                             case 2:
                             case 3: // Dark Grey
                             case 4:
                             case 5:
                                 return 29412;
                             default: // original - Grey
                                 return 8571;
                         }
                     }
                     // Female
                     else
                     {
                         switch (skinColor)
                         {
                             case 10: // White
                                 return 29409;
                             case 6: // Light Brown
                             case 7:
                                 return 29410;
                             case 4: // Brown
                             case 5:
                                 return 29411;
                             case 0: // Dark
                             case 1:
                             case 2:
                             case 3:
                                 return 29412;
                             default: // original - Grey
                                 return 8571;
                         }
                     }
                 }
                 else if (Player::TeamForRace(getRace()) == ALLIANCE)
                     return 892;
                 else
                     return 8571;
             case FORM_BEAR:
                 // Based on Hair color
                 if (getRace() == RACE_NIGHTELF)
                 {
                     uint8 hairColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID);
                     switch (hairColor)
                     {
                         case 0: // Green
                         case 1: // Light Green
                         case 2: // Dark Green
                             return 29413; // 29415?
                         case 6: // Dark Blue
                             return 29414;
                         case 4: // White
                             return 29416;
                         case 3: // Light Blue
                             return 29417;
                         default: // original - Violet
                             return 2281;
                     }
                 }
                 else if (getRace() == RACE_TROLL)
                 {
                     uint8 hairColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID);
                     switch (hairColor)
                     {
                         case 0: // Red
                         case 1:
                             return 33657;
                         case 2: // Yellow
                         case 3:
                             return 33659;
                         case 7: // Purple
                         case 10:
                             return 33656;
                         case 8: // White
                         case 9:
                         case 11:
                         case 12:
                             return 33658;
                         default: // original - Blue
                             return 33655;
                     }
                 }
                 else if (getRace() == RACE_WORGEN)
                 {
                     // Based on Skin color
                     uint8 skinColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID);
                     // Male
                     if (getGender() == GENDER_MALE)
                     {
                         switch (skinColor)
                         {
                             case 1: // Brown
                                 return 33652;
                             case 2: // Black
                             case 7:
                                 return 33651;
                             case 4: // Yellow
                                 return 33653;
                             case 3: // White
                             case 5:
                                 return 33654;
                             default: // original - Gray
                                 return 33650;
                         }
                     }
                     // Female
                     else
                     {
                         switch (skinColor)
                         {
                             case 5: // Brown
                             case 6:
                                 return 33652;
                             case 7: // Black
                             case 8:
                                 return 33651;
                             case 3: // yellow
                             case 4:
                                 return 33654;
                             case 2: // White
                                 return 33653;
                             default: // original - Gray
                                 return 33650;
                         }
                     }
                 }
                 // Based on Skin color
                 else if (getRace() == RACE_TAUREN)
                 {
                     uint8 skinColor = GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID);
                     // Male
                     if (getGender() == GENDER_MALE)
                     {
                         switch (skinColor)
                         {
                             case 0: // Dark (Black)
                             case 1:
                             case 2:
                                 return 29418;
                             case 3: // White
                             case 4:
                             case 5:
                             case 12:
                             case 13:
                             case 14:
                                 return 29419;
                             case 9: // Light Brown/Grey
                             case 10:
                             case 11:
                             case 15:
                             case 16:
                             case 17:
                                 return 29420;
                             case 18: // Completly White
                                 return 29421;
                             default: // original - Brown
                                 return 2289;
                         }
                     }
                     // Female
                     else
                     {
                         switch (skinColor)
                         {
                             case 0: // Dark (Black)
                             case 1:
                                 return 29418;
                             case 2: // White
                             case 3:
                                 return 29419;
                             case 6: // Light Brown/Grey
                             case 7:
                             case 8:
                             case 9:
                                 return 29420;
                             case 10: // Completly White
                                 return 29421;
                             default: // original - Brown
                                 return 2289;
                         }
                     }
                 }
                 else if (Player::TeamForRace(getRace()) == ALLIANCE)
                     return 2281;
                 else
                     return 2289;
             case FORM_FLIGHT:
                 if (Player::TeamForRace(getRace()) == ALLIANCE)
                     return 20857;
                 return 20872;
             case FORM_FLIGHT_EPIC:
                 if (Player::TeamForRace(getRace()) == ALLIANCE)
                     return (getRace() == RACE_WORGEN ? 37729 : 21243);
                 if (getRace() == RACE_TROLL)
                     return 37730;
                 return 21244;
             case FORM_MOONKIN:
                 switch (getRace())
                 {
                     case RACE_NIGHTELF:
                         return 15374;
                     case RACE_TAUREN:
                         return 15375;
                     case RACE_WORGEN:
                         return 37173;
                     case RACE_TROLL:
                         return 37174;
                     default:
                         break;
                 }
                 break;
             case FORM_GHOSTWOLF:
                 if (HasAura(58135)) 
                     return 27312;
             default:
                 break;
         }
     }
 
     uint32 modelid = 0;
     SpellShapeshiftFormEntry const* formEntry = sSpellShapeshiftFormStore.LookupEntry(form);
     if (formEntry && formEntry->CreatureDisplayID[0])
     {
         // Take the alliance modelid as default
         if (GetTypeId() != TYPEID_PLAYER)
             return formEntry->CreatureDisplayID[0];
         else
         {
             if (Player::TeamForRace(getRace()) == ALLIANCE)
                 modelid = formEntry->CreatureDisplayID[0];
             else
                 modelid = formEntry->CreatureDisplayID[1];
 
             // If the player is horde but there are no values for the horde modelid - take the alliance modelid
             if (!modelid && Player::TeamForRace(getRace()) == HORDE)
                 modelid = formEntry->CreatureDisplayID[0];
         }
     }
 
     return modelid;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetModelForTotem ( PlayerTotemType totemType )

 {
     switch (getRace())
     {
         case RACE_ORC:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 30758;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 30757;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 30759;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 30756;
             }
             break;
         }
         case RACE_DWARF:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 30754;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 30753;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 30755;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 30736;
             }
             break;
         }
         case RACE_TROLL:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 30762;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 30761;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 30763;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 30760;
             }
             break;
         }
         case RACE_TAUREN:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 4589;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 4588;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 4587;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 4590;
             }
             break;
         }
         case RACE_DRAENEI:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 19074;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 19073;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 19075;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 19071;
             }
             break;
         }
         case RACE_GOBLIN:
         {
             switch (totemType)
             {
                 case SUMMON_TYPE_TOTEM_FIRE:    // fire
                     return 30783;
                 case SUMMON_TYPE_TOTEM_EARTH:   // earth
                     return 30782;
                 case SUMMON_TYPE_TOTEM_WATER:   // water
                     return 30784;
                 case SUMMON_TYPE_TOTEM_AIR:     // air
                     return 30781;
             }
             break;
         }
     }
     return 0;
 }

Here is the call graph for this function:

float Unit::GetModifierValue	(	UnitMods	unitMod,
		UnitModifierType	modifierType
	)		const

 {
     if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
     {
         TC_LOG_ERROR("entities.unit", "attempt to access non-existing modifier value from UnitMods!");
         return 0.0f;
     }
 
     if (modifierType == TOTAL_PCT && m_auraModifiersGroup[unitMod][modifierType] <= 0.0f)
         return 0.0f;
 
     return m_auraModifiersGroup[unitMod][modifierType];
 }

Here is the caller graph for this function:

MotionMaster* Unit::GetMotionMaster ( )

inline

2101 { return i_motionMaster; }

Unit::i_motionMaster

MotionMaster * i_motionMaster

Definition: Unit.h:2297

const MotionMaster* Unit::GetMotionMaster ( ) const

inline

2102 { return i_motionMaster; }

Unit::i_motionMaster

MotionMaster * i_motionMaster

Definition: Unit.h:2297

MountCapabilityEntry const * Unit::GetMountCapability ( uint32 mountType ) const

 {
     if (!mountType)
         return nullptr;
 
     DB2Manager::MountTypeXCapabilitySet const* capabilities = sDB2Manager.GetMountCapabilities(mountType);
     if (!capabilities)
         return nullptr;
 
     uint32 zoneId, areaId;
     GetZoneAndAreaId(zoneId, areaId);
     uint32 ridingSkill = 5000;
     if (GetTypeId() == TYPEID_PLAYER)
         ridingSkill = ToPlayer()->GetSkillValue(SKILL_RIDING);
 
     for (MountTypeXCapabilityEntry const* mountTypeXCapability : *capabilities)
     {
         MountCapabilityEntry const* mountCapability = sMountCapabilityStore.LookupEntry(mountTypeXCapability->MountCapabilityID);
         if (!mountCapability)
             continue;
 
         if (ridingSkill < mountCapability->RequiredRidingSkill)
             continue;
 
         if (HasExtraUnitMovementFlag(MOVEMENTFLAG2_FULL_SPEED_PITCHING))
         {
             if (!(mountCapability->Flags & MOUNT_CAPABILITY_FLAG_CAN_PITCH))
                 continue;
         }
         else if (HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING))
         {
             if (!(mountCapability->Flags & MOUNT_CAPABILITY_FLAG_CAN_SWIM))
                 continue;
         }
         else if (!(mountCapability->Flags & 0x1))   // unknown flags, checked in 4.2.2 14545 client
         {
             if (!(mountCapability->Flags & 0x2))
                 continue;
         }
 
         if (mountCapability->RequiredMap != -1 && int32(GetMapId()) != mountCapability->RequiredMap)
             continue;
 
         if (mountCapability->RequiredArea && (mountCapability->RequiredArea != zoneId && mountCapability->RequiredArea != areaId))
             continue;
 
         if (mountCapability->RequiredAura && !HasAura(mountCapability->RequiredAura))
             continue;
 
         if (mountCapability->RequiredSpell && (GetTypeId() != TYPEID_PLAYER || !ToPlayer()->HasSpell(mountCapability->RequiredSpell)))
             continue;
 
         return mountCapability;
     }
 
     return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetMountID ( ) const

inline

1497 { return GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID); }

UNIT_FIELD_MOUNTDISPLAYID

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

Definition: UpdateFields.h:119

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Unit::GetMovementAnimKitId ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1507 { return _movementAnimKitId; }

Unit::_movementAnimKitId

uint16 _movementAnimKitId

Definition: Unit.h:2359

uint32 Unit::GetNativeDisplayId ( ) const

inline

2014 { return GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID); }

UNIT_FIELD_NATIVEDISPLAYID

Definition: UpdateFields.h:118

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetNegStat ( Stats stat ) const

inline

1901 { return GetFloatValue(UNIT_FIELD_NEGSTAT+stat); }

Object::GetFloatValue

float GetFloatValue(uint16 index) const

Definition: Object.cpp:312

UNIT_FIELD_NEGSTAT

Definition: UpdateFields.h:139

Here is the call graph for this function:

Unit * Unit::GetNextRandomRaidMemberOrPet ( float radius )

 {
     Player* player = NULL;
     if (GetTypeId() == TYPEID_PLAYER)
         player = ToPlayer();
     // Should we enable this also for charmed units?
     else if (GetTypeId() == TYPEID_UNIT && IsPet())
         player = GetOwner()->ToPlayer();
 
     if (!player)
         return NULL;
     Group* group = player->GetGroup();
     // When there is no group check pet presence
     if (!group)
     {
         // We are pet now, return owner
         if (player != this)
             return IsWithinDistInMap(player, radius) ? player : NULL;
         Unit* pet = GetGuardianPet();
         // No pet, no group, nothing to return
         if (!pet)
             return NULL;
         // We are owner now, return pet
         return IsWithinDistInMap(pet, radius) ? pet : NULL;
     }
 
     std::vector<Unit*> nearMembers;
     // reserve place for players and pets because resizing vector every unit push is unefficient (vector is reallocated then)
     nearMembers.reserve(group->GetMembersCount() * 2);
 
     for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
         if (Player* Target = itr->GetSource())
         {
             // IsHostileTo check duel and controlled by enemy
             if (Target != this && Target->IsAlive() && IsWithinDistInMap(Target, radius) && !IsHostileTo(Target))
                 nearMembers.push_back(Target);
 
         // Push player's pet to vector
         if (Unit* pet = Target->GetGuardianPet())
             if (pet != this && pet->IsAlive() && IsWithinDistInMap(pet, radius) && !IsHostileTo(pet))
                 nearMembers.push_back(pet);
         }
 
     if (nearMembers.empty())
         return NULL;
 
     uint32 randTarget = urand(0, nearMembers.size()-1);
     return nearMembers[randTarget];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Aura * Unit::GetOwnedAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		Aura *	except = `NULL`
	)		const

 {
     AuraMapBounds range = m_ownedAuras.equal_range(spellId);
     for (AuraMap::const_iterator itr = range.first; itr != range.second; ++itr)
     {
         if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask)
                 && (!casterGUID || itr->second->GetCasterGUID() == casterGUID)
                 && (!itemCasterGUID || itr->second->GetCastItemGUID() == itemCasterGUID)
                 && (!except || except != itr->second))
         {
             return itr->second;
         }
     }
     return NULL;
 }

Here is the caller graph for this function:

AuraMap& Unit::GetOwnedAuras ( )

inline

1779 { return m_ownedAuras; }

Unit::m_ownedAuras

AuraMap m_ownedAuras

Definition: Unit.h:2273

Here is the caller graph for this function:

AuraMap const& Unit::GetOwnedAuras ( ) const

inline

1780 { return m_ownedAuras; }

Unit::m_ownedAuras

AuraMap m_ownedAuras

Definition: Unit.h:2273

Unit * Unit::GetOwner ( ) const

 {
     ObjectGuid ownerGUID = GetOwnerGUID();
     if (!ownerGUID.IsEmpty())
         return ObjectAccessor::GetUnit(*this, ownerGUID);
 
     return NULL;
 }

Here is the call graph for this function:

ObjectGuid Unit::GetOwnerGUID ( ) const

inline

1698 { return GetGuidValue(UNIT_FIELD_SUMMONEDBY); }

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

UNIT_FIELD_SUMMONEDBY

Definition: UpdateFields.h:86

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::GetPartyMembers ( std::list< Unit * > & units )

 {
     Unit* owner = GetCharmerOrOwnerOrSelf();
     Group* group = NULL;
     if (owner->GetTypeId() == TYPEID_PLAYER)
         group = owner->ToPlayer()->GetGroup();
 
     if (group)
     {
         uint8 subgroup = owner->ToPlayer()->GetSubGroup();
 
         for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
         {
             Player* Target = itr->GetSource();
 
             // IsHostileTo check duel and controlled by enemy
             if (Target && Target->GetSubGroup() == subgroup && !IsHostileTo(Target))
             {
                 if (Target->IsAlive() && IsInMap(Target))
                     TagUnitMap.push_back(Target);
 
                 if (Guardian* pet = Target->GetGuardianPet())
                     if (pet->IsAlive() && IsInMap(Target))
                         TagUnitMap.push_back(pet);
             }
         }
     }
     else
     {
         if (owner->IsAlive() && (owner == this || IsInMap(owner)))
             TagUnitMap.push_back(owner);
         if (Guardian* pet = owner->GetGuardianPet())
             if (pet->IsAlive() && (pet == this || IsInMap(pet)))
                 TagUnitMap.push_back(pet);
     }
 }

Here is the call graph for this function:

ObjectGuid Unit::GetPetGUID ( ) const

inline

1708 { return m_SummonSlot[SUMMON_SLOT_PET]; }

Unit::m_SummonSlot

ObjectGuid m_SummonSlot[MAX_SUMMON_SLOT]

Definition: Unit.h:1929

SUMMON_SLOT_PET

#define SUMMON_SLOT_PET

Definition: Unit.h:1280

Here is the caller graph for this function:

float Unit::GetPositionZMinusOffset ( ) const

 {
     float offset = 0.0f;
     if (HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
         offset = GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
     return GetPositionZ() - offset;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetPosStat ( Stats stat ) const

inline

1900 { return GetFloatValue(UNIT_FIELD_POSSTAT+stat); }

UNIT_FIELD_POSSTAT

Definition: UpdateFields.h:138

Object::GetFloatValue

float GetFloatValue(uint16 index) const

Definition: Object.cpp:312

Here is the call graph for this function:

int32 Unit::GetPower ( Powers power ) const

 {
     uint32 powerIndex = GetPowerIndex(power);
     if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
         return 0;
 
     return GetUInt32Value(UNIT_FIELD_POWER + powerIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetPowerIndex ( uint32 powerType ) const

This is here because hunter pets are of the warrior class. With the current implementation, the core only gives them POWER_RAGE, so we enforce the class to hunter so that they effectively get focus power.

 {
     uint32 classId = getClass();
     if (ToPet() && ToPet()->getPetType() == HUNTER_PET)
         classId = CLASS_HUNTER;
 
     return sDB2Manager.GetPowerIndexByClass(powerType, classId);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetPowerPct ( Powers power ) const

inline

1449 { return GetMaxPower(power) ? 100.f * GetPower(power) / GetMaxPower(power) : 0.0f; }

Unit::GetPower

int32 GetPower(Powers power) const

Definition: Unit.cpp:11589

Unit::GetMaxPower

int32 GetMaxPower(Powers power) const

Definition: Unit.cpp:11598

Here is the caller graph for this function:

Powers Unit::getPowerType ( ) const

inline

1444 { return Powers(GetUInt32Value(UNIT_FIELD_DISPLAY_POWER)); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_DISPLAY_POWER

Definition: UpdateFields.h:97

Powers

Definition: SharedDefines.h:246

Here is the call graph for this function:

Here is the caller graph for this function:

Powers Unit::GetPowerTypeByAuraGroup ( UnitMods unitMod ) const

 {
     switch (unitMod)
     {
         case UNIT_MOD_RAGE:        return POWER_RAGE;
         case UNIT_MOD_FOCUS:       return POWER_FOCUS;
         case UNIT_MOD_ENERGY:      return POWER_ENERGY;
         case UNIT_MOD_RUNE:        return POWER_RUNES;
         case UNIT_MOD_RUNIC_POWER: return POWER_RUNIC_POWER;
         default:
         case UNIT_MOD_MANA:        return POWER_MANA;
     }
 }

Here is the caller graph for this function:

float Unit::GetPPMProcChance	(	uint32	WeaponSpeed,
		float	PPM,
		const SpellInfo *	spellProto
	)		const

 {
     // proc per minute chance calculation
     if (PPM <= 0)
         return 0.0f;
 
     // Apply chance modifer aura
     if (spellProto)
         if (Player* modOwner = GetSpellModOwner())
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_PROC_PER_MINUTE, PPM);
 
     return std::floor((WeaponSpeed * PPM) / 600.0f);   // result is chance in percents (probability = Speed_in_sec * (PPM / 60))
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::GetProcAurasTriggeredOnEvent	(	AuraApplicationList &	aurasTriggeringProc,
		AuraApplicationList *	procAuras,
		ProcEventInfo	eventInfo
	)

 {
     // use provided list of auras which can proc
     if (procAuras)
     {
         for (std::list<AuraApplication*>::iterator itr = procAuras->begin(); itr!= procAuras->end(); ++itr)
         {
             ASSERT((*itr)->GetTarget() == this);
             if (!(*itr)->GetRemoveMode())
                 if ((*itr)->GetBase()->IsProcTriggeredOnEvent(*itr, eventInfo))
                 {
                     (*itr)->GetBase()->PrepareProcToTrigger(*itr, eventInfo);
                     aurasTriggeringProc.push_back(*itr);
                 }
         }
     }
     // or generate one on our own
     else
     {
         for (AuraApplicationMap::iterator itr = GetAppliedAuras().begin(); itr!= GetAppliedAuras().end(); ++itr)
         {
             if (itr->second->GetBase()->IsProcTriggeredOnEvent(itr->second, eventInfo))
             {
                 itr->second->GetBase()->PrepareProcToTrigger(itr->second, eventInfo);
                 aurasTriggeringProc.push_back(itr->second);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Unit::getRace ( ) const

inline

1411 { return GetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_RACE); }

UNIT_FIELD_BYTES_0

Definition: UpdateFields.h:96

UNIT_BYTES_0_OFFSET_RACE

Definition: Unit.h:232

RedirectThreatInfo::GetThreatPct

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::getRaceMask ( ) const

inline

1412 { return 1 << (getRace()-1); }

Unit::getRace

uint8 getRace() const

Definition: Unit.h:1411

void Unit::GetRandomContactPoint	(	const Unit *	target,
		float &	x,
		float &	y,
		float &	z,
		float	distance2dMin,
		float	distance2dMax
	)		const

 {
     float combat_reach = GetCombatReach();
     if (combat_reach < 0.1f) // sometimes bugged for players
         combat_reach = DEFAULT_COMBAT_REACH;
 
     uint32 attacker_number = uint32(getAttackers().size());
     if (attacker_number > 0)
         --attacker_number;
     GetNearPoint(obj, x, y, z, obj->GetCombatReach(), distance2dMin+(distance2dMax-distance2dMin) * (float)rand_norm(),
         GetAngle(obj) + (attacker_number ? (static_cast<float>(M_PI/2) - static_cast<float>(M_PI) * (float)rand_norm()) * float(attacker_number) / combat_reach * 0.3f : 0));
 }

Here is the call graph for this function:

ReputationRank Unit::GetReactionTo ( Unit const * target ) const

 {
     // always friendly to self
     if (this == target)
         return REP_FRIENDLY;
 
     // always friendly to charmer or owner
     if (GetCharmerOrOwnerOrSelf() == target->GetCharmerOrOwnerOrSelf())
         return REP_FRIENDLY;
 
     Player const* selfPlayerOwner = GetAffectingPlayer();
     Player const* targetPlayerOwner = target->GetAffectingPlayer();
 
     // check forced reputation to support SPELL_AURA_FORCE_REACTION
     if (selfPlayerOwner)
     {
         if (FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry())
             if (ReputationRank const* repRank = selfPlayerOwner->GetReputationMgr().GetForcedRankIfAny(targetFactionTemplateEntry))
                 return *repRank;
     }
     else if (targetPlayerOwner)
     {
         if (FactionTemplateEntry const* selfFactionTemplateEntry = GetFactionTemplateEntry())
             if (ReputationRank const* repRank = targetPlayerOwner->GetReputationMgr().GetForcedRankIfAny(selfFactionTemplateEntry))
                 return *repRank;
     }
 
     if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE))
     {
         if (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE))
         {
             if (selfPlayerOwner && targetPlayerOwner)
             {
                 // always friendly to other unit controlled by player, or to the player himself
                 if (selfPlayerOwner == targetPlayerOwner)
                     return REP_FRIENDLY;
 
                 // duel - always hostile to opponent
                 if (selfPlayerOwner->duel && selfPlayerOwner->duel->opponent == targetPlayerOwner && selfPlayerOwner->duel->startTime != 0)
                     return REP_HOSTILE;
 
                 // same group - checks dependant only on our faction - skip FFA_PVP for example
                 if (selfPlayerOwner->IsInRaidWith(targetPlayerOwner))
                     return REP_FRIENDLY; // return true to allow config option AllowTwoSide.Interaction.Group to work
                     // however client seems to allow mixed group parties, because in 13850 client it works like:
                     // return GetFactionReactionTo(GetFactionTemplateEntry(), target);
             }
 
             // check FFA_PVP
             if (GetByteValue(UNIT_FIELD_BYTES_2, 1) & UNIT_BYTE2_FLAG_FFA_PVP
                 && target->GetByteValue(UNIT_FIELD_BYTES_2, 1) & UNIT_BYTE2_FLAG_FFA_PVP)
                 return REP_HOSTILE;
 
             if (selfPlayerOwner)
             {
                 if (FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry())
                 {
                     if (!selfPlayerOwner->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_IGNORE_REPUTATION))
                     {
                         if (FactionEntry const* targetFactionEntry = sFactionStore.LookupEntry(targetFactionTemplateEntry->Faction))
                         {
                             if (targetFactionEntry->CanHaveReputation())
                             {
                                 // check contested flags
                                 if (targetFactionTemplateEntry->Flags & FACTION_TEMPLATE_FLAG_CONTESTED_GUARD
                                     && selfPlayerOwner->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP))
                                     return REP_HOSTILE;
 
                                 // if faction has reputation, hostile state depends only from AtWar state
                                 if (selfPlayerOwner->GetReputationMgr().IsAtWar(targetFactionEntry))
                                     return REP_HOSTILE;
                                 return REP_FRIENDLY;
                             }
                         }
                     }
                 }
             }
         }
     }
     // do checks dependant only on our faction
     return GetFactionReactionTo(GetFactionTemplateEntry(), target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetRedirectThreatPercent ( ) const

inline

2157 { return _redirectThreadInfo.GetThreatPct(); }

uint32 GetThreatPct() const

Definition: Unit.h:1084

Unit::_redirectThreadInfo

RedirectThreatInfo _redirectThreadInfo

Definition: Unit.h:2350

Here is the caller graph for this function:

Unit * Unit::GetRedirectThreatTarget ( )

 {
     return !_redirectThreadInfo.GetTargetGUID().IsEmpty() ? ObjectAccessor::GetUnit(*this, _redirectThreadInfo.GetTargetGUID()) : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetRemainingPeriodicAmount	(	ObjectGuid	caster,
		uint32	spellId,
		AuraType	auraType,
		uint8	effectIndex = `0`
	)		const

 {
     uint32 amount = 0;
     AuraEffectList const& periodicAuras = GetAuraEffectsByType(auraType);
     for (AuraEffectList::const_iterator i = periodicAuras.begin(); i != periodicAuras.end(); ++i)
     {
         if ((*i)->GetCasterGUID() != caster || (*i)->GetId() != spellId || (*i)->GetEffIndex() != effectIndex || !(*i)->GetTotalTicks())
             continue;
         amount += uint32(((*i)->GetAmount() * std::max<int32>((*i)->GetTotalTicks() - int32((*i)->GetTickNumber()), 0)) / (*i)->GetTotalTicks());
         break;
     }
 
     return amount;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetResistance ( SpellSchools school ) const

inline

1422 { return GetUInt32Value(UNIT_FIELD_RESISTANCES+school); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_RESISTANCES

Definition: UpdateFields.h:140

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetResistance ( SpellSchoolMask mask ) const

 {
     int32 resist = -1;
     for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
         if (mask & (1 << i) && (resist < 0 || resist > int32(GetResistance(SpellSchools(i)))))
             resist = int32(GetResistance(SpellSchools(i)));
 
     // resist value will never be negative here
     return uint32(resist);
 }

Here is the call graph for this function:

float Unit::GetResistanceBuffMods	(	SpellSchools	school,
		bool	positive
	)		const

 {
     return GetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school);
 }

Here is the call graph for this function:

uint32 Unit::GetSchoolImmunityMask ( ) const

 {
     uint32 mask = 0;
     SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_SCHOOL];
     for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
         mask |= itr->type;
 
     return mask;
 }

ShapeshiftForm Unit::GetShapeshiftForm ( ) const

inline

1932 { return ShapeshiftForm(GetByteValue(UNIT_FIELD_BYTES_2, 3)); }

ShapeshiftForm

Definition: Unit.h:260

Definition: UpdateFields.h:146

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

Here is the caller graph for this function:

SharedVisionList const& Unit::GetSharedVisionList ( )

inline

1754 { return m_sharedVision; }

Unit::m_sharedVision

SharedVisionList m_sharedVision

Definition: Unit.h:2293

Here is the caller graph for this function:

SheathState Unit::GetSheath ( ) const

inline

1462 { return SheathState(GetByteValue(UNIT_FIELD_BYTES_2, 0)); }

Definition: UpdateFields.h:146

SheathState

Definition: Unit.h:296

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

AuraList& Unit::GetSingleCastAuras ( )

inline

1833 { return m_scAuras; }

Unit::m_scAuras

AuraList m_scAuras

Definition: Unit.h:2280

Here is the caller graph for this function:

AuraList const& Unit::GetSingleCastAuras ( ) const

inline

1834 { return m_scAuras; }

Unit::m_scAuras

AuraList m_scAuras

Definition: Unit.h:2280

float Unit::GetSpeed ( UnitMoveType mtype ) const

 {
     return m_speed_rate[mtype]*(IsControlledByPlayer() ? playerBaseMoveSpeed[mtype] : baseMoveSpeed[mtype]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetSpeedRate ( UnitMoveType mtype ) const

inline

2087 { return m_speed_rate[mtype]; }

Unit::m_speed_rate

float m_speed_rate[MAX_MOVE_TYPE]

Definition: Unit.h:2290

Here is the caller graph for this function:

SpellHistory* Unit::GetSpellHistory ( )

inline

1926 { return _spellHistory; }

Unit::_spellHistory

SpellHistory * _spellHistory

Definition: Unit.h:2364

Here is the caller graph for this function:

SpellHistory const* Unit::GetSpellHistory ( ) const

inline

1927 { return _spellHistory; }

Unit::_spellHistory

SpellHistory * _spellHistory

Definition: Unit.h:2364

float Unit::GetSpellMaxRangeForTarget	(	Unit const *	target,
		SpellInfo const *	spellInfo
	)		const

 {
     if (!spellInfo->RangeEntry)
         return 0;
     if (spellInfo->RangeEntry->MaxRangeFriend == spellInfo->RangeEntry->MaxRangeHostile)
         return spellInfo->GetMaxRange();
     if (target == NULL)
         return spellInfo->GetMaxRange(true);
     return spellInfo->GetMaxRange(!IsHostileTo(target));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetSpellMinRangeForTarget	(	Unit const *	target,
		SpellInfo const *	spellInfo
	)		const

 {
     if (!spellInfo->RangeEntry)
         return 0;
     if (spellInfo->RangeEntry->MinRangeFriend == spellInfo->RangeEntry->MinRangeHostile)
         return spellInfo->GetMinRange();
     return spellInfo->GetMinRange(!IsHostileTo(target));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Player * Unit::GetSpellModOwner ( ) const

 {
     if (Player* player = const_cast<Unit*>(this)->ToPlayer())
         return player;
 
     if (IsPet() || IsTotem())
     {
         if (Unit* owner = GetOwner())
             if (Player* player = owner->ToPlayer())
                 return player;
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellSchools Unit::GetSpellSchoolByAuraGroup ( UnitMods unitMod ) const

 {
     SpellSchools school = SPELL_SCHOOL_NORMAL;
 
     switch (unitMod)
     {
         case UNIT_MOD_RESISTANCE_HOLY:     school = SPELL_SCHOOL_HOLY;          break;
         case UNIT_MOD_RESISTANCE_FIRE:     school = SPELL_SCHOOL_FIRE;          break;
         case UNIT_MOD_RESISTANCE_NATURE:   school = SPELL_SCHOOL_NATURE;        break;
         case UNIT_MOD_RESISTANCE_FROST:    school = SPELL_SCHOOL_FROST;         break;
         case UNIT_MOD_RESISTANCE_SHADOW:   school = SPELL_SCHOOL_SHADOW;        break;
         case UNIT_MOD_RESISTANCE_ARCANE:   school = SPELL_SCHOOL_ARCANE;        break;
 
         default:
             break;
     }
 
     return school;
 }

Here is the caller graph for this function:

UnitStandStateType Unit::GetStandState ( ) const

inline

1488 { return UnitStandStateType(GetByteValue(UNIT_FIELD_BYTES_1, 0)); }

UnitStandStateType

Definition: Unit.h:205

UNIT_FIELD_BYTES_1

Definition: UpdateFields.h:124

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetStat ( Stats stat ) const

inline

1417 { return float(GetUInt32Value(UNIT_FIELD_STAT+stat)); }

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_FIELD_STAT

Definition: UpdateFields.h:137

Here is the call graph for this function:

Here is the caller graph for this function:

Stats Unit::GetStatByAuraGroup ( UnitMods unitMod ) const

 {
     Stats stat = STAT_STRENGTH;
 
     switch (unitMod)
     {
         case UNIT_MOD_STAT_STRENGTH:    stat = STAT_STRENGTH;      break;
         case UNIT_MOD_STAT_AGILITY:     stat = STAT_AGILITY;       break;
         case UNIT_MOD_STAT_STAMINA:     stat = STAT_STAMINA;       break;
         case UNIT_MOD_STAT_INTELLECT:   stat = STAT_INTELLECT;     break;
         case UNIT_MOD_STAT_SPIRIT:      stat = STAT_SPIRIT;        break;
 
         default:
             break;
     }
 
     return stat;
 }

Here is the caller graph for this function:

ObjectGuid Unit::GetTarget ( ) const

inline

2209 { return GetGuidValue(UNIT_FIELD_TARGET); }

UNIT_FIELD_TARGET

Definition: UpdateFields.h:89

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the call graph for this function:

Here is the caller graph for this function:

ThreatManager& Unit::getThreatManager ( )

inline

1998 { return m_ThreatManager; }

Unit::m_ThreatManager

ThreatManager m_ThreatManager

Definition: Unit.h:2302

float Unit::GetTotalAttackPowerValue ( WeaponAttackType attType ) const

 {
     if (attType == RANGED_ATTACK)
     {
         int32 ap = GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER);
         if (ap < 0)
             return 0.0f;
         return ap * (1.0f + GetFloatValue(UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER));
     }
     else
     {
         int32 ap = GetInt32Value(UNIT_FIELD_ATTACK_POWER);
         if (ap < 0)
             return 0.0f;
         return ap * (1.0f + GetFloatValue(UNIT_FIELD_ATTACK_POWER_MULTIPLIER));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetTotalAuraModifier ( AuraType auratype ) const

 {
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     if (mTotalAuraList.empty())
         return 0;
 
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     int32 modifier = 0;
 
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
             modifier += (*i)->GetAmount();
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         modifier += itr->second;
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetTotalAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->IsAffectingSpell(affectedSpell))
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 modifier += (*i)->GetAmount();
     }
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         modifier += itr->second;
 
     return modifier;
 }

Here is the call graph for this function:

int32 Unit::GetTotalAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
 
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if ((*i)->GetMiscValue() & miscMask)
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 modifier += (*i)->GetAmount();
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         modifier += itr->second;
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::GetTotalAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     int32 modifier = 0;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetMiscValue() == miscValue)
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 modifier += (*i)->GetAmount();
     }
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         modifier += itr->second;
 
     return modifier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetTotalAuraModValue ( UnitMods unitMod ) const

 {
     if (unitMod >= UNIT_MOD_END)
     {
         TC_LOG_ERROR("entities.unit", "attempt to access non-existing UnitMods in GetTotalAuraModValue()!");
         return 0.0f;
     }
 
     if (m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
         return 0.0f;
 
     float value = CalculatePct(m_auraModifiersGroup[unitMod][BASE_VALUE], std::max(m_auraModifiersGroup[unitMod][BASE_PCT_EXCLUDE_CREATE], -100.0f));
     value *= m_auraModifiersGroup[unitMod][BASE_PCT];
     value += m_auraModifiersGroup[unitMod][TOTAL_VALUE];
     value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
 
     return value;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetTotalAuraMultiplier ( AuraType auratype ) const

 {
     float multiplier = 1.0f;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         AddPct(multiplier, (*i)->GetAmount());
 
     return multiplier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetTotalAuraMultiplierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     float multiplier = 1.0f;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->IsAffectingSpell(affectedSpell))
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 AddPct(multiplier, (*i)->GetAmount());
     }
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         AddPct(multiplier, itr->second);
 
     return multiplier;
 }

Here is the call graph for this function:

float Unit::GetTotalAuraMultiplierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     float multiplier = 1.0f;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if (((*i)->GetMiscValue() & miscMask))
         {
             // Check if the Aura Effect has a the Same Effect Stack Rule and if so, use the highest amount of that SpellGroup
             // If the Aura Effect does not have this Stack Rule, it returns false so we can add to the multiplier as usual
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 AddPct(multiplier, (*i)->GetAmount());
         }
     }
     // Add the highest of the Same Effect Stack Rule SpellGroups to the multiplier
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         AddPct(multiplier, itr->second);
 
     return multiplier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetTotalAuraMultiplierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

 {
     std::map<SpellGroup, int32> SameEffectSpellGroup;
     float multiplier = 1.0f;
 
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
     {
         if ((*i)->GetMiscValue() == miscValue)
             if (!sSpellMgr->AddSameEffectStackRuleSpellGroups((*i)->GetSpellInfo(), (*i)->GetAmount(), SameEffectSpellGroup))
                 AddPct(multiplier, (*i)->GetAmount());
     }
 
     for (std::map<SpellGroup, int32>::const_iterator itr = SameEffectSpellGroup.begin(); itr != SameEffectSpellGroup.end(); ++itr)
         AddPct(multiplier, itr->second);
 
     return multiplier;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetTotalStatValue ( Stats stat ) const

 {
     UnitMods unitMod = UnitMods(UNIT_MOD_STAT_START + stat);
 
     if (m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
         return 0.0f;
 
     // value = ((base_value * base_pct) + total_value) * total_pct
     float value = CalculatePct(m_auraModifiersGroup[unitMod][BASE_VALUE], std::max(m_auraModifiersGroup[unitMod][BASE_PCT_EXCLUDE_CREATE], -100.0f));
     value += GetCreateStat(stat);
     value *= m_auraModifiersGroup[unitMod][BASE_PCT];
     value += m_auraModifiersGroup[unitMod][TOTAL_VALUE];
     value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
 
     return value;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::getTransForm ( ) const

inline

2018 { return m_transform;}

Unit::m_transform

uint32 m_transform

Definition: Unit.h:2269

Here is the caller graph for this function:

ObjectGuid Unit::GetTransGUID ( ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (GetVehicle())
         return GetVehicleBase()->GetGUID();
     if (GetTransport())
         return GetTransport()->GetGUID();
 
     return ObjectGuid::Empty;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetUnitBlockChanceAgainst ( Unit const * attacker ) const

 {
     if (IsNonMeleeSpellCast(false) || HasUnitState(UNIT_STATE_CONTROLLED))
         return 0.0f;
 
     if (Player const* player = ToPlayer())
     {
         if (player->CanBlock())
         {
             Item* tmpitem = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
             if (tmpitem && !tmpitem->IsBroken() && tmpitem->GetTemplate()->GetInventoryType() == INVTYPE_SHIELD)
                 return GetFloatValue(PLAYER_BLOCK_PERCENTAGE);
         }
         // is player but has no block ability or no not broken shield equipped
         return 0.0f;
     }
     else
     {
         if (IsTotem())
             return 0.0f;
         else
         {
             float block = 3.0f;
             int32 levelDiff = getLevelForTarget(attacker) - attacker->getLevelForTarget(this);
             if (levelDiff > 0)
                 block += 1.5f * levelDiff;
             block += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT);
             return block > 0.0f ? block : 0.0f;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetUnitCriticalChance	(	WeaponAttackType	attackType,
		const Unit *	victim
	)		const

 {
     float crit;
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         switch (attackType)
         {
             case BASE_ATTACK:
                 crit = GetFloatValue(PLAYER_CRIT_PERCENTAGE);
                 break;
             case OFF_ATTACK:
                 crit = GetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE);
                 break;
             case RANGED_ATTACK:
                 crit = GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
                 break;
                 // Just for good manner
             default:
                 crit = 0.0f;
                 break;
         }
     }
     else
     {
         crit = 5.0f;
         crit += GetTotalAuraModifier(SPELL_AURA_MOD_WEAPON_CRIT_PERCENT);
         crit += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_PCT);
     }
 
     // flat aura mods
     if (attackType == RANGED_ATTACK)
         crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
     else
         crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
 
     crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
 
     if (crit < 0.0f)
         crit = 0.0f;
     return crit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetUnitDodgeChanceAgainst ( Unit const * attacker ) const

 {
     if (IsNonMeleeSpellCast(false) || HasUnitState(UNIT_STATE_CONTROLLED))
         return 0.0f;
 
     if (GetTypeId() == TYPEID_PLAYER)
         return GetFloatValue(PLAYER_DODGE_PERCENTAGE);
     else
     {
         if (IsTotem())
             return 0.0f;
         else
         {
             float dodge = 3.0f + GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT);
             int32 levelDiff = getLevelForTarget(attacker) - attacker->getLevelForTarget(this);
             if (levelDiff > 0)
                 dodge += 1.5f * levelDiff;
             return dodge > 0.0f ? dodge : 0.0f;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetUnitMissChance ( WeaponAttackType attType ) const

 {
     float miss_chance = 5.00f;
 
     if (attType == RANGED_ATTACK)
         miss_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
     else
         miss_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
 
     return miss_chance;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::GetUnitMovementFlags ( ) const

inline

2110 { return m_movementInfo.GetMovementFlags(); }

MovementInfo::GetMovementFlags

MovementInfo m_movementInfo

Definition: Object.h:612

uint32 GetMovementFlags() const

Definition: Object.h:326

Here is the caller graph for this function:

float Unit::GetUnitParryChanceAgainst ( Unit const * attacker ) const

 {
     if (IsNonMeleeSpellCast(false) || HasUnitState(UNIT_STATE_CONTROLLED))
         return 0.0f;
 
     float chance = 0.0f;
 
     if (Player const* player = ToPlayer())
     {
         if (player->CanParry())
         {
             Item* tmpitem = player->GetWeaponForAttack(BASE_ATTACK, true);
             if (!tmpitem)
                 tmpitem = player->GetWeaponForAttack(OFF_ATTACK, true);
 
             if (tmpitem)
                 chance = GetFloatValue(PLAYER_PARRY_PERCENTAGE);
         }
     }
     else if (GetTypeId() == TYPEID_UNIT)
     {
         chance = 6.0f;
         int32 levelDiff = getLevelForTarget(attacker) - attacker->getLevelForTarget(this);
         if (levelDiff > 0)
             chance += 1.5f * levelDiff;
         chance += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT);
     }
 
     return chance > 0.0f ? chance : 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetUnitSpellCriticalChance	(	Unit *	victim,
		SpellInfo const *	spellProto,
		SpellSchoolMask	schoolMask,
		WeaponAttackType	attackType = `BASE_ATTACK`
	)		const

Mobs can't crit with spells. Player Totems can Fire Elemental (from totem) can too - but this part is a hack and needs more research

Intentional fallback. Calculate critical strike chance for both Ranged and Melee spells

 {
     if (GetGUID().IsCreatureOrVehicle() && !(IsTotem() && GetOwnerGUID().IsPlayer()) && GetEntry() != 15438)
         return 0.0f;
 
     // not critting spell
     if ((spellProto->HasAttribute(SPELL_ATTR2_CANT_CRIT)))
         return 0.0f;
 
     float crit_chance = 0.0f;
     switch (spellProto->DmgClass)
     {
         case SPELL_DAMAGE_CLASS_NONE:
             // We need more spells to find a general way (if there is any)
             switch (spellProto->Id)
             {
                 case 379:   // Earth Shield
                 case 33778: // Lifebloom Final Bloom
                 case 64844: // Divine Hymn
                 case 71607: // Item - Bauble of True Blood 10m
                 case 71646: // Item - Bauble of True Blood 25m
                     break;
                 default:
                     return 0.0f;
             }
         // Do not add a break here, case fallthrough is intentional! Adding a break will make above spells unable to crit.
         case SPELL_DAMAGE_CLASS_MAGIC:
         {
             if (schoolMask & SPELL_SCHOOL_MASK_NORMAL)
                 crit_chance = 0.0f;
             // For other schools
             else if (GetTypeId() == TYPEID_PLAYER)
                 crit_chance = GetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1 + GetFirstSchoolInMask(schoolMask));
             else
             {
                 crit_chance = (float)m_baseSpellCritChance;
                 crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
             }
             // taken
             if (victim)
             {
                 if (!spellProto->IsPositive())
                 {
                     // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
                     crit_chance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
                     // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
                     crit_chance += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
                 }
                 // scripted (increase crit chance ... against ... target by x%
                 AuraEffectList const& mOverrideClassScript = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
                 for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
                 {
                     if (!((*i)->IsAffectingSpell(spellProto)))
                         continue;
 
                     switch ((*i)->GetMiscValue())
                     {
                         case 911: // Shatter
                             if (victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
                             {
                                 crit_chance *= 1.5f;
                                 if (AuraEffect const* eff = (*i)->GetBase()->GetEffect(EFFECT_1))
                                     crit_chance += eff->GetAmount();
                             }
                             break;
                         case 7917: // Glyph of Shadowburn
                             if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                                 crit_chance+=(*i)->GetAmount();
                             break;
                         case 7997: // Renewed Hope
                         case 7998:
                             if (victim->HasAura(6788))
                                 crit_chance+=(*i)->GetAmount();
                             break;
                         default:
                             break;
                     }
                 }
                 // Custom crit by class
                 switch (spellProto->SpellFamilyName)
                 {
                     case SPELLFAMILY_MAGE:
                         // Glyph of Fire Blast
                         if (spellProto->SpellFamilyFlags[0] == 0x2 && spellProto->SpellIconID == 12)
                             if (victim->HasAuraWithMechanic((1 << MECHANIC_STUN) | (1 << MECHANIC_KNOCKOUT)))
                                 if (AuraEffect const* aurEff = GetAuraEffect(56369, EFFECT_0))
                                     crit_chance += aurEff->GetAmount();
                         break;
                     case SPELLFAMILY_DRUID:
                         // Improved Faerie Fire
                         if (victim->HasAuraState(AURA_STATE_FAERIE_FIRE))
                             if (AuraEffect const* aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 109, 0))
                                 crit_chance += aurEff->GetAmount();
 
                         // cumulative effect - don't break
 
                         // Starfire
                         if (spellProto->SpellFamilyFlags[0] & 0x4 && spellProto->SpellIconID == 1485)
                         {
                             // Improved Insect Swarm
                             if (AuraEffect const* aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 1771, 0))
                                 if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, flag128(0x00000002, 0, 0)))
                                     crit_chance += aurEff->GetAmount();
                            break;
                         }
                         break;
                     case SPELLFAMILY_ROGUE:
                         // Shiv-applied poisons can't crit
                         if (FindCurrentSpellBySpellId(5938))
                             crit_chance = 0.0f;
                         break;
                     case SPELLFAMILY_PALADIN:
                         // Flash of light
                         if (spellProto->SpellFamilyFlags[0] & 0x40000000)
                         {
                             // Sacred Shield
                             if (AuraEffect const* aura = victim->GetAuraEffect(58597, 1, GetGUID()))
                                 crit_chance += aura->GetAmount();
                             break;
                         }
                         // Exorcism
                         else if (spellProto->GetCategory() == 19)
                         {
                             if (victim->GetCreatureTypeMask() & CREATURE_TYPEMASK_DEMON_OR_UNDEAD)
                                 return 100.0f;
                             break;
                         }
                         break;
                     case SPELLFAMILY_SHAMAN:
                         // Lava Burst
                         if (spellProto->SpellFamilyFlags[1] & 0x00001000)
                         {
                             if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, flag128(0x10000000, 0, 0), GetGUID()))
                                 if (victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE) > -100)
                                     return 100.0f;
                             break;
                         }
                         break;
                 }
             }
             break;
         }
         case SPELL_DAMAGE_CLASS_MELEE:
             if (victim)
             {
                 // Custom crit by class
                 switch (spellProto->SpellFamilyName)
                 {
                     case SPELLFAMILY_DRUID:
                         // Rend and Tear - bonus crit chance for Ferocious Bite on bleeding targets
                         if (spellProto->SpellFamilyFlags[0] & 0x00800000
                             && spellProto->SpellIconID == 1680
                             && victim->HasAuraState(AURA_STATE_BLEEDING))
                         {
                             if (AuraEffect const* rendAndTear = GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 1))
                                 crit_chance += rendAndTear->GetAmount();
                             break;
                         }
                         break;
                 }
             }
         case SPELL_DAMAGE_CLASS_RANGED:
         {
             if (victim)
             {
                 crit_chance += GetUnitCriticalChance(attackType, victim);
                 crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
             }
             break;
         }
         default:
             return 0.0f;
     }
     // percent done
     // only players use intelligence for critical chance computations
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRITICAL_CHANCE, crit_chance);
 
     AuraEffectList const& critAuras = victim->GetAuraEffectsByType(SPELL_AURA_MOD_CRIT_CHANCE_FOR_CASTER);
     for (AuraEffectList::const_iterator i = critAuras.begin(); i != critAuras.end(); ++i)
         if ((*i)->GetCasterGUID() == GetGUID() && (*i)->IsAffectingSpell(spellProto))
             crit_chance += (*i)->GetAmount();
 
     return crit_chance > 0.0f ? crit_chance : 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vehicle* Unit::GetVehicle ( ) const

inline

2166 { return m_vehicle; }

Unit::m_vehicle

Vehicle * m_vehicle

Definition: Unit.h:2304

Here is the caller graph for this function:

Unit * Unit::GetVehicleBase ( ) const

 {
     return m_vehicle ? m_vehicle->GetBase() : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Creature * Unit::GetVehicleCreatureBase ( ) const

 {
     if (Unit* veh = GetVehicleBase())
         if (Creature* c = veh->ToCreature())
             return c;
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vehicle* Unit::GetVehicleKit ( ) const

inline

2165 { return m_vehicleKit; }

Unit::m_vehicleKit

Vehicle * m_vehicleKit

Definition: Unit.h:2305

Unit* Unit::GetVictim ( ) const

inline

1379 { return m_attacking; }

Unit::m_attacking

Unit * m_attacking

Definition: Unit.h:2256

uint32 Unit::GetVirtualItemId ( uint32 slot ) const

 {
     if (slot >= MAX_EQUIPMENT_ITEMS)
         return 0;
 
     return GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + slot * 2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraApplication * Unit::GetVisibleAura ( uint8 slot ) const

 {
     VisibleAuraMap::const_iterator itr = m_visibleAuras.find(slot);
     if (itr != m_visibleAuras.end())
         return itr->second;
     return 0;
 }

Here is the caller graph for this function:

VisibleAuraMap const* Unit::GetVisibleAuras ( )

inline

2003 { return &m_visibleAuras; }

Unit::m_visibleAuras

VisibleAuraMap m_visibleAuras

Definition: Unit.h:2288

Here is the caller graph for this function:

float Unit::GetWeaponDamageRange	(	WeaponAttackType	attType,
		WeaponDamageRange	type
	)		const

 {
     if (attType == OFF_ATTACK && !haveOffhandWeapon())
         return 0.0f;
 
     return m_weaponDamage[attType][type];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::GetWeaponProcChance ( ) const

 {
     // normalized proc chance for weapon attack speed
     // (odd formula...)
     if (isAttackReady(BASE_ATTACK))
         return (GetAttackTime(BASE_ATTACK) * 1.8f / 1000.0f);
     else if (haveOffhandWeapon() && isAttackReady(OFF_ATTACK))
         return (GetAttackTime(OFF_ATTACK) * 1.6f / 1000.0f);
     return 0;
 }

Here is the call graph for this function:

bool Unit::HandleAuraProc	(	Unit *	victim,
		uint32	damage,
		Aura *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown,
		bool *	handled
	)

private

Todo:: move those to spell scripts

Possible hack alert Don't drop charges on proc, they will be dropped on SpellMod removal Before this change, it was dropping two charges per attack, one in ProcDamageAndSpellFor, and one in RemoveSpellMods. The reason of this behaviour is Recklessness having three auras, 2 of them can not proc (isTriggeredAura array) but the other one can, making the whole spell proc.

 {
     SpellInfo const* dummySpell = triggeredByAura->GetSpellInfo();
 
     switch (dummySpell->SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
             switch (dummySpell->Id)
             {
                 // Nevermelting Ice Crystal
                 case 71564:
                     RemoveAuraFromStack(71564);
                     *handled = true;
                     break;
                 // Gaseous Bloat
                 case 70672:
                 case 72455:
                 case 72832:
                 case 72833:
                 {
                     *handled = true;
                     uint32 stack = triggeredByAura->GetStackAmount();
                     int32 const mod = (GetMap()->GetSpawnMode() & 1) ? 1500 : 1250;
                     int32 dmg = 0;
                     for (uint8 i = 1; i <= stack; ++i)
                         dmg += mod * i;
                     if (Unit* caster = triggeredByAura->GetCaster())
                         caster->CastCustomSpell(70701, SPELLVALUE_BASE_POINT0, dmg);
                     break;
                 }
                 // Ball of Flames Proc
                 case 71756:
                 case 72782:
                 case 72783:
                 case 72784:
                     RemoveAuraFromStack(dummySpell->Id);
                     *handled = true;
                     break;
                 // Discerning Eye of the Beast
                 case 59915:
                 {
                     CastSpell(this, 59914, true);   // 59914 already has correct basepoints in DBC, no need for custom bp
                     *handled = true;
                     break;
                 }
                 // Swift Hand of Justice
                 case 59906:
                 {
                     if (SpellEffectInfo const* effect = triggeredByAura->GetSpellEffectInfo(EFFECT_0))
                     {
                         int32 bp0 = CalculatePct(GetMaxHealth(), effect->CalcValue());
                         CastCustomSpell(this, 59913, &bp0, NULL, NULL, true);
                         *handled = true;
                     }
                     break;
                 }
             }
 
             break;
         case SPELLFAMILY_PALADIN:
         {
             // Judgements of the Just
             if (dummySpell->SpellIconID == 3015)
             {
                 *handled = true;
                 CastSpell(victim, 68055, true);
                 return true;
             }
             break;
         }
         case SPELLFAMILY_MAGE:
         {
             break;
         }
         case SPELLFAMILY_DEATHKNIGHT:
         {
             // Blood of the North
             // Reaping
             // Death Rune Mastery
             if (dummySpell->SpellIconID == 3041 || (dummySpell->SpellIconID == 22 && dummySpell->Id != 62459) || dummySpell->SpellIconID == 2622)
             {
                 *handled = true;
                 // Convert recently used Blood Rune to Death Rune
                 if (Player* player = ToPlayer())
                 {
                     if (player->getClass() != CLASS_DEATH_KNIGHT)
                         return false;
 
                     RuneType rune = ToPlayer()->GetLastUsedRune();
                     // can't proc from death rune use
                     if (rune == RUNE_DEATH)
                         return false;
                     AuraEffect* aurEff = triggeredByAura->GetEffect(EFFECT_0);
                     if (!aurEff)
                         return false;
 
                     // Reset amplitude - set death rune remove timer to 30s
                     aurEff->ResetPeriodic(true);
                     uint32 runesLeft;
 
                     if (dummySpell->SpellIconID == 2622)
                         runesLeft = 2;
                     else
                         runesLeft = 1;
 
                     for (uint8 i = 0; i < MAX_RUNES && runesLeft; ++i)
                     {
                         if (dummySpell->SpellIconID == 2622)
                         {
                             if (player->GetCurrentRune(i) == RUNE_DEATH ||
                                 player->GetBaseRune(i) == RUNE_BLOOD)
                                 continue;
                         }
                         else
                         {
                             if (player->GetCurrentRune(i) == RUNE_DEATH ||
                                 player->GetBaseRune(i) != RUNE_BLOOD)
                                 continue;
                         }
                         if (player->GetRuneCooldown(i) != (player->GetRuneBaseCooldown(i) - player->GetLastRuneGraceTimer(i)))
                             continue;
 
                         --runesLeft;
                         // Mark aura as used
                         player->AddRuneByAuraEffect(i, RUNE_DEATH, aurEff);
                     }
                     return true;
                 }
                 return false;
             }
 
             switch (dummySpell->Id)
             {
                 // Bone Shield cooldown
                 case 49222:
                 {
                     *handled = true;
                     if (cooldown && GetTypeId() == TYPEID_PLAYER)
                     {
                         if (GetSpellHistory()->HasCooldown(100000))
                             return false;
 
                         GetSpellHistory()->AddCooldown(100000, 0, std::chrono::seconds(cooldown));
                     }
                     return true;
                 }
             }
             break;
         }
         case SPELLFAMILY_WARRIOR:
         {
             switch (dummySpell->Id)
             {
                 // Item - Warrior T10 Protection 4P Bonus
                 case 70844:
                 {
                     if (SpellEffectInfo const* effect = triggeredByAura->GetSpellEffectInfo(EFFECT_1))
                     {
                         int32 basepoints0 = CalculatePct(GetMaxHealth(), effect->CalcValue());
                         CastCustomSpell(this, 70845, &basepoints0, NULL, NULL, true);
                     }
                     break;
                 }
                 // Recklessness
                 case 1719:
                 {
                     *handled = true;
                     break;
                 }
                 default:
                     break;
             }
             break;
         }
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HandleAuraRaidProcFromCharge ( AuraEffect * triggeredByAura )

private

 {
     // aura can be deleted at casts
     SpellInfo const* spellProto = triggeredByAura->GetSpellInfo();
 
     uint32 damageSpellId;
     switch (spellProto->Id)
     {
         case 57949:            // shiver
             damageSpellId = 57952;
             //animationSpellId = 57951; dummy effects for jump spell have unknown use (see also 41637)
             break;
         case 59978:            // shiver
             damageSpellId = 59979;
             break;
         case 43593:            // Cold Stare
             damageSpellId = 43594;
             break;
         default:
             TC_LOG_ERROR("entities.unit", "Unit::HandleAuraRaidProcFromCharge, received unhandled spell: %u", spellProto->Id);
             return false;
     }
 
     ObjectGuid caster_guid = triggeredByAura->GetCasterGUID();
 
     // jumps
     int32 jumps = triggeredByAura->GetBase()->GetCharges()-1;
 
     // current aura expire
     triggeredByAura->GetBase()->SetCharges(1);             // will removed at next charges decrease
 
     // next target selection
     if (jumps > 0)
     {
         if (Unit* caster = triggeredByAura->GetCaster())
         {
             SpellEffectInfo const* effect = triggeredByAura->GetSpellEffectInfo();
             float radius = effect->CalcRadius(caster);
             if (Unit* target= GetNextRandomRaidMemberOrPet(radius))
             {
                 CastSpell(target, spellProto, true, NULL, triggeredByAura, caster_guid);
                 if (Aura* aura = target->GetAura(spellProto->Id, caster->GetGUID()))
                     aura->SetCharges(jumps);
             }
         }
     }
 
     CastSpell(this, damageSpellId, true, NULL, triggeredByAura, caster_guid);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HandleAuraRaidProcFromChargeWithValue ( AuraEffect * triggeredByAura )

private

 {
     // aura can be deleted at casts
     SpellInfo const* spellProto = triggeredByAura->GetSpellInfo();
     int32 heal = triggeredByAura->GetAmount();
     ObjectGuid caster_guid = triggeredByAura->GetCasterGUID();
 
     // Currently only Prayer of Mending
     if (!(spellProto->SpellFamilyName == SPELLFAMILY_PRIEST && spellProto->SpellFamilyFlags[1] & 0x20))
     {
         TC_LOG_DEBUG("spells", "Unit::HandleAuraRaidProcFromChargeWithValue, received not handled spell: %u", spellProto->Id);
         return false;
     }
 
     // jumps
     int32 jumps = triggeredByAura->GetBase()->GetCharges()-1;
 
     // current aura expire
     triggeredByAura->GetBase()->SetCharges(1);             // will removed at next charges decrease
 
     // next target selection
     if (jumps > 0)
     {
         if (Unit* caster = triggeredByAura->GetCaster())
         {
             SpellEffectInfo const* effect = triggeredByAura->GetSpellEffectInfo();
             float radius = effect->CalcRadius(caster);
 
             if (Unit* target = GetNextRandomRaidMemberOrPet(radius))
             {
                 CastCustomSpell(target, spellProto->Id, &heal, NULL, NULL, true, NULL, triggeredByAura, caster_guid);
                 if (Aura* aura = target->GetAura(spellProto->Id, caster->GetGUID()))
                     aura->SetCharges(jumps);
             }
         }
     }
 
     // heal
     CastCustomSpell(this, 33110, &heal, NULL, NULL, true, NULL, NULL, caster_guid);
     return true;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HandleDummyAuraProc	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown
	)

private

Todo:: It should be moved to database, shouldn't it?

 {
     SpellInfo const* dummySpell = triggeredByAura->GetSpellInfo();
     uint32 effIndex = triggeredByAura->GetEffIndex();
     int32  triggerAmount = triggeredByAura->GetAmount();
 
     Item* castItem = !triggeredByAura->GetBase()->GetCastItemGUID().IsEmpty() && GetTypeId() == TYPEID_PLAYER
         ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
 
     uint32 triggered_spell_id = 0;
     uint32 cooldown_spell_id = 0; // for random trigger, will be one of the triggered spell to avoid repeatable triggers
                                   // otherwise, it's the triggered_spell_id by default
     Unit* target = victim;
     int32 basepoints0 = 0;
     ObjectGuid originalCaster;
 
     switch (dummySpell->SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
         {
             switch (dummySpell->Id)
             {
                 // Unstable Power
                 case 24658:
                 {
                     if (!procSpell || procSpell->Id == 24659)
                         return false;
                     // Need remove one 24659 aura
                     RemoveAuraFromStack(24659);
                     return true;
                 }
                 // Restless Strength
                 case 24661:
                 {
                     // Need remove one 24662 aura
                     RemoveAuraFromStack(24662);
                     return true;
                 }
                 // Mark of Malice
                 case 33493:
                 {
                     // Cast finish spell at last charge
                     if (triggeredByAura->GetBase()->GetCharges() > 1)
                         return false;
 
                     target = this;
                     triggered_spell_id = 33494;
                     break;
                 }
                 // Twisted Reflection (boss spell)
                 case 21063:
                     triggered_spell_id = 21064;
                     break;
                 // Vampiric Aura (boss spell)
                 case 38196:
                 {
                     basepoints0 = 3 * damage;               // 300%
                     if (basepoints0 < 0)
                         return false;
 
                     triggered_spell_id = 31285;
                     target = this;
                     break;
                 }
                 // Aura of Madness (Darkmoon Card: Madness trinket)
                 //=====================================================
                 // 39511 Sociopath: +35 strength (Paladin, Rogue, Druid, Warrior)
                 // 40997 Delusional: +70 attack power (Rogue, Hunter, Paladin, Warrior, Druid)
                 // 40998 Kleptomania: +35 agility (Warrior, Rogue, Paladin, Hunter, Druid)
                 // 40999 Megalomania: +41 damage/healing (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                 // 41002 Paranoia: +35 spell/melee/ranged crit strike rating (All classes)
                 // 41005 Manic: +35 haste (spell, melee and ranged) (All classes)
                 // 41009 Narcissism: +35 intellect (Druid, Shaman, Priest, Warlock, Mage, Paladin, Hunter)
                 // 41011 Martyr Complex: +35 stamina (All classes)
                 // 41406 Dementia: Every 5 seconds either gives you +5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                 // 41409 Dementia: Every 5 seconds either gives you -5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                 case 39446:
                 {
                     if (GetTypeId() != TYPEID_PLAYER || !IsAlive())
                         return false;
 
                     // Select class defined buff
                     switch (getClass())
                     {
                         case CLASS_PALADIN:                 // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
                         case CLASS_DRUID:                   // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
                             triggered_spell_id = RAND(39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409);
                             cooldown_spell_id = 39511;
                             break;
                         case CLASS_ROGUE:                   // 39511, 40997, 40998, 41002, 41005, 41011
                         case CLASS_WARRIOR:                 // 39511, 40997, 40998, 41002, 41005, 41011
                         case CLASS_DEATH_KNIGHT:
                             triggered_spell_id = RAND(39511, 40997, 40998, 41002, 41005, 41011);
                             cooldown_spell_id = 39511;
                             break;
                         case CLASS_PRIEST:                  // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                         case CLASS_SHAMAN:                  // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                         case CLASS_MAGE:                    // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                         case CLASS_WARLOCK:                 // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                             triggered_spell_id = RAND(40999, 41002, 41005, 41009, 41011, 41406, 41409);
                             cooldown_spell_id = 40999;
                             break;
                         case CLASS_HUNTER:                  // 40997, 40999, 41002, 41005, 41009, 41011, 41406, 41409
                             triggered_spell_id = RAND(40997, 40999, 41002, 41005, 41009, 41011, 41406, 41409);
                             cooldown_spell_id = 40997;
                             break;
                         default:
                             return false;
                     }
 
                     target = this;
                     if (roll_chance_i(10))
                         ToPlayer()->Say("This is Madness!", LANG_UNIVERSAL); 
                     break;
                 }
                 // Sunwell Exalted Caster Neck (??? neck)
                 // cast ??? Light's Wrath if Exalted by Aldor
                 // cast ??? Arcane Bolt if Exalted by Scryers
                 case 46569:
                     return false;                           // old unused version
                 // Sunwell Exalted Caster Neck (Shattered Sun Pendant of Acumen neck)
                 // cast 45479 Light's Wrath if Exalted by Aldor
                 // cast 45429 Arcane Bolt if Exalted by Scryers
                 case 45481:
                 {
                     Player* player = ToPlayer();
                     if (!player)
                         return false;
 
                     // Get Aldor reputation rank
                     if (player->GetReputationRank(932) == REP_EXALTED)
                     {
                         target = this;
                         triggered_spell_id = 45479;
                         break;
                     }
                     // Get Scryers reputation rank
                     if (player->GetReputationRank(934) == REP_EXALTED)
                     {
                         // triggered at positive/self casts also, current attack target used then
                         if (target && IsFriendlyTo(target))
                         {
                             target = GetVictim();
                             if (!target)
                             {
                                 target = player->GetSelectedUnit();
                                 if (!target)
                                     return false;
                             }
                             if (IsFriendlyTo(target))
                                 return false;
                         }
 
                         triggered_spell_id = 45429;
                         break;
                     }
                     return false;
                 }
                 // Sunwell Exalted Melee Neck (Shattered Sun Pendant of Might neck)
                 // cast 45480 Light's Strength if Exalted by Aldor
                 // cast 45428 Arcane Strike if Exalted by Scryers
                 case 45482:
                 {
                     if (GetTypeId() != TYPEID_PLAYER)
                         return false;
 
                     // Get Aldor reputation rank
                     if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                     {
                         target = this;
                         triggered_spell_id = 45480;
                         break;
                     }
                     // Get Scryers reputation rank
                     if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                     {
                         triggered_spell_id = 45428;
                         break;
                     }
                     return false;
                 }
                 // Sunwell Exalted Tank Neck (Shattered Sun Pendant of Resolve neck)
                 // cast 45431 Arcane Insight if Exalted by Aldor
                 // cast 45432 Light's Ward if Exalted by Scryers
                 case 45483:
                 {
                     if (GetTypeId() != TYPEID_PLAYER)
                         return false;
 
                     // Get Aldor reputation rank
                     if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                     {
                         target = this;
                         triggered_spell_id = 45432;
                         break;
                     }
                     // Get Scryers reputation rank
                     if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                     {
                         target = this;
                         triggered_spell_id = 45431;
                         break;
                     }
                     return false;
                 }
                 // Sunwell Exalted Healer Neck (Shattered Sun Pendant of Restoration neck)
                 // cast 45478 Light's Salvation if Exalted by Aldor
                 // cast 45430 Arcane Surge if Exalted by Scryers
                 case 45484:
                 {
                     if (GetTypeId() != TYPEID_PLAYER)
                         return false;
 
                     // Get Aldor reputation rank
                     if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                     {
                         target = this;
                         triggered_spell_id = 45478;
                         break;
                     }
                     // Get Scryers reputation rank
                     if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                     {
                         triggered_spell_id = 45430;
                         break;
                     }
                     return false;
                 }
                 // Kill command
                 case 58914:
                 {
                     // Remove aura stack from pet
                     RemoveAuraFromStack(58914);
                     Unit* owner = GetOwner();
                     if (!owner)
                         return true;
                     // reduce the owner's aura stack
                     owner->RemoveAuraFromStack(34027);
                     return true;
                 }
                 // Vampiric Touch (generic, used by some boss)
                 case 52723:
                 case 60501:
                 {
                     triggered_spell_id = 52724;
                     basepoints0 = damage / 2;
                     target = this;
                     break;
                 }
                 // Shadowfiend Death (Gain mana if pet dies with Glyph of Shadowfiend)
                 case 57989:
                 {
                     Unit* owner = GetOwner();
                     if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
                         return false;
                     // Glyph of Shadowfiend (need cast as self cast for owner, no hidden cooldown)
                     owner->CastSpell(owner, 58227, true, castItem, triggeredByAura);
                     return true;
                 }
                 // Divine purpose
                 case 31871:
                 case 31872:
                 {
                     // Roll chane
                     if (!victim || !victim->IsAlive() || !roll_chance_i(triggerAmount))
                         return false;
 
                     // Remove any stun effect on target
                     victim->RemoveAurasWithMechanic(1<<MECHANIC_STUN, AURA_REMOVE_BY_ENEMY_SPELL);
                     return true;
                 }
                 // Purified Shard of the Scale - Onyxia 10 Caster Trinket
                 case 69755:
                 {
                     triggered_spell_id = (procFlag & PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS) ? 69733 : 69729;
                     break;
                 }
                 // Shiny Shard of the Scale - Onyxia 25 Caster Trinket
                 case 69739:
                 {
                     triggered_spell_id = (procFlag & PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS) ? 69734 : 69730;
                     break;
                 }
                 case 71519: // Deathbringer's Will Normal
                 {
                     if (GetTypeId() != TYPEID_PLAYER)
                         return false;
 
                     std::vector<uint32> RandomSpells;
                     switch (getClass())
                     {
                         case CLASS_WARRIOR:
                         case CLASS_PALADIN:
                         case CLASS_DEATH_KNIGHT:
                             RandomSpells.push_back(71484);
                             RandomSpells.push_back(71491);
                             RandomSpells.push_back(71492);
                             break;
                         case CLASS_SHAMAN:
                         case CLASS_ROGUE:
                             RandomSpells.push_back(71486);
                             RandomSpells.push_back(71485);
                             RandomSpells.push_back(71492);
                             break;
                         case CLASS_DRUID:
                             RandomSpells.push_back(71484);
                             RandomSpells.push_back(71485);
                             RandomSpells.push_back(71492);
                             break;
                         case CLASS_HUNTER:
                             RandomSpells.push_back(71486);
                             RandomSpells.push_back(71491);
                             RandomSpells.push_back(71485);
                             break;
                         default:
                             return false;
                     }
                     if (RandomSpells.empty()) // shouldn't happen
                         return false;
 
                     uint8 rand_spell = urand(0, (RandomSpells.size() - 1));
                     CastSpell(target, RandomSpells[rand_spell], true, castItem, triggeredByAura, originalCaster);
                     for (std::vector<uint32>::iterator itr = RandomSpells.begin(); itr != RandomSpells.end(); ++itr)
                     {
                         if (!GetSpellHistory()->HasCooldown(*itr))
                             GetSpellHistory()->AddCooldown(*itr, 0, std::chrono::seconds(cooldown));
                     }
                     break;
                 }
                 case 71562: // Deathbringer's Will Heroic
                 {
                     if (GetTypeId() != TYPEID_PLAYER)
                         return false;
 
                     std::vector<uint32> RandomSpells;
                     switch (getClass())
                     {
                         case CLASS_WARRIOR:
                         case CLASS_PALADIN:
                         case CLASS_DEATH_KNIGHT:
                             RandomSpells.push_back(71561);
                             RandomSpells.push_back(71559);
                             RandomSpells.push_back(71560);
                             break;
                         case CLASS_SHAMAN:
                         case CLASS_ROGUE:
                             RandomSpells.push_back(71558);
                             RandomSpells.push_back(71556);
                             RandomSpells.push_back(71560);
                             break;
                         case CLASS_DRUID:
                             RandomSpells.push_back(71561);
                             RandomSpells.push_back(71556);
                             RandomSpells.push_back(71560);
                             break;
                         case CLASS_HUNTER:
                             RandomSpells.push_back(71558);
                             RandomSpells.push_back(71559);
                             RandomSpells.push_back(71556);
                             break;
                         default:
                             return false;
                     }
                     if (RandomSpells.empty()) // shouldn't happen
                         return false;
 
                     uint8 rand_spell = urand(0, (RandomSpells.size() - 1));
                     CastSpell(target, RandomSpells[rand_spell], true, castItem, triggeredByAura, originalCaster);
                     for (std::vector<uint32>::iterator itr = RandomSpells.begin(); itr != RandomSpells.end(); ++itr)
                     {
                         if (!GetSpellHistory()->HasCooldown(*itr))
                             GetSpellHistory()->AddCooldown(*itr, 0, std::chrono::seconds(cooldown));
                     }
                     break;
                 }
                 case 65032: // Boom aura (321 Boombot)
                 {
                     if (victim->GetEntry() != 33343)   // Scrapbot
                         return false;
 
                     InstanceScript* instance = GetInstanceScript();
                     if (!instance)
                         return false;
 
                     instance->DoCastSpellOnPlayers(65037);  // Achievement criteria marker
                     break;
                 }
                 case 47020: // Enter vehicle XT-002 (Scrapbot)
                 {
                     if (GetTypeId() != TYPEID_UNIT)
                         return false;
 
                     Unit* vehicleBase = GetVehicleBase();
                     if (!vehicleBase)
                         return false;
 
                     // Todo: Check if this amount is blizzlike
                     vehicleBase->ModifyHealth(int32(vehicleBase->CountPctFromMaxHealth(1)));
                     break;
                 }
             }
             break;
         }
         case SPELLFAMILY_MAGE:
         {
             // Hot Streak & Improved Hot Streak
             if (dummySpell->SpellIconID == 2999)
             {
                 if (effIndex != 0)
                     return false;
                 AuraEffect* counter = triggeredByAura->GetBase()->GetEffect(EFFECT_1);
                 if (!counter)
                     return true;
 
                 // Count spell criticals in a row in second aura
                 if (procEx & PROC_EX_CRITICAL_HIT)
                 {
                     counter->SetAmount(counter->GetAmount() * 2);
                     if (counter->GetAmount() < 100 && dummySpell->Id != 44445) // not enough or Hot Streak spell
                         return true;
                     // Crititcal counted -> roll chance
                     if (roll_chance_i(triggerAmount))
                         CastSpell(this, 48108, true, castItem, triggeredByAura);
                 }
                 counter->SetAmount(25);
                 return true;
             }
             // Incanter's Regalia set (add trigger chance to Mana Shield)
             if (dummySpell->SpellFamilyFlags[0] & 0x8000)
             {
                 if (GetTypeId() != TYPEID_PLAYER)
                     return false;
 
                 target = this;
                 triggered_spell_id = 37436;
                 break;
             }
         }
         case SPELLFAMILY_WARLOCK:
         {
             // Seed of Corruption
             if (dummySpell->SpellFamilyFlags[1] & 0x00000010)
             {
                 if (procSpell && procSpell->SpellFamilyFlags[1] & 0x8000)
                     return false;
                 // if damage is more than need or target die from damage deal finish spell
                 if (triggeredByAura->GetAmount() <= int32(damage) || GetHealth() <= damage)
                 {
                     // remember caster before aura delete
                     Unit* caster = triggeredByAura->GetCaster();
 
                     // Remove aura (before cast for prevent infinite loop handlers)
                     RemoveAurasDueToSpell(triggeredByAura->GetId());
 
                     uint32 spell = sSpellMgr->GetSpellWithRank(27285, dummySpell->GetRank());
 
                     // Cast finish spell (triggeredByAura already not exist!)
                     if (caster)
                         caster->CastSpell(this, spell, true, castItem);
                     return true;                            // no hidden cooldown
                 }
 
                 // Damage counting
                 triggeredByAura->SetAmount(triggeredByAura->GetAmount() - damage);
                 return true;
             }
             // Seed of Corruption (Mobs cast) - no die req
             if (!dummySpell->SpellFamilyFlags && dummySpell->SpellIconID == 1932)
             {
                 // if damage is more than need deal finish spell
                 if (triggeredByAura->GetAmount() <= int32(damage))
                 {
                     // remember caster before aura delete
                     Unit* caster = triggeredByAura->GetCaster();
 
                     // Remove aura (before cast for prevent infinite loop handlers)
                     RemoveAurasDueToSpell(triggeredByAura->GetId());
 
                     // Cast finish spell (triggeredByAura already not exist!)
                     if (caster)
                         caster->CastSpell(this, 32865, true, castItem);
                     return true;                            // no hidden cooldown
                 }
                 // Damage counting
                 triggeredByAura->SetAmount(triggeredByAura->GetAmount() - damage);
                 return true;
             }
             switch (dummySpell->Id)
             {
                 // Shadowflame (Voidheart Raiment set bonus)
                 case 37377:
                 {
                     triggered_spell_id = 37379;
                     break;
                 }
                 // Pet Healing (Corruptor Raiment or Rift Stalker Armor)
                 case 37381:
                 {
                     target = GetGuardianPet();
                     if (!target)
                         return false;
 
                     // heal amount
                     basepoints0 = CalculatePct(int32(damage), triggerAmount);
                     triggered_spell_id = 37382;
                     break;
                 }
                 // Shadowflame Hellfire (Voidheart Raiment set bonus)
                 case 39437:
                 {
                     triggered_spell_id = 37378;
                     break;
                 }
             }
             break;
         }
         case SPELLFAMILY_PRIEST:
         {
             switch (dummySpell->Id)
             {
                 // Priest Tier 6 Trinket (Ashtongue Talisman of Acumen)
                 case 40438:
                 {
                     // Shadow Word: Pain
                     if (!procSpell)
                         return false;
                     else if (procSpell->SpellFamilyFlags[0] & 0x8000)
                         triggered_spell_id = 40441;
                     // Renew
                     else if (procSpell->SpellFamilyFlags[0] & 0x40)
                         triggered_spell_id = 40440;
                     else
                         return false;
 
                     target = this;
                     break;
                 }
                 // Oracle Healing Bonus ("Garments of the Oracle" set)
                 case 26169:
                 {
                     // heal amount
                     basepoints0 = int32(CalculatePct(damage, 10));
                     target = this;
                     triggered_spell_id = 26170;
                     break;
                 }
                 // Frozen Shadoweave (Shadow's Embrace set) warning! its not only priest set
                 case 39372:
                 {
                     if (!procSpell || (procSpell->GetSchoolMask() & (SPELL_SCHOOL_MASK_FROST | SPELL_SCHOOL_MASK_SHADOW)) == 0)
                         return false;
 
                     // heal amount
                     basepoints0 = CalculatePct(int32(damage), triggerAmount);
                     target = this;
                     triggered_spell_id = 39373;
                     break;
                 }
                 // Greater Heal (Vestments of Faith (Priest Tier 3) - 4 pieces bonus)
                 case 28809:
                 {
                     triggered_spell_id = 28810;
                     break;
                 }
                 break;
             }
             break;
         }
         case SPELLFAMILY_DRUID:
         {
             switch (dummySpell->Id)
             {
                 // Glyph of Bloodletting
                 case 54815:
                 {
                     if (!target)
                         return false;
 
                     // try to find spell Rip on the target
                     if (AuraEffect const* AurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, flag128(0x00800000, 0x0, 0x0), GetGUID()))
                     {
                         // Rip's max duration, note: spells which modifies Rip's duration also counted
                         uint32 CountMin = AurEff->GetBase()->GetMaxDuration();
 
                         // just Rip's max duration without other spells
                         uint32 CountMax = AurEff->GetSpellInfo()->GetMaxDuration();
 
                         // add possible auras' and Glyph of Shred's max duration
                         CountMax += 3 * triggerAmount * IN_MILLISECONDS;      // Glyph of Bloodletting        -> +6 seconds
                         CountMax += HasAura(60141) ? 4 * IN_MILLISECONDS : 0; // Rip Duration/Lacerate Damage -> +4 seconds
 
                         // if min < max -> that means caster didn't cast 3 shred yet
                         // so set Rip's duration and max duration
                         if (CountMin < CountMax)
                         {
                             AurEff->GetBase()->SetDuration(AurEff->GetBase()->GetDuration() + triggerAmount * IN_MILLISECONDS);
                             AurEff->GetBase()->SetMaxDuration(CountMin + triggerAmount * IN_MILLISECONDS);
                             return true;
                         }
                     }
                     // if not found Rip
                     return false;
                 }
                 // Leader of the Pack
                 case 24932:
                 {
                    if (triggerAmount <= 0)
                         return false;
                     basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
                     target = this;
                     triggered_spell_id = 34299;
                     // Regenerate 4% mana
                     int32 mana = CalculatePct(GetCreateMana(), triggerAmount);
                     CastCustomSpell(this, 68285, &mana, NULL, NULL, true, castItem, triggeredByAura);
                     break;
                 }
                 // Healing Touch (Dreamwalker Raiment set)
                 case 28719:
                 {
                     if (!procSpell)
                         return false;
                     // mana back
                     std::vector<SpellInfo::CostData> costs = procSpell->CalcPowerCost(this, procSpell->GetSchoolMask());
                     auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_MANA; });
                     if (m == costs.end())
                         return false;
 
                     basepoints0 = int32(CalculatePct(m->Amount, 30));
                     target = this;
                     triggered_spell_id = 28742;
                     break;
                 }
                 // Healing Touch Refund (Idol of Longevity trinket)
                 case 28847:
                 {
                     target = this;
                     triggered_spell_id = 28848;
                     break;
                 }
                 // Mana Restore (Malorne Raiment set / Malorne Regalia set)
                 case 37288:
                 case 37295:
                 {
                     target = this;
                     triggered_spell_id = 37238;
                     break;
                 }
                 // Druid Tier 6 Trinket
                 case 40442:
                 {
                     float  chance;
 
                     if (!procSpell)
                         return false;
                     // Starfire
                     if (procSpell->SpellFamilyFlags[0] & 0x4)
                     {
                         triggered_spell_id = 40445;
                         chance = 25.0f;
                     }
                     // Rejuvenation
                     else if (procSpell->SpellFamilyFlags[0] & 0x10)
                     {
                         triggered_spell_id = 40446;
                         chance = 25.0f;
                     }
                     // Mangle (Bear) and Mangle (Cat)
                     else if (procSpell->SpellFamilyFlags[1] & 0x00000440)
                     {
                         triggered_spell_id = 40452;
                         chance = 40.0f;
                     }
                     else
                         return false;
 
                     if (!roll_chance_f(chance))
                         return false;
 
                     target = this;
                     break;
                 }
                 // Item - Druid T10 Balance 4P Bonus
                 case 70723:
                 {
                     // Wrath & Starfire
                     if (procSpell && (procSpell->SpellFamilyFlags[0] & 0x5) && (procEx & PROC_EX_CRITICAL_HIT))
                     {
                         triggered_spell_id = 71023;
                         SpellInfo const* triggeredSpell = sSpellMgr->GetSpellInfo(triggered_spell_id);
                         if (!triggeredSpell)
                             return false;
                         SpellEffectInfo const* effect = triggeredSpell->GetEffect(DIFFICULTY_NONE, EFFECT_0);
                         if (!effect)
                             return false;
                         basepoints0 = CalculatePct(int32(damage), triggerAmount) / (triggeredSpell->GetMaxDuration() / effect->ApplyAuraPeriod);
                         // Add remaining ticks to damage done
                         basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
                     }
                     break;
                 }
                 // Item - Druid T10 Restoration 4P Bonus (Rejuvenation)
                 case 70664:
                 {
                     // Proc only from normal Rejuvenation
                     if (!procSpell || procSpell->Id != 774)
                         return false;
 
                     Player* caster = ToPlayer();
                     if (!caster)
                         return false;
                     if (!caster->GetGroup() && victim == this)
                         return false;
 
                     CastCustomSpell(70691, SPELLVALUE_BASE_POINT0, damage, victim, true);
                     return true;
                 }
             }
             break;
         }
         case SPELLFAMILY_PALADIN:
         {
             // Judgements of the Wise
             if (dummySpell->SpellIconID == 3017)
             {
                 target = this;
                 triggered_spell_id = 31930;
                 break;
             }
             switch (dummySpell->Id)
             {
                 // Sacred Shield
                 case 53601:
                 {
                     if (procFlag & PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS)
                         return false;
 
                     if (damage > 0)
                         triggered_spell_id = 58597;
 
                     // Item - Paladin T8 Holy 4P Bonus
                     if (Unit* caster = triggeredByAura->GetCaster())
                         if (AuraEffect const* aurEff = caster->GetAuraEffect(64895, 0))
                             cooldown = aurEff->GetAmount();
 
                     target = this;
                     break;
                 }
                 // Holy Power (Redemption Armor set)
                 case 28789:
                 {
                     if (!victim)
                         return false;
 
                     // Set class defined buff
                     switch (victim->getClass())
                     {
                         case CLASS_PALADIN:
                         case CLASS_PRIEST:
                         case CLASS_SHAMAN:
                         case CLASS_DRUID:
                             triggered_spell_id = 28795;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
                             break;
                         case CLASS_MAGE:
                         case CLASS_WARLOCK:
                             triggered_spell_id = 28793;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
                             break;
                         case CLASS_HUNTER:
                         case CLASS_ROGUE:
                             triggered_spell_id = 28791;     // Increases the friendly target's attack power by $s1 for $d.
                             break;
                         case CLASS_WARRIOR:
                             triggered_spell_id = 28790;     // Increases the friendly target's armor
                             break;
                         default:
                             return false;
                     }
                     break;
                 }
                 case 31801:
                 {
                     if (effIndex != 0)                       // effect 2 used by seal unleashing code
                         return false;
 
                     // At melee attack or Hammer of the Righteous spell damage considered as melee attack
                     bool stacker = !procSpell || procSpell->Id == 53595;
                     // spells with SPELL_DAMAGE_CLASS_MELEE excluding Judgements
                     bool damager = procSpell && (procSpell->EquippedItemClass != -1 || procSpell->Id == 71433 || procSpell->Id == 71434);
 
                     if (!stacker && !damager)
                         return false;
 
                     triggered_spell_id = 31803;
 
                     // On target with 5 stacks of Censure direct damage is done
                     if (Aura* aur = victim->GetAura(triggered_spell_id, GetGUID()))
                     {
                         if (aur->GetStackAmount() == 5)
                         {
                             if (stacker)
                                 aur->RefreshDuration();
                             CastSpell(victim, 42463, true);
                             return true;
                         }
                     }
 
                     if (!stacker)
                         return false;
                     break;
                 }
                 // Paladin Tier 6 Trinket (Ashtongue Talisman of Zeal)
                 case 40470:
                 {
                     if (!procSpell)
                         return false;
 
                     float chance;
 
                     // Flash of light/Holy light
                     if (procSpell->SpellFamilyFlags[0] & 0xC0000000)
                     {
                         triggered_spell_id = 40471;
                         chance = 15.0f;
                     }
                     // Judgement (any)
                     else if (procSpell->GetSpellSpecific() == SPELL_SPECIFIC_JUDGEMENT)
                     {
                         triggered_spell_id = 40472;
                         chance = 50.0f;
                     }
                     else
                         return false;
 
                     if (!roll_chance_f(chance))
                         return false;
 
                     break;
                 }
                 // Item - Paladin T8 Holy 2P Bonus
                 case 64890:
                 {
                     triggered_spell_id = 64891;
                     basepoints0 = triggerAmount * damage / 300;
                     break;
                 }
                 case 71406: // Tiny Abomination in a Jar
                 case 71545: // Tiny Abomination in a Jar (Heroic)
                 {
                     if (!victim || !victim->IsAlive())
                         return false;
 
                     CastSpell(this, 71432, true, NULL, triggeredByAura);
 
                     Aura const* dummy = GetAura(71432);
                     if (!dummy || dummy->GetStackAmount() < (dummySpell->Id == 71406 ? 8 : 7))
                         return false;
 
                     RemoveAurasDueToSpell(71432);
                     triggered_spell_id = 71433;  // default main hand attack
                     // roll if offhand
                     if (Player const* player = ToPlayer())
                         if (player->GetWeaponForAttack(OFF_ATTACK, true) && urand(0, 1))
                             triggered_spell_id = 71434;
                     target = victim;
                     break;
                 }
                 // Item - Icecrown 25 Normal Dagger Proc
                 case 71880:
                 {
                     switch (getPowerType())
                     {
                         case POWER_MANA:
                             triggered_spell_id = 71881;
                             break;
                         case POWER_RAGE:
                             triggered_spell_id = 71883;
                             break;
                         case POWER_ENERGY:
                             triggered_spell_id = 71882;
                             break;
                         case POWER_RUNIC_POWER:
                             triggered_spell_id = 71884;
                             break;
                         default:
                             return false;
                     }
                     break;
                 }
                 // Item - Icecrown 25 Heroic Dagger Proc
                 case 71892:
                 {
                     switch (getPowerType())
                     {
                         case POWER_MANA:
                             triggered_spell_id = 71888;
                             break;
                         case POWER_RAGE:
                             triggered_spell_id = 71886;
                             break;
                         case POWER_ENERGY:
                             triggered_spell_id = 71887;
                             break;
                         case POWER_RUNIC_POWER:
                             triggered_spell_id = 71885;
                             break;
                         default:
                             return false;
                     }
                     break;
                 }
             }
             break;
         }
         case SPELLFAMILY_SHAMAN:
         {
             switch (dummySpell->Id)
             {
                 // Totemic Power (The Earthshatterer set)
                 case 28823:
                 {
                     if (!victim)
                         return false;
 
                     // Set class defined buff
                     switch (victim->getClass())
                     {
                         case CLASS_PALADIN:
                         case CLASS_PRIEST:
                         case CLASS_SHAMAN:
                         case CLASS_DRUID:
                             triggered_spell_id = 28824;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
                             break;
                         case CLASS_MAGE:
                         case CLASS_WARLOCK:
                             triggered_spell_id = 28825;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
                             break;
                         case CLASS_HUNTER:
                         case CLASS_ROGUE:
                             triggered_spell_id = 28826;     // Increases the friendly target's attack power by $s1 for $d.
                             break;
                         case CLASS_WARRIOR:
                             triggered_spell_id = 28827;     // Increases the friendly target's armor
                             break;
                         default:
                             return false;
                     }
                     break;
                 }
                 // Lesser Healing Wave (Totem of Flowing Water Relic)
                 case 28849:
                 {
                     target = this;
                     triggered_spell_id = 28850;
                     break;
                 }
                 // Windfury Weapon (Passive) 1-8 Ranks
                 case 33757:
                 {
                     Player* player = ToPlayer();
                     if (!player || !castItem || !castItem->IsEquipped() || !victim || !victim->IsAlive())
                         return false;
 
                     // custom cooldown processing case
                     if (cooldown && GetSpellHistory()->HasCooldown(dummySpell->Id))
                         return false;
 
                     if (triggeredByAura->GetBase() && castItem->GetGUID() != triggeredByAura->GetBase()->GetCastItemGUID())
                         return false;
 
                     WeaponAttackType attType = WeaponAttackType(player->GetAttackBySlot(castItem->GetSlot(), castItem->GetTemplate()->GetInventoryType()));
                     if ((attType != BASE_ATTACK && attType != OFF_ATTACK)
                         || (attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                         || (attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK))
                          return false;
 
                     // Now compute real proc chance...
                     uint32 chance = 20;
                     player->ApplySpellMod(dummySpell->Id, SPELLMOD_CHANCE_OF_SUCCESS, chance);
 
                     Item* addWeapon = player->GetWeaponForAttack(attType == BASE_ATTACK ? OFF_ATTACK : BASE_ATTACK, true);
                     uint32 enchant_id_add = addWeapon ? addWeapon->GetEnchantmentId(EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)) : 0;
                     SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id_add);
                     if (pEnchant && pEnchant->EffectSpellID[0] == dummySpell->Id)
                         chance += 14;
 
                     if (!roll_chance_i(chance))
                         return false;
 
                     // Now amount of extra power stored in 1 effect of Enchant spell
                     uint32 spellId = 8232;
                     SpellInfo const* windfurySpellInfo = sSpellMgr->GetSpellInfo(spellId);
                     if (!windfurySpellInfo)
                     {
                         TC_LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: non-existing spell id: %u (Windfury)", spellId);
                         return false;
                     }
 
                     int32 extra_attack_power = CalculateSpellDamage(victim, windfurySpellInfo, 1);
 
                     // Value gained from additional AP
                     basepoints0 = int32(extra_attack_power / 14.0f * GetAttackTime(attType) / 1000);
 
                     if (procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK)
                         triggered_spell_id = 25504;
 
                     if (procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                         triggered_spell_id = 33750;
 
                     // apply cooldown before cast to prevent processing itself
                     if (cooldown)
                         player->GetSpellHistory()->AddCooldown(dummySpell->Id, 0, std::chrono::seconds(cooldown));
 
                     // Attack Twice
                     for (uint32 i = 0; i < 2; ++i)
                         CastCustomSpell(victim, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
 
                     return true;
                 }
                 // Shaman Tier 6 Trinket
                 case 40463:
                 {
                     if (!procSpell)
                         return false;
 
                     float chance;
                     if (procSpell->SpellFamilyFlags[0] & 0x1)
                     {
                         triggered_spell_id = 40465;         // Lightning Bolt
                         chance = 15.0f;
                     }
                     else if (procSpell->SpellFamilyFlags[0] & 0x80)
                     {
                         triggered_spell_id = 40465;         // Lesser Healing Wave
                         chance = 10.0f;
                     }
                     else if (procSpell->SpellFamilyFlags[1] & 0x00000010)
                     {
                         triggered_spell_id = 40466;         // Stormstrike
                         chance = 50.0f;
                     }
                     else
                         return false;
 
                     if (!roll_chance_f(chance))
                         return false;
 
                     target = this;
                     break;
                 }
                 // Spirit Hunt
                 case 58877:
                 {
                     // Cast on owner
                     target = GetOwner();
                     if (!target)
                         return false;
                     basepoints0 = CalculatePct(int32(damage), triggerAmount);
                     triggered_spell_id = 58879;
                     // Cast on spirit wolf
                     CastCustomSpell(this, triggered_spell_id, &basepoints0, NULL, NULL, true, NULL, triggeredByAura);
                     break;
                 }
                 // Shaman T8 Elemental 4P Bonus
                 case 64928:
                 {
                     basepoints0 = CalculatePct(int32(damage), triggerAmount);
                     triggered_spell_id = 64930;            // Electrified
                     break;
                 }
                 // Shaman T9 Elemental 4P Bonus
                 case 67228:
                 {
                     // Lava Burst
                     if (procSpell && procSpell->SpellFamilyFlags[1] & 0x1000)
                     {
                         triggered_spell_id = 71824;
                         SpellInfo const* triggeredSpell = sSpellMgr->GetSpellInfo(triggered_spell_id);
                         if (!triggeredSpell)
                             return false;
                         if (SpellEffectInfo const* effect = triggeredSpell->GetEffect(DIFFICULTY_NONE, EFFECT_0))
                             basepoints0 = CalculatePct(int32(damage), triggerAmount) / (triggeredSpell->GetMaxDuration() / effect->ApplyAuraPeriod);
                     }
                     break;
                 }
                 // Item - Shaman T10 Restoration 4P Bonus
                 case 70808:
                 {
                     // Chain Heal
                     if (procSpell && (procSpell->SpellFamilyFlags[0] & 0x100) && (procEx & PROC_EX_CRITICAL_HIT))
                     {
                         triggered_spell_id = 70809;
                         SpellInfo const* triggeredSpell = sSpellMgr->GetSpellInfo(triggered_spell_id);
                         if (!triggeredSpell)
                             return false;
                         if (SpellEffectInfo const* effect = triggeredSpell->GetEffect(DIFFICULTY_NONE, EFFECT_0))
                         {
                             basepoints0 = CalculatePct(int32(damage), triggerAmount) / (triggeredSpell->GetMaxDuration() / effect->ApplyAuraPeriod);
                             // Add remaining ticks to healing done
                             basepoints0 += GetRemainingPeriodicAmount(GetGUID(), triggered_spell_id, SPELL_AURA_PERIODIC_HEAL);
                         }
                     }
                     break;
                 }
                 // Item - Shaman T10 Elemental 4P Bonus
                 case 70817:
                 {
                     if (!target)
                         return false;
                     // try to find spell Flame Shock on the target
                     if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, flag128(0x10000000, 0x0, 0x0), GetGUID()))
                     {
                         Aura* flameShock  = aurEff->GetBase();
                         int32 maxDuration = flameShock->GetMaxDuration();
                         int32 newDuration = flameShock->GetDuration() + 2 * aurEff->GetPeriod();
 
                         flameShock->SetDuration(newDuration);
                         // is it blizzlike to change max duration for FS?
                         if (newDuration > maxDuration)
                             flameShock->SetMaxDuration(newDuration);
 
                         return true;
                     }
                     // if not found Flame Shock
                     return false;
                 }
                 break;
             }
             // Frozen Power
             if (dummySpell->SpellIconID == 3780)
             {
                 if (!target)
                     return false;
                 if (GetDistance(target) < 15.0f)
                     return false;
                 float chance = (float)triggerAmount;
                 if (!roll_chance_f(chance))
                     return false;
 
                 triggered_spell_id = 63685;
                 break;
             }
             // Static Shock
             if (dummySpell->SpellIconID == 3059)
             {
                 // Lightning Shield
                 if (GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, flag128(0x400, 0, 0)))
                 {
                     uint32 spell = 26364;
 
                     GetSpellHistory()->ResetCooldown(spell);
                     CastSpell(target, spell, true, castItem, triggeredByAura);
                     return true;
                 }
                 return false;
             }
             break;
         }
         case SPELLFAMILY_DEATHKNIGHT:
         {
             // Dancing Rune Weapon
             if (dummySpell->Id == 49028)
             {
                 // 1 dummy aura for dismiss rune blade
                 if (effIndex != 1)
                     return false;
 
                 Unit* pPet = NULL;
                 for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr) // Find Rune Weapon
                     if ((*itr)->GetEntry() == 27893)
                     {
                         pPet = *itr;
                         break;
                     }
 
                 if (pPet && pPet->GetVictim() && damage && procSpell)
                 {
                     uint32 procDmg = damage / 2;
 
                     SpellNonMeleeDamage log(pPet, pPet->GetVictim(), procSpell->Id, procSpell->GetSchoolMask());
                     log.damage = procDmg;
                     pPet->DealDamage(pPet->GetVictim(), procDmg, NULL, SPELL_DIRECT_DAMAGE, procSpell->GetSchoolMask(), procSpell, true);
                     pPet->SendSpellNonMeleeDamageLog(&log);
                     break;
                 }
                 else
                     return false;
             }
             // Threat of Thassarian
             if (dummySpell->SpellIconID == 2023)
             {
                 // Must Dual Wield
                 if (!procSpell || !haveOffhandWeapon())
                     return false;
                 // Chance as basepoints for dummy aura
                 if (!roll_chance_i(triggerAmount))
                     return false;
 
                 switch (procSpell->Id)
                 {
                     case 49020: triggered_spell_id = 66198; break; // Obliterate
                     case 49143: triggered_spell_id = 66196; break; // Frost Strike
                     case 45462: triggered_spell_id = 66216; break; // Plague Strike
                     case 49998: triggered_spell_id = 66188; break; // Death Strike
                     case 56815: triggered_spell_id = 66217; break; // Rune Strike
                     case 45902: triggered_spell_id = 66215; break; // Blood Strike
                     default:
                         return false;
                 }
                 break;
             }
             // Runic Power Back on Snare/Root
             if (dummySpell->Id == 61257)
             {
                 // only for spells and hit/crit (trigger start always) and not start from self cast spells
                 if (!procSpell || !(procEx & (PROC_EX_NORMAL_HIT|PROC_EX_CRITICAL_HIT)) || this == victim)
                     return false;
                 // Need snare or root mechanic
                 if (!(procSpell->GetAllEffectsMechanicMask() & ((1<<MECHANIC_ROOT)|(1<<MECHANIC_SNARE))))
                     return false;
                 triggered_spell_id = 61258;
                 target = this;
                 break;
             }
             break;
         }
         case SPELLFAMILY_PET:
         {
             break;
         }
         default:
             break;
     }
 
     // if not handled by custom case, get triggered spell from dummySpell proto
     if (!triggered_spell_id)
         triggered_spell_id = triggeredByAura->GetSpellEffectInfo()->TriggerSpell;
 
     // processed charge only counting case
     if (!triggered_spell_id)
         return true;
 
     SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(triggered_spell_id);
     if (!triggerEntry)
     {
         TC_LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: Spell %u has non-existing triggered spell %u", dummySpell->Id, triggered_spell_id);
         return false;
     }
 
     if (cooldown_spell_id == 0)
         cooldown_spell_id = triggered_spell_id;
 
     if (cooldown && GetTypeId() == TYPEID_PLAYER && GetSpellHistory()->HasCooldown(cooldown_spell_id))
         return false;
 
     if (basepoints0)
         CastCustomSpell(target, triggered_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura, originalCaster);
     else
         CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura, originalCaster);
 
     if (cooldown)
         GetSpellHistory()->AddCooldown(cooldown_spell_id, 0, std::chrono::seconds(cooldown));
 
     return true;
 }

Here is the caller graph for this function:

void Unit::HandleEmoteCommand ( uint32 anim_id )

 {
     WorldPackets::Chat::Emote packet;
     packet.Guid = GetGUID();
     packet.EmoteID = anim_id;
     SendMessageToSet(packet.Write(), true);
 }

Here is the call graph for this function:

bool Unit::HandleOverrideClassScriptAuraProc	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	cooldown
	)

private

 {
     int32 scriptId = triggeredByAura->GetMiscValue();
 
     if (!victim || !victim->IsAlive())
         return false;
 
     Item* castItem = !triggeredByAura->GetBase()->GetCastItemGUID().IsEmpty() && GetTypeId() == TYPEID_PLAYER
         ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
 
     uint32 triggered_spell_id = 0;
 
     switch (scriptId)
     {
         case 4533:                                          // Dreamwalker Raiment 2 pieces bonus
         {
             // Chance 50%
             if (!roll_chance_i(50))
                 return false;
 
             switch (victim->getPowerType())
             {
                 case POWER_MANA:   triggered_spell_id = 28722; break;
                 case POWER_RAGE:   triggered_spell_id = 28723; break;
                 case POWER_ENERGY: triggered_spell_id = 28724; break;
                 default:
                     return false;
             }
             break;
         }
         case 4537:                                          // Dreamwalker Raiment 6 pieces bonus
             triggered_spell_id = 28750;                     // Blessing of the Claw
             break;
         default:
             break;
     }
 
     // not processed
     if (!triggered_spell_id)
         return false;
 
     // standard non-dummy case
     SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(triggered_spell_id);
 
     if (!triggerEntry)
     {
         TC_LOG_ERROR("entities.unit", "Unit::HandleOverrideClassScriptAuraProc: Spell %u triggering for class script id %u", triggered_spell_id, scriptId);
         return false;
     }
 
     if (cooldown && GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetSpellHistory()->HasCooldown(triggered_spell_id))
         return false;
 
     CastSpell(victim, triggered_spell_id, true, castItem, triggeredByAura);
 
     if (cooldown)
         GetSpellHistory()->AddCooldown(triggered_spell_id, 0, std::chrono::seconds(cooldown));
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::HandleProcExtraAttackFor ( Unit * victim )

 {
     while (m_extraAttacks)
     {
         AttackerStateUpdate(victim, BASE_ATTACK, true);
         --m_extraAttacks;
     }
 }

Here is the call graph for this function:

bool Unit::HandleProcTriggerSpell	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown
	)

private

Todo:: : reverify and move these spells to spellscripts

 {
     // Get triggered aura spell info
     SpellInfo const* auraSpellInfo = triggeredByAura->GetSpellInfo();
 
     // Basepoints of trigger aura
     int32 triggerAmount = triggeredByAura->GetAmount();
 
     // Set trigger spell id, target, custom basepoints
     uint32 trigger_spell_id = triggeredByAura->GetSpellEffectInfo()->TriggerSpell;
 
     Unit*  target = NULL;
     int32  basepoints0 = 0;
 
     if (triggeredByAura->GetAuraType() == SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE)
         basepoints0 = triggerAmount;
 
     Item* castItem = !triggeredByAura->GetBase()->GetCastItemGUID().IsEmpty() && GetTypeId() == TYPEID_PLAYER
         ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : NULL;
 
     // Try handle unknown trigger spells
     // triggered spells exists only in serverside spell_dbc
     {
         switch (auraSpellInfo->SpellFamilyName)
         {
             case SPELLFAMILY_GENERIC:
                 switch (auraSpellInfo->Id)
                 {
                     case 57345:             // Darkmoon Card: Greatness
                     {
                         float stat = 0.0f;
                         // strength
                         if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 60229;stat = GetStat(STAT_STRENGTH); }
                         // agility
                         if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 60233;stat = GetStat(STAT_AGILITY);  }
                         // intellect
                         if (GetStat(STAT_INTELLECT)> stat) { trigger_spell_id = 60234;stat = GetStat(STAT_INTELLECT);}
                         // spirit
                         if (GetStat(STAT_SPIRIT)   > stat) { trigger_spell_id = 60235;                               }
                         break;
                     }
                     case 64568:             // Blood Reserve
                     {
                         if (HealthBelowPctDamaged(35, damage))
                         {
                             CastCustomSpell(this, 64569, &triggerAmount, NULL, NULL, true);
                             RemoveAura(64568);
                         }
                         return false;
                     }
                     case 67702:             // Death's Choice, Item - Coliseum 25 Normal Melee Trinket
                     {
                         float stat = 0.0f;
                         // strength
                         if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 67708;stat = GetStat(STAT_STRENGTH); }
                         // agility
                         if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 67703;                               }
                         break;
                     }
                     case 67771:             // Death's Choice (heroic), Item - Coliseum 25 Heroic Melee Trinket
                     {
                         float stat = 0.0f;
                         // strength
                         if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 67773;stat = GetStat(STAT_STRENGTH); }
                         // agility
                         if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 67772;                               }
                         break;
                     }
                     // Mana Drain Trigger
                     case 27522:
                     case 40336:
                     {
                         // On successful melee or ranged attack gain $29471s1 mana and if possible drain $27526s1 mana from the target.
                         if (IsAlive())
                             CastSpell(this, 29471, true, castItem, triggeredByAura);
                         if (victim && victim->IsAlive())
                             CastSpell(victim, 27526, true, castItem, triggeredByAura);
                         return true;
                     }
                     // Evasive Maneuvers
                     case 50240:
                     {
                         // Remove a Evasive Charge
                         Aura* charge = GetAura(50241);
                         if (charge && charge->ModStackAmount(-1, AURA_REMOVE_BY_ENEMY_SPELL))
                             RemoveAurasDueToSpell(50240);
                         break;
                     }
                 }
                 break;
             case SPELLFAMILY_DRUID:
             {
                 switch (auraSpellInfo->Id)
                 {
                     // Druid Forms Trinket
                     case 37336:
                     {
                         switch (GetShapeshiftForm())
                         {
                             case FORM_NONE:     trigger_spell_id = 37344; break;
                             case FORM_CAT:      trigger_spell_id = 37341; break;
                             case FORM_BEAR:     trigger_spell_id = 37340; break;
                             case FORM_TREE:     trigger_spell_id = 37342; break;
                             case FORM_MOONKIN:  trigger_spell_id = 37343; break;
                             default:
                                 return false;
                         }
                         break;
                     }
                     // Druid T9 Feral Relic (Lacerate, Swipe, Mangle, and Shred)
                     case 67353:
                     {
                         switch (GetShapeshiftForm())
                         {
                             case FORM_CAT:      trigger_spell_id = 67355; break;
                             case FORM_BEAR:     trigger_spell_id = 67354; break;
                             default:
                                 return false;
                         }
                         break;
                     }
                     default:
                         break;
                 }
                 break;
             }
             case SPELLFAMILY_HUNTER:
             {
                 /*if (auraSpellInfo->SpellIconID == 3247)     // Piercing Shots
                 {
                     trigger_spell_id = 63468; // 6.x missing from dbc but it is in the tooltip
                     SpellInfo const* TriggerPS = sSpellMgr->GetSpellInfo(trigger_spell_id);
                     if (!TriggerPS)
                         return false;
 
                     basepoints0 = CalculatePct(int32(damage), triggerAmount) / (TriggerPS->GetMaxDuration() / TriggerPS->Effects[0].ApplyAuraPeriod);
                     basepoints0 += victim->GetRemainingPeriodicAmount(GetGUID(), trigger_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
                     break;
                 }*/
                 // Item - Hunter T9 4P Bonus
                 if (auraSpellInfo->Id == 67151)
                 {
                     trigger_spell_id = 68130;
                     target = this;
                     break;
                 }
                 break;
             }
             case SPELLFAMILY_PALADIN:
             {
                 switch (auraSpellInfo->Id)
                 {
                     // Soul Preserver
                     case 60510:
                     {
                         switch (getClass())
                         {
                             case CLASS_DRUID:
                                 trigger_spell_id = 60512;
                                 break;
                             case CLASS_PALADIN:
                                 trigger_spell_id = 60513;
                                 break;
                             case CLASS_PRIEST:
                                 trigger_spell_id = 60514;
                                 break;
                             case CLASS_SHAMAN:
                                 trigger_spell_id = 60515;
                                 break;
                         }
 
                         target = this;
                         break;
                     }
                     case 37657: // Lightning Capacitor
                     case 54841: // Thunder Capacitor
                     case 67712: // Item - Coliseum 25 Normal Caster Trinket
                     case 67758: // Item - Coliseum 25 Heroic Caster Trinket
                     {
                         if (!victim || !victim->IsAlive() || GetTypeId() != TYPEID_PLAYER)
                             return false;
 
                         uint32 stack_spell_id = 0;
                         switch (auraSpellInfo->Id)
                         {
                             case 37657:
                                 stack_spell_id = 37658;
                                 trigger_spell_id = 37661;
                                 break;
                             case 54841:
                                 stack_spell_id = 54842;
                                 trigger_spell_id = 54843;
                                 break;
                             case 67712:
                                 stack_spell_id = 67713;
                                 trigger_spell_id = 67714;
                                 break;
                             case 67758:
                                 stack_spell_id = 67759;
                                 trigger_spell_id = 67760;
                                 break;
                         }
 
                         CastSpell(this, stack_spell_id, true, NULL, triggeredByAura);
 
                         Aura* dummy = GetAura(stack_spell_id);
                         if (!dummy || dummy->GetStackAmount() < triggerAmount)
                             return false;
 
                         RemoveAurasDueToSpell(stack_spell_id);
                         target = victim;
                         break;
                     }
                     default:
                         break;
                 }
                 break;
             }
             case SPELLFAMILY_DEATHKNIGHT:
             {
                 // Item - Death Knight T10 Melee 4P Bonus
                 if (auraSpellInfo->Id == 70656)
                 {
                     if (GetTypeId() != TYPEID_PLAYER || getClass() != CLASS_DEATH_KNIGHT)
                         return false;
 
                     for (uint8 i = 0; i < MAX_RUNES; ++i)
                         if (ToPlayer()->GetRuneCooldown(i) == 0)
                             return false;
                 }
                 break;
             }
             case SPELLFAMILY_ROGUE:
             {
                 switch (auraSpellInfo->Id)
                 {
                     // Rogue T10 2P bonus, should only proc on caster
                     case 70805:
                     {
                         if (victim != this)
                             return false;
                         break;
                     }
                 }
                 break;
             }
             default:
                  break;
         }
     }
 
     // All ok. Check current trigger spell
     SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(trigger_spell_id);
     if (triggerEntry == NULL)
     {
         // Don't cast unknown spell
         TC_LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell %u (effIndex: %u) has unknown TriggerSpell %u. Unhandled custom case?", auraSpellInfo->Id, triggeredByAura->GetEffIndex(), trigger_spell_id);
         return false;
     }
 
     // not allow proc extra attack spell at extra attack
     if (m_extraAttacks && triggerEntry->HasEffect(GetMap()->GetDifficultyID(), SPELL_EFFECT_ADD_EXTRA_ATTACKS))
         return false;
 
     // Custom requirements (not listed in procEx) Warning! damage dealing after this
     // Custom triggered spells
     switch (auraSpellInfo->Id)
     {
         // Deep Wounds
         case 12834:
         case 12849:
         case 12867:
         {
             if (GetTypeId() != TYPEID_PLAYER)
                 return false;
 
             float averageDmg = 0;
             // now compute approximate weapon damage by formula from wowwiki.com
             if (procFlags & PROC_FLAG_DONE_OFFHAND_ATTACK)
                 averageDmg = (GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE) + GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE)) / 2.f;
             else
                 averageDmg = (GetFloatValue(UNIT_FIELD_MINDAMAGE) + GetFloatValue(UNIT_FIELD_MAXDAMAGE)) / 2.f;
 
             basepoints0 = int32(averageDmg);
             break;
         }
         // Persistent Shield (Scarab Brooch trinket)
         // This spell originally trigger 13567 - Dummy Trigger (vs dummy efect)
         case 26467:
         {
             basepoints0 = int32(CalculatePct(damage, 15));
             target = victim;
             trigger_spell_id = 26470;
             break;
         }
         // Unyielding Knights (item exploit 29108\29109)
         case 38164:
         {
             if (!victim || victim->GetEntry() != 19457)  // Proc only if your target is Grillok
                 return false;
             break;
         }
         // Deflection
         case 52420:
         {
             if (!HealthBelowPctDamaged(35, damage))
                 return false;
             break;
         }
 
         // Cheat Death
         case 28845:
         {
             // When your health drops below 20%
             if (HealthBelowPctDamaged(20, damage) || HealthBelowPct(20))
                 return false;
             break;
         }
         // Greater Heal Refund (Avatar Raiment set)
         case 37594:
         {
             if (!victim || !victim->IsAlive())
                 return false;
 
             // Doesn't proc if target already has full health
             if (victim->IsFullHealth())
                 return false;
             // If your Greater Heal brings the target to full health, you gain $37595s1 mana.
             if (victim->GetHealth() + damage < victim->GetMaxHealth())
                 return false;
             break;
         }
         // Bonus Healing (Crystal Spire of Karabor mace)
         case 40971:
         {
             // If your target is below $s1% health
             if (!victim || !victim->IsAlive() || victim->HealthAbovePct(triggerAmount))
                 return false;
             break;
         }
         // Decimation
         case 108869:
             // Can proc only if target has hp below 25%
             if (!victim || !victim->HealthBelowPct(triggeredByAura->GetSpellEffectInfo()->CalcValue()))
                 return false;
             break;
         // Deathbringer Saurfang - Blood Beast's Blood Link
         case 72176:
             basepoints0 = 3;
             break;
         // Professor Putricide - Ooze Spell Tank Protection
         case 71770:
             if (victim)
                 victim->CastSpell(victim, trigger_spell_id, true);    // EffectImplicitTarget is self
             return true;
         case 45057: // Evasive Maneuvers (Commendation of Kael`thas trinket)
         case 71634: // Item - Icecrown 25 Normal Tank Trinket 1
         case 71640: // Item - Icecrown 25 Heroic Tank Trinket 1
         case 75475: // Item - Chamber of Aspects 25 Normal Tank Trinket
         case 75481: // Item - Chamber of Aspects 25 Heroic Tank Trinket
         {
             // Procs only if damage takes health below $s1%
             if (!HealthBelowPctDamaged(triggerAmount, damage))
                 return false;
             break;
         }
         default:
             break;
     }
 
     // Custom basepoints/target for exist spell
     // dummy basepoints or other customs
     switch (trigger_spell_id)
     {
         // Auras which should proc on area aura source (caster in this case):
         // Cast positive spell on enemy target
         case 7099:  // Curse of Mending
         case 39703: // Curse of Mending
         case 29494: // Temptation
         case 20233: // Improved Lay on Hands (cast on target)
         {
             target = victim;
             break;
         }
         // Finish movies that add combo
         case 14189: // Seal Fate (Netherblade set)
         case 14157: // Ruthlessness
         {
             if (!victim || victim == this)
                 return false;
             // Need add combopoint AFTER finish movie (or they dropped in finish phase)
             break;
         }
         // Item - Druid T10 Balance 2P Bonus
         case 16870:
         {
             if (HasAura(70718))
                 CastSpell(this, 70721, true);
             break;
         }
         // Enlightenment (trigger only from mana cost spells)
         case 35095:
         {
             if (!procSpell)
                 return false;
 
             std::vector<SpellInfo::CostData> costs = procSpell->CalcPowerCost(this, procSpell->GetSchoolMask());
             auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_MANA && cost.Amount > 0; });
             if (m == costs.end())
                 return false;
             break;
         }
         case 46916:  // Slam! (Bloodsurge proc)
         case 52437:  // Sudden Death
         {
             // Item - Warrior T10 Melee 4P Bonus
             if (AuraEffect const* aurEff = GetAuraEffect(70847, 0))
             {
                 if (!roll_chance_i(aurEff->GetAmount()))
                     break;
                 CastSpell(this, 70849, true, castItem, triggeredByAura); // Extra Charge!
                 CastSpell(this, 71072, true, castItem, triggeredByAura); // Slam GCD Reduced
                 CastSpell(this, 71069, true, castItem, triggeredByAura); // Execute GCD Reduced
             }
             break;
         }
         // Maelstrom Weapon
         case 53817:
         {
             // has rank dependant proc chance, ignore too often cases
             // PPM = 2.5 * (rank of talent),
             uint32 rank = auraSpellInfo->GetRank();
             // 5 rank -> 100% 4 rank -> 80% and etc from full rate
             if (!roll_chance_i(20*rank))
                 return false;
             // Item - Shaman T10 Enhancement 4P Bonus
             if (AuraEffect const* aurEff = GetAuraEffect(70832, 0))
                 if (Aura const* maelstrom = GetAura(53817))
                     if ((maelstrom->GetStackAmount() == maelstrom->GetSpellInfo()->StackAmount) && roll_chance_i(aurEff->GetAmount()))
                         CastSpell(this, 70831, true, castItem, triggeredByAura);
             break;
         }
         // Glyph of Death's Embrace
         case 58679:
         {
             // Proc only from healing part of Death Coil. Check is essential as all Death Coil spells have 0x2000 mask in SpellFamilyFlags
             if (!procSpell || !(procSpell->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && procSpell->SpellFamilyFlags[0] == 0x80002000))
                 return false;
             break;
         }
         // Savage Defense
         case 62606:
         {
             basepoints0 = CalculatePct(triggerAmount, GetTotalAttackPowerValue(BASE_ATTACK));
             break;
         }
         // Body and Soul
         case 64128:
         case 65081:
         {
             // Proc only from PW:S cast
             if (!(procSpell->SpellFamilyFlags[0] & 0x00000001))
                 return false;
             break;
         }
         // Culling the Herd
         case 70893:
         {
             // check if we're doing a critical hit
             if (!(procSpell->SpellFamilyFlags[1] & 0x10000000) && (procEx != PROC_EX_CRITICAL_HIT))
                 return false;
             // check if we're procced by Claw, Bite or Smack (need to use the spell icon ID to detect it)
             if (!(procSpell->SpellIconID == 262 || procSpell->SpellIconID == 1680 || procSpell->SpellIconID == 473))
                 return false;
             break;
         }
     }
 
     if (cooldown && GetTypeId() == TYPEID_PLAYER && GetSpellHistory()->HasCooldown(trigger_spell_id))
         return false;
 
     // extra attack should hit same target
     if (triggerEntry->HasEffect(GetMap()->GetDifficultyID(), SPELL_EFFECT_ADD_EXTRA_ATTACKS))
         target = victim;
 
     // try detect target manually if not set
     if (target == NULL)
         target = !(procFlags & (PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS)) && triggerEntry->IsPositive() ? this : victim;
 
     if (basepoints0)
         CastCustomSpell(target, trigger_spell_id, &basepoints0, NULL, NULL, true, castItem, triggeredByAura);
     else
         CastSpell(target, trigger_spell_id, true, castItem, triggeredByAura);
 
     if (cooldown)
         GetSpellHistory()->AddCooldown(trigger_spell_id, 0, std::chrono::seconds(cooldown));
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HandleSpellClick	(	Unit *	clicker,
		int8	seatId = `-1`
	)

First check simple relations from clicker to clickee

Check database conditions

 {
     bool result = false;
     uint32 spellClickEntry = GetVehicleKit() ? GetVehicleKit()->GetCreatureEntry() : GetEntry();
     SpellClickInfoMapBounds clickPair = sObjectMgr->GetSpellClickInfoMapBounds(spellClickEntry);
     for (SpellClickInfoContainer::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr)
     {
         if (!itr->second.IsFitToRequirements(clicker, this))
             continue;
 
         if (!sConditionMgr->IsObjectMeetingSpellClickConditions(spellClickEntry, itr->second.spellId, clicker, this))
             continue;
 
         Unit* caster = (itr->second.castFlags & NPC_CLICK_CAST_CASTER_CLICKER) ? clicker : this;
         Unit* target = (itr->second.castFlags & NPC_CLICK_CAST_TARGET_CLICKER) ? clicker : this;
         ObjectGuid origCasterGUID = (itr->second.castFlags & NPC_CLICK_CAST_ORIG_CASTER_OWNER) ? GetOwnerGUID() : clicker->GetGUID();
 
         SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(itr->second.spellId);
         // if (!spellEntry) should be checked at npc_spellclick load
 
         if (seatId > -1)
         {
             uint8 i = 0;
             bool valid = false;
             for (SpellEffectInfo const* effect : spellEntry->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
             {
                 if (!effect)
                     continue;
 
                 if (effect->ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE)
                 {
                     valid = true;
                     break;
                 }
                 ++i;
             }
 
             if (!valid)
             {
                 TC_LOG_ERROR("sql.sql", "Spell %u specified in npc_spellclick_spells is not a valid vehicle enter aura!", itr->second.spellId);
                 continue;
             }
 
             if (IsInMap(caster))
                 caster->CastCustomSpell(itr->second.spellId, SpellValueMod(SPELLVALUE_BASE_POINT0+i), seatId + 1, target, GetVehicleKit() ? TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE : TRIGGERED_NONE, NULL, NULL, origCasterGUID);
             else    // This can happen during Player::_LoadAuras
             {
                 int32 bp0[MAX_SPELL_EFFECTS];
                 for (SpellEffectInfo const* effect : spellEntry->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
                     if (effect)
                         bp0[effect->EffectIndex] = effect->BasePoints;
 
                 bp0[i] = seatId;
                 Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, bp0, NULL, origCasterGUID);
             }
         }
         else
         {
             if (IsInMap(caster))
                 caster->CastSpell(target, spellEntry, GetVehicleKit() ? TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE : TRIGGERED_NONE, NULL, NULL, origCasterGUID);
             else
                 Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, NULL, NULL, origCasterGUID);
         }
 
         result = true;
     }
 
     Creature* creature = ToCreature();
     if (creature && creature->IsAIEnabled)
         creature->AI()->OnSpellClick(clicker, result);
 
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HandleStatModifier	(	UnitMods	unitMod,
		UnitModifierType	modifierType,
		float	amount,
		bool	apply
	)

 {
     if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
     {
         TC_LOG_ERROR("entities.unit", "ERROR in HandleStatModifier(): non-existing UnitMods or wrong UnitModifierType!");
         return false;
     }
 
     switch (modifierType)
     {
         case BASE_VALUE:
         case BASE_PCT_EXCLUDE_CREATE:
         case TOTAL_VALUE:
             m_auraModifiersGroup[unitMod][modifierType] += apply ? amount : -amount;
             break;
         case BASE_PCT:
         case TOTAL_PCT:
             ApplyPercentModFloatVar(m_auraModifiersGroup[unitMod][modifierType], amount, apply);
             break;
         default:
             break;
     }
 
     if (!CanModifyStats())
         return false;
 
     switch (unitMod)
     {
         case UNIT_MOD_STAT_STRENGTH:
         case UNIT_MOD_STAT_AGILITY:
         case UNIT_MOD_STAT_STAMINA:
         case UNIT_MOD_STAT_INTELLECT:
         case UNIT_MOD_STAT_SPIRIT:         UpdateStats(GetStatByAuraGroup(unitMod));  break;
 
         case UNIT_MOD_ARMOR:               UpdateArmor();           break;
         case UNIT_MOD_HEALTH:              UpdateMaxHealth();       break;
 
         case UNIT_MOD_MANA:
         case UNIT_MOD_RAGE:
         case UNIT_MOD_FOCUS:
         case UNIT_MOD_ENERGY:
         case UNIT_MOD_RUNE:
         case UNIT_MOD_RUNIC_POWER:          UpdateMaxPower(GetPowerTypeByAuraGroup(unitMod));          break;
 
         case UNIT_MOD_RESISTANCE_HOLY:
         case UNIT_MOD_RESISTANCE_FIRE:
         case UNIT_MOD_RESISTANCE_NATURE:
         case UNIT_MOD_RESISTANCE_FROST:
         case UNIT_MOD_RESISTANCE_SHADOW:
         case UNIT_MOD_RESISTANCE_ARCANE:   UpdateResistances(GetSpellSchoolByAuraGroup(unitMod));      break;
 
         case UNIT_MOD_ATTACK_POWER:        UpdateAttackPowerAndDamage();         break;
         case UNIT_MOD_ATTACK_POWER_RANGED: UpdateAttackPowerAndDamage(true);     break;
 
         case UNIT_MOD_DAMAGE_MAINHAND:     UpdateDamagePhysical(BASE_ATTACK);    break;
         case UNIT_MOD_DAMAGE_OFFHAND:      UpdateDamagePhysical(OFF_ATTACK);     break;
         case UNIT_MOD_DAMAGE_RANGED:       UpdateDamagePhysical(RANGED_ATTACK);  break;
 
         default:
             break;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`
	)		const

 {
     if (GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask))
         return true;
     return false;
 }

Here is the call graph for this function:

bool Unit::HasAuraEffect	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	caster = `ObjectGuid::Empty`
	)		const

 {
     AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
     for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
     {
         if (itr->second->HasEffect(effIndex)
                 && (!caster || itr->second->GetBase()->GetCasterGUID() == caster))
         {
             return true;
         }
     }
     return false;
 }

Here is the caller graph for this function:

bool Unit::HasAuraState	(	AuraStateType	flag,
		SpellInfo const *	spellProto = `NULL`,
		Unit const *	Caster = `NULL`
	)		const

 {
     if (Caster)
     {
         if (spellProto)
         {
             AuraEffectList const& stateAuras = Caster->GetAuraEffectsByType(SPELL_AURA_ABILITY_IGNORE_AURASTATE);
             for (AuraEffectList::const_iterator j = stateAuras.begin(); j != stateAuras.end(); ++j)
                 if ((*j)->IsAffectingSpell(spellProto))
                     return true;
         }
         // Check per caster aura state
         // If aura with aurastate by caster not found return false
         if ((1<<(flag-1)) & PER_CASTER_AURA_STATE_MASK)
         {
             AuraStateAurasMapBounds range = m_auraStateAuras.equal_range(flag);
             for (AuraStateAurasMap::const_iterator itr = range.first; itr != range.second; ++itr)
                 if (itr->second->GetBase()->GetCasterGUID() == Caster->GetGUID())
                     return true;
             return false;
         }
     }
 
     return HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasAuraType ( AuraType auraType ) const

 {
     return (!m_modAuras[auraType].empty());
 }

Here is the caller graph for this function:

bool Unit::HasAuraTypeWithAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

 {
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if ((*i)->IsAffectingSpell(affectedSpell))
             return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasAuraTypeWithCaster	(	AuraType	auratype,
		ObjectGuid	caster
	)		const

 {
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if (caster == (*i)->GetCasterGUID())
             return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasAuraTypeWithFamilyFlags	(	AuraType	auraType,
		uint32	familyName,
		uint32	familyFlags
	)		const

 {
     if (!HasAuraType(auraType))
         return false;
     AuraEffectList const& auras = GetAuraEffectsByType(auraType);
     for (AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
         if (SpellInfo const* iterSpellProto = (*itr)->GetSpellInfo())
             if (iterSpellProto->SpellFamilyName == familyName && iterSpellProto->SpellFamilyFlags[0] & familyFlags)
                 return true;
     return false;
 }

Here is the call graph for this function:

bool Unit::HasAuraTypeWithMiscvalue	(	AuraType	auratype,
		int32	miscvalue
	)		const

 {
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if (miscvalue == (*i)->GetMiscValue())
             return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasAuraTypeWithValue	(	AuraType	auratype,
		int32	value
	)		const

 {
     AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
     for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
         if (value == (*i)->GetAmount())
             return true;
     return false;
 }

Here is the call graph for this function:

bool Unit::HasAuraWithMechanic ( uint32 mechanicMask ) const

 {
     for (AuraApplicationMap::const_iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end(); ++iter)
     {
         SpellInfo const* spellInfo = iter->second->GetBase()->GetSpellInfo();
         if (spellInfo->Mechanic && (mechanicMask & (1 << spellInfo->Mechanic)))
             return true;
 
         for (SpellEffectInfo const* effect : iter->second->GetBase()->GetSpellEffectInfos())
         if (effect && effect->Effect && effect->Mechanic)
         if (mechanicMask & (1 << effect->Mechanic))
                     return true;
     }
 
     return false;
 }

Here is the caller graph for this function:

bool Unit::HasBreakableByDamageAuraType	(	AuraType	type,
		uint32	excludeAura = `0`
	)		const

 {
     AuraEffectList const& auras = GetAuraEffectsByType(type);
     for (AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
         if ((!excludeAura || excludeAura != (*itr)->GetSpellInfo()->Id) && //Avoid self interrupt of channeled Crowd Control spells like Seduction
             ((*itr)->GetSpellInfo()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_TAKE_DAMAGE))
             return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HasBreakableByDamageCrowdControlAura ( Unit * excludeCasterChannel = NULL ) const

 {
     uint32 excludeAura = 0;
     if (Spell* currentChanneledSpell = excludeCasterChannel ? excludeCasterChannel->GetCurrentSpell(CURRENT_CHANNELED_SPELL) : NULL)
         excludeAura = currentChanneledSpell->GetSpellInfo()->Id; //Avoid self interrupt of channeled Crowd Control spells like Seduction
 
     return (   HasBreakableByDamageAuraType(SPELL_AURA_MOD_CONFUSE, excludeAura)
             || HasBreakableByDamageAuraType(SPELL_AURA_MOD_FEAR, excludeAura)
             || HasBreakableByDamageAuraType(SPELL_AURA_MOD_STUN, excludeAura)
             || HasBreakableByDamageAuraType(SPELL_AURA_MOD_ROOT, excludeAura)
             || HasBreakableByDamageAuraType(SPELL_AURA_TRANSFORM, excludeAura));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Unit::HasExtraUnitMovementFlag ( uint16 f ) const

inline

2115 { return m_movementInfo.HasExtraMovementFlag(f); }

MovementInfo::HasExtraMovementFlag

MovementInfo m_movementInfo

Definition: Object.h:612

bool HasExtraMovementFlag(uint16 flag) const

Definition: Object.h:336

Here is the caller graph for this function:

bool Unit::HasInvisibilityAura ( ) const

inline

1598 { return HasAuraType(SPELL_AURA_MOD_INVISIBILITY); }

SPELL_AURA_MOD_INVISIBILITY

Definition: SpellAuraDefines.h:78

bool HasAuraType(AuraType auraType) const

Definition: Unit.cpp:4247

bool Unit::HasNegativeAuraWithAttribute	(	uint32	flag,
		ObjectGuid	guid = `ObjectGuid::Empty`
	)		const

 {
     for (AuraApplicationMap::const_iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end(); ++iter)
     {
         Aura const* aura = iter->second->GetBase();
         if (!iter->second->IsPositive() && aura->GetSpellInfo()->Attributes & flag && (!guid || aura->GetCasterGUID() == guid))
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool Unit::HasNegativeAuraWithInterruptFlag	(	uint32	flag,
		ObjectGuid	guid = `ObjectGuid::Empty`
	)		const

 {
     if (!(m_interruptMask & flag))
         return false;
     for (AuraApplicationList::const_iterator iter = m_interruptableAuras.begin(); iter != m_interruptableAuras.end(); ++iter)
     {
         if (!(*iter)->IsPositive() && (*iter)->GetBase()->GetSpellInfo()->AuraInterruptFlags & flag && (!guid || (*iter)->GetBase()->GetCasterGUID() == guid))
             return true;
     }
     return false;
 }

Here is the caller graph for this function:

bool Unit::HasSharedVision ( ) const

inline

1757 { return !m_sharedVision.empty(); }

Unit::m_sharedVision

SharedVisionList m_sharedVision

Definition: Unit.h:2293

Here is the caller graph for this function:

virtual bool Unit::HasSpell ( uint32 ) const

inlinevirtual

Reimplemented in Creature, and Pet.

1593 { return false; }

Here is the caller graph for this function:

bool Unit::HasStealthAura ( ) const

inline

1597 { return HasAuraType(SPELL_AURA_MOD_STEALTH); }

SPELL_AURA_MOD_STEALTH

Definition: SpellAuraDefines.h:76

bool HasAuraType(AuraType auraType) const

Definition: Unit.cpp:4247

Here is the caller graph for this function:

bool Unit::HasUnitMovementFlag ( uint32 f ) const

inline

2109 { return m_movementInfo.HasMovementFlag(f); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MovementInfo m_movementInfo

Definition: Object.h:612

Here is the caller graph for this function:

bool Unit::HasUnitState ( const uint32 f ) const

inline

1395 { return (m_state & f) != 0; }

Unit::m_state

uint32 m_state

Definition: Unit.h:2340

uint32 Unit::HasUnitTypeMask ( uint32 mask ) const

inline

1399 { return mask & m_unitTypeMask; }

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

bool Unit::haveOffhandWeapon ( ) const

 {
     if (Player const* player = ToPlayer())
         return player->GetWeaponForAttack(OFF_ATTACK, true) != nullptr;
 
     return CanDualWield();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::HealBySpell	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		uint32	addHealth,
		bool	critical = `false`
	)

 {
     uint32 absorb = 0;
     // calculate heal absorb and reduce healing
     CalcHealAbsorb(victim, spellInfo, addHealth, absorb);
 
     int32 gain = DealHeal(victim, addHealth);
     SendHealSpellLog(victim, spellInfo->Id, addHealth, uint32(addHealth - gain), absorb, critical);
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::HealthAbovePct ( int32 pct ) const

inline

1432 { return GetHealth() > CountPctFromMaxHealth(pct); }

uint32 GetHealth() const

Definition: Unit.h:1426

uint32 CountPctFromMaxHealth(int32 pct) const

Definition: Unit.h:1435

Here is the caller graph for this function:

bool Unit::HealthAbovePctHealed	(	int32	pct,
		uint32	heal
	)		const

inline

1433 { return uint64(GetHealth()) + uint64(heal) > CountPctFromMaxHealth(pct); }

G3D::uint64

uint64_t uint64

Definition: g3dmath.h:170

uint32 GetHealth() const

Definition: Unit.h:1426

uint32 CountPctFromMaxHealth(int32 pct) const

Definition: Unit.h:1435

Here is the caller graph for this function:

bool Unit::HealthBelowPct ( int32 pct ) const

inline

1430 { return GetHealth() < CountPctFromMaxHealth(pct); }

uint32 GetHealth() const

Definition: Unit.h:1426

uint32 CountPctFromMaxHealth(int32 pct) const

Definition: Unit.h:1435

Here is the caller graph for this function:

bool Unit::HealthBelowPctDamaged	(	int32	pct,
		uint32	damage
	)		const

inline

1431 { return int64(GetHealth()) - int64(damage) < int64(CountPctFromMaxHealth(pct)); }

G3D::int64

int64_t int64

Definition: g3dmath.h:169

uint32 GetHealth() const

Definition: Unit.h:1426

uint32 CountPctFromMaxHealth(int32 pct) const

Definition: Unit.h:1435

void Unit::IncrDiminishing ( DiminishingGroup group )

 {
     // Checking for existing in the table
     for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
     {
         if (i->DRGroup != group)
             continue;
         if (int32(i->hitCount) < GetDiminishingReturnsMaxLevel(group))
             i->hitCount += 1;
         return;
     }
     m_Diminishing.push_back(DiminishingReturn(group, getMSTime(), DIMINISHING_LEVEL_2));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

CharmInfo * Unit::InitCharmInfo ( )

 {
     if (!m_charmInfo)
         m_charmInfo = new CharmInfo(this);
 
     return m_charmInfo;
 }

Here is the caller graph for this function:

void Unit::InitStatBuffMods ( )

 {
     for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
         SetFloatValue(UNIT_FIELD_POSSTAT+i, 0);
     for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
         SetFloatValue(UNIT_FIELD_NEGSTAT+i, 0);
 }

Here is the call graph for this function:

bool Unit::InitTamedPet	(	Pet *	pet,
		uint8	level,
		uint32	spell_id
	)

 {
     pet->SetCreatorGUID(GetGUID());
     pet->setFaction(getFaction());
     pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, spell_id);
 
     if (GetTypeId() == TYPEID_PLAYER)
         pet->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
 
     if (!pet->InitStatsForLevel(level))
     {
         TC_LOG_ERROR("entities.unit", "Pet::InitStatsForLevel() failed for creature (Entry: %u)!", pet->GetEntry());
         return false;
     }
 
     pet->CopyPhaseFrom(this);
 
     pet->GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
     // this enables pet details window (Shift+P)
     pet->InitPetCreateSpells();
     //pet->InitLevelupSpellsForLevel();
     pet->SetFullHealth();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::InterruptNonMeleeSpells	(	bool	withDelayed,
		uint32	spellid = `0`,
		bool	withInstant = `true`
	)

 {
     // generic spells are interrupted if they are not finished or delayed
     if (m_currentSpells[CURRENT_GENERIC_SPELL] && (!spell_id || m_currentSpells[CURRENT_GENERIC_SPELL]->m_spellInfo->Id == spell_id))
         InterruptSpell(CURRENT_GENERIC_SPELL, withDelayed, withInstant);
 
     // autorepeat spells are interrupted if they are not finished or delayed
     if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL] && (!spell_id || m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id == spell_id))
         InterruptSpell(CURRENT_AUTOREPEAT_SPELL, withDelayed, withInstant);
 
     // channeled spells are interrupted if they are not finished, even if they are delayed
     if (m_currentSpells[CURRENT_CHANNELED_SPELL] && (!spell_id || m_currentSpells[CURRENT_CHANNELED_SPELL]->m_spellInfo->Id == spell_id))
         InterruptSpell(CURRENT_CHANNELED_SPELL, true, true);
 }

Here is the call graph for this function:

void Unit::InterruptSpell	(	CurrentSpellTypes	spellType,
		bool	withDelayed = `true`,
		bool	withInstant = `true`
	)

 {
     //TC_LOG_DEBUG("entities.unit", "Interrupt spell for unit %u.", GetEntry());
     Spell* spell = m_currentSpells[spellType];
     if (spell
         && (withDelayed || spell->getState() != SPELL_STATE_DELAYED)
         && (withInstant || spell->GetCastTime() > 0))
     {
         // for example, do not let self-stun aura interrupt itself
         if (!spell->IsInterruptable())
             return;
 
         // send autorepeat cancel message for autorepeat spells
         if (spellType == CURRENT_AUTOREPEAT_SPELL)
             if (GetTypeId() == TYPEID_PLAYER)
                 ToPlayer()->SendAutoRepeatCancel(this);
 
         if (spell->getState() != SPELL_STATE_FINISHED)
             spell->cancel();
 
         m_currentSpells[spellType] = NULL;
         spell->SetReferencedFromCurrent(false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsAlive ( ) const

inline

1692 { return (m_deathState == ALIVE); }

ALIVE

Definition: Unit.h:541

DeathState m_deathState

Definition: Unit.h:2259

bool Unit::IsAlwaysDetectableFor ( WorldObject const * seer ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

 {
     if (WorldObject::IsAlwaysDetectableFor(seer))
         return true;
 
     if (HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, seer->GetGUID()))
         return true;
 
     return false;
 }

Here is the call graph for this function:

bool Unit::IsAlwaysVisibleFor ( WorldObject const * seer ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

 {
     if (WorldObject::IsAlwaysVisibleFor(seer))
         return true;
 
     // Always seen by owner
     ObjectGuid guid = GetCharmerOrOwnerGUID();
     if (!guid.IsEmpty())
         if (seer->GetGUID() == guid)
             return true;
 
     if (Player const* seerPlayer = seer->ToPlayer())
         if (Unit* owner =  GetOwner())
             if (Player* ownerPlayer = owner->ToPlayer())
                 if (ownerPlayer->IsGroupVisibleFor(seerPlayer))
                     return true;
 
     return false;
 }

Here is the call graph for this function:

bool Unit::IsArmorer ( ) const

inline

1577 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_REPAIR); }

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

UNIT_NPC_FLAG_REPAIR

Definition: Unit.h:747

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isAttackingPlayer ( ) const

 {
     if (HasUnitState(UNIT_STATE_ATTACK_PLAYER))
         return true;
 
     for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
         if ((*itr)->isAttackingPlayer())
             return true;
 
     for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
         if (!m_SummonSlot[i].IsEmpty())
             if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
                 if (summon->isAttackingPlayer())
                     return true;
 
     return false;
 }

Here is the call graph for this function:

bool Unit::isAttackReady ( WeaponAttackType type = BASE_ATTACK ) const

inline

1357 { return m_attackTimer[type] == 0; }

Unit::m_attackTimer

uint32 m_attackTimer[MAX_ATTACK]

Definition: Unit.h:2251

Here is the caller graph for this function:

bool Unit::IsAuctioner ( ) const

inline

1576 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_AUCTIONEER); }

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

UNIT_NPC_FLAG_AUCTIONEER

Definition: Unit.h:756

Here is the call graph for this function:

bool Unit::IsBanker ( ) const

inline

1571 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_BANKER); }

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

UNIT_NPC_FLAG_BANKER

Definition: Unit.h:752

Definition: UpdateFields.h:135

Here is the call graph for this function:

bool Unit::IsBattleMaster ( ) const

inline

1570 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_BATTLEMASTER); }

UNIT_NPC_FLAG_BATTLEMASTER

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: Unit.h:755

Unit::GetCharmerOrOwnerOrOwnGUID

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isBlockCritical ( )

 {
     if (roll_chance_i(GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_CRIT_CHANCE)))
         return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsCharmed ( ) const

inline

1742 { return !GetCharmerGUID().IsEmpty(); }

Unit::GetCharmerGUID

ObjectGuid GetCharmerGUID() const

Definition: Unit.h:1704

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the caller graph for this function:

bool Unit::IsCharmedOwnedByPlayerOrPlayer ( ) const

inline

1715 { return GetCharmerOrOwnerOrOwnGUID().IsPlayer(); }

ObjectGuid::IsPlayer

bool IsPlayer() const

Definition: ObjectGuid.h:249

ObjectGuid GetCharmerOrOwnerOrOwnGUID() const

Definition: Unit.cpp:12682

Here is the caller graph for this function:

bool Unit::IsContestedGuard ( ) const

 {
     if (FactionTemplateEntry const* entry = GetFactionTemplateEntry())
         return entry->IsContestedGuardFaction();
 
     return false;
 }

Here is the call graph for this function:

bool Unit::IsControlledByPlayer ( ) const

inline

1712 { return m_ControlledByPlayer; }

Unit::m_ControlledByPlayer

bool m_ControlledByPlayer

Definition: Unit.h:2175

Here is the caller graph for this function:

bool Unit::IsCritter ( ) const

inline

1580 { return GetCreatureType() == CREATURE_TYPE_CRITTER; }

Unit::GetCreatureType

uint32 GetCreatureType() const

Definition: Unit.cpp:11248

CREATURE_TYPE_CRITTER

Definition: SharedDefines.h:3561

Here is the caller graph for this function:

bool Unit::IsDamageReducedByArmor	(	SpellSchoolMask	damageSchoolMask,
		SpellInfo const *	spellInfo = `NULL`,
		uint8	effIndex = `MAX_SPELL_EFFECTS`
	)

 {
     // only physical spells damage gets reduced by armor
     if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0)
         return false;
     if (spellInfo)
     {
         // there are spells with no specific attribute but they have "ignores armor" in tooltip
         if (spellInfo->HasAttribute(SPELL_ATTR0_CU_IGNORE_ARMOR))
             return false;
 
         // bleeding effects are not reduced by armor
         if (SpellEffectInfo const* effect = spellInfo->GetEffect(GetMap()->GetDifficultyID(), effIndex))
         {
             if (effect->ApplyAuraName == SPELL_AURA_PERIODIC_DAMAGE ||
                 effect->Effect == SPELL_EFFECT_SCHOOL_DAMAGE)
                 if (spellInfo->GetEffectMechanicMask(effIndex) & (1<<MECHANIC_BLEED))
                     return false;
         }
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isDead ( ) const

inline

1694 { return (m_deathState == DEAD || m_deathState == CORPSE); }

DEAD

Definition: Unit.h:544

CORPSE

Definition: Unit.h:543

Unit::m_duringRemoveFromWorld

DeathState m_deathState

Definition: Unit.h:2259

Here is the caller graph for this function:

bool Unit::IsDuringRemoveFromWorld ( ) const

inline

2198 {return m_duringRemoveFromWorld;}

bool m_duringRemoveFromWorld

Definition: Unit.h:2353

Here is the caller graph for this function:

bool Unit::isDying ( ) const

inline

1693 { return (m_deathState == JUST_DIED); }

JUST_DIED

Definition: Unit.h:542

DeathState m_deathState

Definition: Unit.h:2259

Here is the caller graph for this function:

bool Unit::IsFalling ( ) const

 {
     return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FALLING | MOVEMENTFLAG_FALLING_FAR) || movespline->isFalling();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isFeared ( ) const

inline

1599 { return HasAuraType(SPELL_AURA_MOD_FEAR); }

SPELL_AURA_MOD_FEAR

Definition: SpellAuraDefines.h:67

bool HasAuraType(AuraType auraType) const

Definition: Unit.cpp:4247

Here is the caller graph for this function:

bool Unit::IsFFAPvP ( ) const

inline

1482 { return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP); }

Definition: UpdateFields.h:146

Object::HasByteFlag

bool HasByteFlag(uint16 index, uint8 offset, uint8 flag) const

Definition: Object.cpp:1298

UNIT_BYTE2_FLAG_FFA_PVP

Definition: Unit.h:310

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsFlying ( ) const

inline

2189 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FLYING | MOVEMENTFLAG_DISABLE_GRAVITY); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MOVEMENTFLAG_DISABLE_GRAVITY

MovementInfo m_movementInfo

Definition: Object.h:612

MOVEMENTFLAG_FLYING

Definition: Unit.h:800

Definition: Unit.h:785

Here is the caller graph for this function:

bool Unit::IsFriendlyTo ( Unit const * unit ) const

 {
     return GetReactionTo(unit) >= REP_FRIENDLY;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isFrozen ( ) const

 {
     return HasAuraState(AURA_STATE_FROZEN);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsFullHealth ( ) const

inline

1429 { return GetHealth() == GetMaxHealth(); }

uint32 GetMaxHealth() const

Definition: Unit.h:1427

uint32 GetHealth() const

Definition: Unit.h:1426

Here is the caller graph for this function:

bool Unit::IsGossip ( ) const

inline

1567 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP); }

UNIT_NPC_FLAG_GOSSIP

Definition: Unit.h:735

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

bool Unit::IsGuardian ( ) const

inline

1402 { return (m_unitTypeMask & UNIT_MASK_GUARDIAN) != 0; }

UNIT_MASK_GUARDIAN

Definition: Unit.h:860

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

bool Unit::IsGuildMaster ( ) const

inline

1569 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_PETITIONER); }

UNIT_NPC_FLAG_PETITIONER

Definition: Unit.h:753

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

bool Unit::IsHighestExclusiveAura	(	Aura const *	aura,
		bool	removeOtherAuraApplications = `false`
	)

 {
     for (AuraEffect* aurEff : aura->GetAuraEffects())
     {
         if (!aurEff)
             continue;
         AuraType const auraType = AuraType(aurEff->GetSpellEffectInfo()->ApplyAuraName);
         AuraEffectList const& auras = GetAuraEffectsByType(auraType);
         for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end();)
         {
             AuraEffect const* existingAurEff = (*itr);
             ++itr;
 
             if (sSpellMgr->CheckSpellGroupStackRules(aura->GetSpellInfo(), existingAurEff->GetSpellInfo())
                 == SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST)
             {
                 int32 diff = abs(aurEff->GetAmount()) - abs(existingAurEff->GetAmount());
                 if (!diff)
                     diff = int32(aura->GetEffectMask()) - int32(existingAurEff->GetBase()->GetEffectMask());
 
                 if (diff > 0)
                 {
                     Aura const* base = existingAurEff->GetBase();
                     // no removing of area auras from the original owner, as that completely cancels them
                     if (removeOtherAuraApplications && (!base->IsArea() || base->GetOwner() != this))
                     {
                         if (AuraApplication* aurApp = existingAurEff->GetBase()->GetApplicationOfTarget(GetGUID()))
                         {
                             bool hasMoreThanOneEffect = base->HasMoreThanOneEffectForType(auraType);
                             uint32 removedAuras = m_removedAurasCount;
                             RemoveAura(aurApp);
                             if (hasMoreThanOneEffect || m_removedAurasCount > removedAuras + 1)
                                 itr = auras.begin();
                         }
                     }
                 }
                 else if (diff < 0)
                     return false;
             }
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsHostileTo ( Unit const * unit ) const

 {
     return GetReactionTo(unit) <= REP_HOSTILE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsHostileToPlayers ( ) const

 {
     FactionTemplateEntry const* my_faction = GetFactionTemplateEntry();
     if (!my_faction || !my_faction->Faction)
         return false;
 
     FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->Faction);
     if (raw_faction && raw_faction->ReputationIndex >= 0)
         return false;
 
     return my_faction->IsHostileToPlayers();
 }

Here is the call graph for this function:

bool Unit::IsHovering ( ) const

inline

1669 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_HOVER); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MovementInfo m_movementInfo

Definition: Object.h:612

MOVEMENTFLAG_HOVER

Definition: Unit.h:804

Here is the caller graph for this function:

bool Unit::IsHunterPet ( ) const

inline

1404 { return (m_unitTypeMask & UNIT_MASK_HUNTER_PET) != 0; }

UNIT_MASK_HUNTER_PET

Definition: Unit.h:865

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

bool Unit::IsImmunedToDamage ( SpellSchoolMask meleeSchoolMask ) const

 {
     // If m_immuneToSchool type contain this school type, IMMUNE damage.
     SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
     for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
         if (itr->type & shoolMask)
             return true;
 
     // If m_immuneToDamage type contain magic, IMMUNE damage.
     SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
     for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
         if (itr->type & shoolMask)
             return true;
 
     return false;
 }

Here is the caller graph for this function:

bool Unit::IsImmunedToDamage ( SpellInfo const * spellInfo ) const

 {
     if (spellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY))
         return false;
 
     uint32 shoolMask = spellInfo->GetSchoolMask();
     if (spellInfo->Id != 42292 && spellInfo->Id != 59752)
     {
         // If m_immuneToSchool type contain this school type, IMMUNE damage.
         SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
         for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
             if (itr->type & shoolMask && !spellInfo->CanPierceImmuneAura(sSpellMgr->GetSpellInfo(itr->spellId)))
                 return true;
     }
 
     // If m_immuneToDamage type contain magic, IMMUNE damage.
     SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
     for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
         if (itr->type & shoolMask)
             return true;
 
     return false;
 }

Here is the call graph for this function:

bool Unit::IsImmunedToSpell ( SpellInfo const * spellInfo ) const

virtual

Reimplemented in Creature.

 {
     if (!spellInfo)
         return false;
 
     // Single spell immunity.
     SpellImmuneList const& idList = m_spellImmune[IMMUNITY_ID];
     for (SpellImmuneList::const_iterator itr = idList.begin(); itr != idList.end(); ++itr)
         if (itr->type == spellInfo->Id)
             return true;
 
     if (spellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY))
         return false;
 
     if (spellInfo->Dispel)
     {
         SpellImmuneList const& dispelList = m_spellImmune[IMMUNITY_DISPEL];
         for (SpellImmuneList::const_iterator itr = dispelList.begin(); itr != dispelList.end(); ++itr)
             if (itr->type == spellInfo->Dispel)
                 return true;
     }
 
     // Spells that don't have effectMechanics.
     if (spellInfo->Mechanic)
     {
         SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
         for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
             if (itr->type == spellInfo->Mechanic)
                 return true;
     }
 
     bool immuneToAllEffects = true;
     for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         // State/effect immunities applied by aura expect full spell immunity
         // Ignore effects with mechanic, they are supposed to be checked separately
         if (!effect || !effect->IsEffect())
             continue;
         if (!IsImmunedToSpellEffect(spellInfo, effect->EffectIndex))
         {
             immuneToAllEffects = false;
             break;
         }
     }
 
     if (immuneToAllEffects) //Return immune only if the target is immune to all spell effects.
         return true;
 
     if (spellInfo->Id != 42292 && spellInfo->Id != 59752)
     {
         SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
         for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
         {
             SpellInfo const* immuneSpellInfo = sSpellMgr->GetSpellInfo(itr->spellId);
             if ((itr->type & spellInfo->GetSchoolMask())
                 && !(immuneSpellInfo && immuneSpellInfo->IsPositive() && spellInfo->IsPositive())
                 && !spellInfo->CanPierceImmuneAura(immuneSpellInfo))
                 return true;
         }
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsImmunedToSpellEffect	(	SpellInfo const *	spellInfo,
		uint32	index
	)		const

virtual

Reimplemented in Creature, and Totem.

 {
     if (!spellInfo)
         return false;
 
     SpellEffectInfo const* effect = spellInfo->GetEffect(GetMap()->GetDifficultyID(), index);
     if (!effect || !effect->IsEffect())
         return false;
 
     if (spellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY))
         return false;
 
     // If m_immuneToEffect type contain this effect type, IMMUNE effect.
     uint32 eff = effect->Effect;
     SpellImmuneList const& effectList = m_spellImmune[IMMUNITY_EFFECT];
     for (SpellImmuneList::const_iterator itr = effectList.begin(); itr != effectList.end(); ++itr)
         if (itr->type == eff)
             return true;
 
     if (uint32 mechanic = effect->Mechanic)
     {
         SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
         for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
             if (itr->type == mechanic)
                 return true;
     }
 
     if (uint32 aura = effect->ApplyAuraName)
     {
         SpellImmuneList const& list = m_spellImmune[IMMUNITY_STATE];
         for (SpellImmuneList::const_iterator itr = list.begin(); itr != list.end(); ++itr)
             if (itr->type == aura)
                 if (!spellInfo->HasAttribute(SPELL_ATTR3_IGNORE_HIT_RESULT))
                     return true;
 
         // Check for immune to application of harmful magical effects
         AuraEffectList const& immuneAuraApply = GetAuraEffectsByType(SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL);
         for (AuraEffectList::const_iterator iter = immuneAuraApply.begin(); iter != immuneAuraApply.end(); ++iter)
             if (((*iter)->GetMiscValue() & spellInfo->GetSchoolMask()) &&  // Check school
                 !spellInfo->IsPositiveEffect(index))                                  // Harmful
                 return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isInAccessiblePlaceFor ( Creature const * c ) const

 {
     if (IsInWater())
         return c->CanSwim();
     else
         return c->CanWalk() || c->CanFly();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isInBackInMap	(	Unit const *	target,
		float	distance,
		float	arc = `float(M_PI)`
	)		const

 {
     return IsWithinDistInMap(target, distance) && !HasInArc(2 * float(M_PI) - arc, target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsInCombat ( ) const

inline

1584 { return HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT); }

UNIT_FLAG_IN_COMBAT

Definition: Unit.h:692

UNIT_FIELD_FLAGS

Definition: UpdateFields.h:109

Object::HasFlag

bool HasFlag(uint16 index, uint32 flag) const

Definition: Object.cpp:1239

Here is the call graph for this function:

bool Unit::IsInCombatWith ( Unit const * who ) const

 {
     // Check target exists
     if (!who)
         return false;
 
     // Search in threat list
     ObjectGuid guid = who->GetGUID();
     for (ThreatContainer::StorageType::const_iterator i = m_ThreatManager.getThreatList().begin(); i != m_ThreatManager.getThreatList().end(); ++i)
     {
         HostileReference* ref = (*i);
 
         // Return true if the unit matches
         if (ref && ref->getUnitGuid() == guid)
             return true;
     }
 
     // Nothing found, false.
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsInDisallowedMountForm ( ) const

 {
     if (SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(getTransForm()))
         if (transformSpellInfo->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_MOUNTED))
             return false;
 
     if (ShapeshiftForm form = GetShapeshiftForm())
     {
         SpellShapeshiftFormEntry const* shapeshift = sSpellShapeshiftFormStore.LookupEntry(form);
         if (!shapeshift)
             return true;
 
         if (!(shapeshift->Flags & 0x1))
             return true;
     }
 
     if (GetDisplayId() == GetNativeDisplayId())
         return false;
 
     CreatureDisplayInfoEntry const* display = sCreatureDisplayInfoStore.LookupEntry(GetDisplayId());
     if (!display)
         return true;
 
     CreatureDisplayInfoExtraEntry const* displayExtra = sCreatureDisplayInfoExtraStore.LookupEntry(display->ExtendedDisplayInfoID);
     if (!displayExtra)
         return true;
 
     CreatureModelDataEntry const* model = sCreatureModelDataStore.LookupEntry(display->ModelID);
     ChrRacesEntry const* race = sChrRacesStore.LookupEntry(displayExtra->DisplayRaceID);
 
     if (model && !(model->Flags & 0x80))
         if (race && !(race->Flags & 0x4))
             return true;
 
     return false;
 }

Here is the call graph for this function:

bool Unit::IsInFeralForm ( ) const

 {
     ShapeshiftForm form = GetShapeshiftForm();
     return form == FORM_CAT || form == FORM_BEAR;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsInFlight ( ) const

inline

1582 { return HasUnitState(UNIT_STATE_IN_FLIGHT); }

UNIT_STATE_IN_FLIGHT

Definition: Unit.h:558

Unit::HasUnitState

bool HasUnitState(const uint32 f) const

Definition: Unit.h:1395

Here is the caller graph for this function:

bool Unit::isInFrontInMap	(	Unit const *	target,
		float	distance,
		float	arc = `float(M_PI)`
	)		const

 {
     return IsWithinDistInMap(target, distance) && HasInArc(arc, target);
 }

Here is the call graph for this function:

bool Unit::IsInnkeeper ( ) const

inline

1572 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_INNKEEPER); }

UNIT_NPC_FLAG_INNKEEPER

Definition: Unit.h:751

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsInPartyWith ( Unit const * unit ) const

 {
     if (this == unit)
         return true;
 
     const Unit* u1 = GetCharmerOrOwnerOrSelf();
     const Unit* u2 = unit->GetCharmerOrOwnerOrSelf();
     if (u1 == u2)
         return true;
 
     if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER)
         return u1->ToPlayer()->IsInSameGroupWith(u2->ToPlayer());
     else if ((u2->GetTypeId() == TYPEID_PLAYER && u1->GetTypeId() == TYPEID_UNIT && u1->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_TREAT_AS_RAID_UNIT) ||
         (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_UNIT && u2->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_TREAT_AS_RAID_UNIT))
         return true;
     else
         return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsInRaidWith ( Unit const * unit ) const

 {
     if (this == unit)
         return true;
 
     const Unit* u1 = GetCharmerOrOwnerOrSelf();
     const Unit* u2 = unit->GetCharmerOrOwnerOrSelf();
     if (u1 == u2)
         return true;
 
     if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER)
         return u1->ToPlayer()->IsInSameRaidWith(u2->ToPlayer());
     else if ((u2->GetTypeId() == TYPEID_PLAYER && u1->GetTypeId() == TYPEID_UNIT && u1->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_TREAT_AS_RAID_UNIT) ||
         (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_UNIT && u2->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_TREAT_AS_RAID_UNIT))
         return true;
     else
         return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isInRoots ( ) const

inline

1600 { return HasAuraType(SPELL_AURA_MOD_ROOT); }

SPELL_AURA_MOD_ROOT

Definition: SpellAuraDefines.h:86

bool HasAuraType(AuraType auraType) const

Definition: Unit.cpp:4247

bool Unit::IsInWater ( ) const

virtual

 {
     return GetBaseMap()->IsInWater(GetPositionX(), GetPositionY(), GetPositionZ());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsLevitating ( ) const

inline

1667 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MOVEMENTFLAG_DISABLE_GRAVITY

MovementInfo m_movementInfo

Definition: Object.h:612

Definition: Unit.h:785

Here is the caller graph for this function:

virtual bool Unit::IsLoading ( ) const

inlinevirtual

Reimplemented in Pet.

2197 { return false; }

Here is the caller graph for this function:

bool Unit::IsMagnet ( ) const

Todo:: : find a more generic solution

 {
     // Grounding Totem
     if (GetUInt32Value(UNIT_CREATED_BY_SPELL) == 8177) 
         return true;
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsMounted ( ) const

inline

1496 { return HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT); }

UNIT_FLAG_MOUNT

Definition: Unit.h:700

UNIT_FIELD_FLAGS

Definition: UpdateFields.h:109

Object::HasFlag

bool HasFlag(uint16 index, uint32 flag) const

Definition: Object.cpp:1239

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isMoving ( ) const

inline

2186 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_MASK_MOVING); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MovementInfo m_movementInfo

Definition: Object.h:612

MOVEMENTFLAG_MASK_MOVING

Definition: Unit.h:808

Here is the caller graph for this function:

bool Unit::IsNeutralToAll ( ) const

 {
     FactionTemplateEntry const* my_faction = GetFactionTemplateEntry();
     if (!my_faction || !my_faction->Faction)
         return true;
 
     FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->Faction);
     if (raw_faction && raw_faction->ReputationIndex >= 0)
         return false;
 
     return my_faction->IsNeutralToAll();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsNonMeleeSpellCast	(	bool	withDelayed,
		bool	skipChanneled = `false`,
		bool	skipAutorepeat = `false`,
		bool	isAutoshoot = `false`,
		bool	skipInstant = `true`
	)		const

 {
     // We don't do loop here to explicitly show that melee spell is excluded.
     // Maybe later some special spells will be excluded too.
 
     // generic spells are cast when they are not finished and not delayed
     if (m_currentSpells[CURRENT_GENERIC_SPELL] &&
         (m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_FINISHED) &&
         (withDelayed || m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_DELAYED))
     {
         if (!skipInstant || m_currentSpells[CURRENT_GENERIC_SPELL]->GetCastTime())
         {
             if (!isAutoshoot || !(m_currentSpells[CURRENT_GENERIC_SPELL]->m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_RESET_AUTO_ACTIONS)))
                 return true;
         }
     }
     // channeled spells may be delayed, but they are still considered cast
     if (!skipChanneled && m_currentSpells[CURRENT_CHANNELED_SPELL] &&
         (m_currentSpells[CURRENT_CHANNELED_SPELL]->getState() != SPELL_STATE_FINISHED))
     {
         if (!isAutoshoot || !(m_currentSpells[CURRENT_CHANNELED_SPELL]->m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_RESET_AUTO_ACTIONS)))
             return true;
     }
     // autorepeat spells may be finished or delayed, but they are still considered cast
     if (!skipAutorepeat && m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
         return true;
 
     return false;
 }

bool Unit::IsOnVehicle ( const Unit * vehicle ) const

 {
     return m_vehicle && m_vehicle == vehicle->GetVehicleKit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsPet ( ) const

inline

1403 { return (m_unitTypeMask & UNIT_MASK_PET) != 0; }

uint32 m_unitTypeMask

Definition: Unit.h:2307

UNIT_MASK_PET

Definition: Unit.h:862

bool Unit::IsPolymorphed ( ) const

 {
     uint32 transformId = getTransForm();
     if (!transformId)
         return false;
 
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(transformId);
     if (!spellInfo)
         return false;
 
     return spellInfo->GetSpellSpecific() == SPELL_SPECIFIC_MAGE_POLYMORPH;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isPossessed ( ) const

inline

1743 { return HasUnitState(UNIT_STATE_POSSESSED); }

UNIT_STATE_POSSESSED

Definition: Unit.h:566

Unit::HasUnitState

bool HasUnitState(const uint32 f) const

Definition: Unit.h:1395

Here is the caller graph for this function:

bool Unit::isPossessedByPlayer ( ) const

 {
     return HasUnitState(UNIT_STATE_POSSESSED) && GetCharmerGUID().IsPlayer();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isPossessing ( ) const

 {
     if (Unit* u = GetCharm())
         return u->isPossessed();
     else
         return false;
 }

Here is the call graph for this function:

bool Unit::isPossessing ( Unit * u ) const

 {
     return u->isPossessed() && GetCharmGUID() == u->GetGUID();
 }

Here is the call graph for this function:

bool Unit::IsPvP ( ) const

inline

1481 { return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP); }

Definition: UpdateFields.h:146

Object::HasByteFlag

bool HasByteFlag(uint16 index, uint8 offset, uint8 flag) const

Definition: Object.cpp:1298

UNIT_BYTE2_FLAG_PVP

Definition: Unit.h:308

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsQuestGiver ( ) const

inline

1566 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER); }

UNIT_NPC_FLAG_QUESTGIVER

Definition: Unit.h:736

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

AuraEffect * Unit::IsScriptOverriden	(	SpellInfo const *	spell,
		int32	script
	)		const

 {
     AuraEffectList const& auras = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
     {
         if ((*i)->GetMiscValue() == script)
             if ((*i)->IsAffectingSpell(spell))
                 return (*i);
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsServiceProvider ( ) const

 {
     return HasFlag64(UNIT_NPC_FLAGS,
         UNIT_NPC_FLAG_VENDOR | UNIT_NPC_FLAG_TRAINER | UNIT_NPC_FLAG_FLIGHTMASTER |
         UNIT_NPC_FLAG_PETITIONER | UNIT_NPC_FLAG_BATTLEMASTER | UNIT_NPC_FLAG_BANKER |
         UNIT_NPC_FLAG_INNKEEPER | UNIT_NPC_FLAG_SPIRITHEALER |
         UNIT_NPC_FLAG_SPIRITGUIDE | UNIT_NPC_FLAG_TABARDDESIGNER | UNIT_NPC_FLAG_AUCTIONEER);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsSitState ( ) const

 {
     UnitStandStateType s = GetStandState();
     return
         s == UNIT_STAND_STATE_SIT_CHAIR        || s == UNIT_STAND_STATE_SIT_LOW_CHAIR  ||
         s == UNIT_STAND_STATE_SIT_MEDIUM_CHAIR || s == UNIT_STAND_STATE_SIT_HIGH_CHAIR ||
         s == UNIT_STAND_STATE_SIT;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isSpellBlocked	(	Unit *	victim,
		SpellInfo const *	spellProto,
		WeaponAttackType	attackType = `BASE_ATTACK`
	)

 {
     // These spells can't be blocked
     if (spellProto && spellProto->HasAttribute(SPELL_ATTR0_IMPOSSIBLE_DODGE_PARRY_BLOCK))
         return false;
 
     if (victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION) || victim->HasInArc(float(M_PI), this))
     {
         // Check creatures flags_extra for disable block
         if (victim->GetTypeId() == TYPEID_UNIT &&
             victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK)
                 return false;
 
         if (roll_chance_f(victim->GetUnitBlockChanceAgainst(this)))
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsSpellCrit	(	Unit *	victim,
		SpellInfo const *	spellProto,
		SpellSchoolMask	schoolMask,
		WeaponAttackType	attackType = `BASE_ATTACK`
	)		const

 {
     return roll_chance_f(GetUnitSpellCriticalChance(victim, spellProto, schoolMask, attackType));
 }

Here is the call graph for this function:

bool Unit::IsSpiritGuide ( ) const

inline

1574 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITGUIDE); }

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

UNIT_NPC_FLAG_SPIRITGUIDE

Definition: UpdateFields.h:135

Definition: Unit.h:750

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsSpiritHealer ( ) const

inline

1573 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITHEALER); }

UNIT_NPC_FLAG_SPIRITHEALER

Definition: Unit.h:749

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

UNIT_NPC_FLAG_SPIRITHEALER

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsSpiritService ( ) const

inline

1579 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITHEALER | UNIT_NPC_FLAG_SPIRITGUIDE); }

Definition: Unit.h:749

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

UNIT_NPC_FLAG_SPIRITGUIDE

Definition: UpdateFields.h:135

Definition: Unit.h:750

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsSplineEnabled ( ) const

 {
     return movespline->Initialized() && !movespline->Finalized();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsStandState ( ) const

 {
     UnitStandStateType s = GetStandState();
     return !IsSitState() && s != UNIT_STAND_STATE_SLEEP && s != UNIT_STAND_STATE_KNEEL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsStopped ( ) const

inline

2104 { return !(HasUnitState(UNIT_STATE_MOVING)); }

UNIT_STATE_MOVING

Definition: Unit.h:586

Unit::HasUnitState

bool HasUnitState(const uint32 f) const

Definition: Unit.h:1395

Here is the caller graph for this function:

bool Unit::IsSummon ( ) const

inline

1401 { return (m_unitTypeMask & UNIT_MASK_SUMMON) != 0; }

UNIT_MASK_SUMMON

Definition: Unit.h:858

UNIT_NPC_FLAG_TABARDDESIGNER

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

bool Unit::IsTabardDesigner ( ) const

inline

1575 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_TABARDDESIGNER); }

Definition: Unit.h:754

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

bool Unit::isTargetableForAttack ( bool checkFakeDeath = true ) const

 {
     if (!IsAlive())
         return false;
 
     if (HasFlag(UNIT_FIELD_FLAGS,
         UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_IMMUNE_TO_PC))
         return false;
 
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->IsGameMaster())
         return false;
 
     return !HasUnitState(UNIT_STATE_UNATTACKABLE) && (!checkFakeDeath || !HasUnitState(UNIT_STATE_DIED));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsTaxi ( ) const

inline

1568 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_FLIGHTMASTER); }

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

UNIT_NPC_FLAG_FLIGHTMASTER

Definition: UpdateFields.h:135

Definition: Unit.h:748

Here is the call graph for this function:

bool Unit::IsTotem ( ) const

inline

1405 { return (m_unitTypeMask & UNIT_MASK_TOTEM) != 0; }

uint32 m_unitTypeMask

Definition: Unit.h:2307

UNIT_MASK_TOTEM

Definition: Unit.h:861

Here is the caller graph for this function:

bool Unit::IsTrainer ( ) const

inline

1565 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_TRAINER); }

UNIT_NPC_FLAG_TRAINER

Definition: Unit.h:739

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsTriggeredAtSpellProcEvent	(	Unit *	victim,
		Aura *	aura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procExtra,
		WeaponAttackType	attType,
		bool	isVictim,
		bool	active,
		SpellProcEventEntry const *&	spellProcEvent
	)

private

 {
     SpellInfo const* spellProto = aura->GetSpellInfo();
 
     // let the aura be handled by new proc system if it has new entry
     if (sSpellMgr->GetSpellProcEntry(spellProto->Id))
         return false;
 
     // Get proc Event Entry
     spellProcEvent = sSpellMgr->GetSpellProcEvent(spellProto->Id);
 
     // Get EventProcFlag
     uint32 EventProcFlag;
     if (spellProcEvent && spellProcEvent->procFlags) // if exist get custom spellProcEvent->procFlags
         EventProcFlag = spellProcEvent->procFlags;
     else
         EventProcFlag = spellProto->ProcFlags;       // else get from spell proto
     // Continue if no trigger exist
     if (!EventProcFlag)
         return false;
 
     // Additional checks for triggered spells (ignore trap casts)
     if (procExtra & PROC_EX_INTERNAL_TRIGGERED && !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION))
     {
         if (!spellProto->HasAttribute(SPELL_ATTR3_CAN_PROC_WITH_TRIGGERED))
             return false;
     }
 
     // Check spellProcEvent data requirements
     if (!sSpellMgr->IsSpellProcEventCanTriggeredBy(spellProto, spellProcEvent, EventProcFlag, procSpell, procFlag, procExtra, active))
         return false;
     // In most cases req get honor or XP from kill
     if (EventProcFlag & PROC_FLAG_KILL && GetTypeId() == TYPEID_PLAYER)
     {
         bool allow = false;
 
         if (victim)
             allow = ToPlayer()->isHonorOrXPTarget(victim);
 
         // Shadow Word: Death - can trigger from every kill
         if (aura->GetId() == 32409)
             allow = true;
         if (!allow)
             return false;
     }
     // Aura added by spell can`t trigger from self (prevent drop charges/do triggers)
     // But except periodic and kill triggers (can triggered from self)
     if (procSpell && procSpell->Id == spellProto->Id
         && !(spellProto->ProcFlags&(PROC_FLAG_TAKEN_PERIODIC | PROC_FLAG_KILL)))
         return false;
 
     // Check if current equipment allows aura to proc
     if (!isVictim && GetTypeId() == TYPEID_PLAYER)
     {
         Player* player = ToPlayer();
         if (spellProto->EquippedItemClass == ITEM_CLASS_WEAPON)
         {
             Item* item = NULL;
             if (attType == BASE_ATTACK || attType == RANGED_ATTACK)
                 item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
             else if (attType == OFF_ATTACK)
                 item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
 
             if (player->IsInFeralForm())
                 return false;
 
             if (!item || item->IsBroken() || item->GetTemplate()->GetClass() != ITEM_CLASS_WEAPON || !((1 << item->GetTemplate()->GetSubClass()) & spellProto->EquippedItemSubClassMask))
                 return false;
         }
         else if (spellProto->EquippedItemClass == ITEM_CLASS_ARMOR)
         {
             // Check if player is wearing shield
             Item* item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
             if (!item || item->IsBroken() || item->GetTemplate()->GetClass() != ITEM_CLASS_ARMOR || !((1 << item->GetTemplate()->GetSubClass()) & spellProto->EquippedItemSubClassMask))
                 return false;
         }
     }
     // Get chance from spell
     float chance = float(spellProto->ProcChance);
     // If in spellProcEvent exist custom chance, chance = spellProcEvent->customChance;
     if (spellProcEvent && spellProcEvent->customChance)
         chance = spellProcEvent->customChance;
     // If PPM exist calculate chance from PPM
     if (spellProcEvent && spellProcEvent->ppmRate != 0)
     {
         if (!isVictim)
         {
             uint32 weaponSpeed = GetAttackTime(attType);
             chance = GetPPMProcChance(weaponSpeed, spellProcEvent->ppmRate, spellProto);
         }
         else if (victim)
         {
             uint32 weaponSpeed = victim->GetAttackTime(attType);
             chance = victim->GetPPMProcChance(weaponSpeed, spellProcEvent->ppmRate, spellProto);
         }
     }
     // Apply chance modifer aura
     if (Player* modOwner = GetSpellModOwner())
     {
         modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CHANCE_OF_SUCCESS, chance);
     }
     return roll_chance_f(chance);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::isTurning ( ) const

inline

2187 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_MASK_TURNING); }

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

MOVEMENTFLAG_MASK_TURNING

MovementInfo m_movementInfo

Definition: Object.h:612

Definition: Unit.h:813

bool Unit::IsUnderWater ( ) const

virtual

 {
     return GetBaseMap()->IsUnderWater(GetPositionX(), GetPositionY(), GetPositionZ());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsValidAssistTarget ( Unit const * target ) const

 {
     return _IsValidAssistTarget(target, NULL);
 }

Here is the call graph for this function:

bool Unit::IsValidAttackTarget ( Unit const * target ) const

 {
     return _IsValidAttackTarget(target, NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsVehicle ( ) const

inline

1406 { return (m_unitTypeMask & UNIT_MASK_VEHICLE) != 0; }

UNIT_MASK_VEHICLE

Definition: Unit.h:863

uint32 m_unitTypeMask

Definition: Unit.h:2307

Here is the caller graph for this function:

bool Unit::IsVendor ( ) const

inline

1564 { return HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_VENDOR); }

UNIT_NPC_FLAG_VENDOR

Definition: Unit.h:742

bool HasFlag64(uint16 index, uint64 flag) const

Definition: Object.cpp:1327

Definition: UpdateFields.h:135

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsVisible ( ) const

 {
     return (m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GM) > SEC_PLAYER) ? false : true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsWalking ( ) const

inline

1668 { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING); }

MOVEMENTFLAG_WALKING

Definition: Unit.h:784

bool HasMovementFlag(uint32 flag) const

Definition: Object.h:330

RedirectThreatInfo::ModifyThreatPct

MovementInfo m_movementInfo

Definition: Object.h:612

Here is the caller graph for this function:

bool Unit::IsWithinCombatRange	(	const Unit *	obj,
		float	dist2compare
	)		const

 {
     if (!obj || !IsInMap(obj) || !IsInPhase(obj))
         return false;
 
     float dx = GetPositionX() - obj->GetPositionX();
     float dy = GetPositionY() - obj->GetPositionY();
     float dz = GetPositionZ() - obj->GetPositionZ();
     float distsq = dx * dx + dy * dy + dz * dz;
 
     float sizefactor = GetCombatReach() + obj->GetCombatReach();
     float maxdist = dist2compare + sizefactor;
 
     return distsq < maxdist * maxdist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::IsWithinMeleeRange	(	const Unit *	obj,
		float	dist = `MELEE_RANGE`
	)		const

 {
     if (!obj || !IsInMap(obj) || !IsInPhase(obj))
         return false;
 
     float dx = GetPositionX() - obj->GetPositionX();
     float dy = GetPositionY() - obj->GetPositionY();
     float dz = GetPositionZMinusOffset() - obj->GetPositionZMinusOffset();
     float distsq = dx*dx + dy*dy + dz*dz;
 
     float sizefactor = GetMeleeReach() + obj->GetMeleeReach();
     float maxdist = dist + sizefactor;
 
     return distsq < maxdist * maxdist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::JumpTo	(	float	speedXY,
		float	speedZ,
		bool	forward = `true`
	)

 {
     float angle = forward ? 0 : float(M_PI);
     if (GetTypeId() == TYPEID_UNIT)
         GetMotionMaster()->MoveJumpTo(angle, speedXY, speedZ);
     else
     {
         float vcos = std::cos(angle+GetOrientation());
         float vsin = std::sin(angle+GetOrientation());
         SendMoveKnockBack(ToPlayer(), speedXY, -speedZ, vcos, vsin);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::JumpTo	(	WorldObject *	obj,
		float	speedZ,
		bool	withOrientation = `false`
	)

 {
     float x, y, z;
     obj->GetContactPoint(this, x, y, z);
     float speedXY = GetExactDist2d(x, y) * 10.0f / speedZ;
     GetMotionMaster()->MoveJump(x, y, z, GetAngle(obj), speedXY, speedZ, EVENT_JUMP, withOrientation);
 }

Here is the call graph for this function:

void Unit::Kill	(	Unit *	victim,
		bool	durabilityLoss = `true`
	)

Todo:: do instance binding anyway if the charmer/owner is offline

 {
     // Prevent killing unit twice (and giving reward from kill twice)
     if (!victim->GetHealth())
         return;
 
     // find player: owner of controlled `this` or `this` itself maybe
     Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
     Creature* creature = victim->ToCreature();
 
     bool isRewardAllowed = true;
     if (creature)
     {
         isRewardAllowed = creature->IsDamageEnoughForLootingAndReward();
         if (!isRewardAllowed)
             creature->SetLootRecipient(NULL);
     }
 
     if (isRewardAllowed && creature && creature->GetLootRecipient())
         player = creature->GetLootRecipient();
 
     // Reward player, his pets, and group/raid members
     // call kill spell proc event (before real die and combat stop to triggering auras removed at death/combat stop)
     if (isRewardAllowed && player && player != victim)
     {
         WorldPackets::Party::PartyKillLog partyKillLog;
         partyKillLog.Player = player->GetGUID();
         partyKillLog.Victim = victim->GetGUID();
 
         Player* looter = player;
         Group* group = player->GetGroup();
         bool hasLooterGuid = false;
 
         if (group)
         {
             group->BroadcastPacket(partyKillLog.Write(), group->GetMemberGroup(player->GetGUID()) != 0);
 
             if (creature)
             {
                 group->UpdateLooterGuid(creature, true);
                 if (!group->GetLooterGuid().IsEmpty())
                 {
                     looter = ObjectAccessor::FindPlayer(group->GetLooterGuid());
                     if (looter)
                     {
                         hasLooterGuid = true;
                         creature->SetLootRecipient(looter);   // update creature loot recipient to the allowed looter.
                     }
                 }
             }
         }
         else
         {
             player->SendDirectMessage(partyKillLog.Write());
 
             if (creature)
             {
                 WorldPackets::Loot::LootList lootList;
                 lootList.Owner = creature->GetGUID();
 
                 player->SendMessageToSet(lootList.Write(), true);
             }
         }
 
         // Generate loot before updating looter
         if (creature)
         {
             Loot* loot = &creature->loot;
 
             loot->clear();
             if (uint32 lootid = creature->GetCreatureTemplate()->lootid)
                 loot->FillLoot(lootid, LootTemplates_Creature, looter, false, false, creature->GetLootMode());
 
             loot->generateMoneyLoot(creature->GetCreatureTemplate()->mingold, creature->GetCreatureTemplate()->maxgold);
 
             if (group)
             {
                 if (hasLooterGuid)
                     group->SendLooter(creature, looter);
                 else
                     group->SendLooter(creature, NULL);
 
                 // Update round robin looter only if the creature had loot
                 if (!loot->empty())
                     group->UpdateLooterGuid(creature);
             }
         }
 
         player->RewardPlayerAndGroupAtKill(victim, false);
     }
 
     // Do KILL and KILLED procs. KILL proc is called only for the unit who landed the killing blow (and its owner - for pets and totems) regardless of who tapped the victim
     if (IsPet() || IsTotem())
         if (Unit* owner = GetOwner())
             owner->ProcDamageAndSpell(victim, PROC_FLAG_KILL, PROC_FLAG_NONE, PROC_EX_NONE, 0);
 
     if (!victim->IsCritter())
         ProcDamageAndSpell(victim, PROC_FLAG_KILL, PROC_FLAG_KILLED, PROC_EX_NONE, 0);
 
     // Proc auras on death - must be before aura/combat remove
     victim->ProcDamageAndSpell(NULL, PROC_FLAG_DEATH, PROC_FLAG_NONE, PROC_EX_NONE, 0, BASE_ATTACK, 0);
 
     // update get killing blow achievements, must be done before setDeathState to be able to require auras on target
     // and before Spirit of Redemption as it also removes auras
     if (Player* killerPlayer = GetCharmerOrOwnerPlayerOrPlayerItself())
         killerPlayer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS, 1, 0, 0, victim);
 
     // if talent known but not triggered (check priest class for speedup check)
     bool spiritOfRedemption = false;
     if (victim->GetTypeId() == TYPEID_PLAYER && victim->getClass() == CLASS_PRIEST)
     {
         AuraEffectList const& dummyAuras = victim->GetAuraEffectsByType(SPELL_AURA_DUMMY);
         for (AuraEffectList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
         {
             if ((*itr)->GetSpellInfo()->SpellIconID == 1654)
             {
                 AuraEffect const* aurEff = *itr;
                 // save value before aura remove
                 uint32 ressSpellId = victim->GetUInt32Value(PLAYER_SELF_RES_SPELL);
                 if (!ressSpellId)
                     ressSpellId = victim->ToPlayer()->GetResurrectionSpellId();
                 // Remove all expected to remove at death auras (most important negative case like DoT or periodic triggers)
                 victim->RemoveAllAurasOnDeath();
                 // restore for use at real death
                 victim->SetUInt32Value(PLAYER_SELF_RES_SPELL, ressSpellId);
 
                 // FORM_SPIRITOFREDEMPTION and related auras
                 victim->CastSpell(victim, 27827, true, NULL, aurEff);
                 spiritOfRedemption = true;
                 break;
             }
         }
     }
 
     if (!spiritOfRedemption)
     {
         TC_LOG_DEBUG("entities.unit", "SET JUST_DIED");
         victim->setDeathState(JUST_DIED);
     }
 
     // Inform pets (if any) when player kills target)
     // MUST come after victim->setDeathState(JUST_DIED); or pet next target
     // selection will get stuck on same target and break pet react state
     if (player)
     {
         Pet* pet = player->GetPet();
         if (pet && pet->IsAlive() && pet->isControlled())
             pet->AI()->KilledUnit(victim);
     }
 
     // 10% durability loss on death
     // clean InHateListOf
     if (Player* plrVictim = victim->ToPlayer())
     {
         // remember victim PvP death for corpse type and corpse reclaim delay
         // at original death (not at SpiritOfRedemtionTalent timeout)
         plrVictim->SetPvPDeath(player != NULL);
 
         // only if not player and not controlled by player pet. And not at BG
         if ((durabilityLoss && !player && !victim->ToPlayer()->InBattleground()) || (player && sWorld->getBoolConfig(CONFIG_DURABILITY_LOSS_IN_PVP)))
         {
             double baseLoss = sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH);
             uint32 loss = uint32(baseLoss - (baseLoss * plrVictim->GetTotalAuraMultiplier(SPELL_AURA_MOD_DURABILITY_LOSS)));
             TC_LOG_DEBUG("entities.unit", "We are dead, losing %u percent durability", loss);
             // Durability loss is calculated more accurately again for each item in Player::DurabilityLoss
             plrVictim->DurabilityLossAll(baseLoss, false);
             // durability lost message
             SendDurabilityLoss(plrVictim, loss);
         }
         // Call KilledUnit for creatures
         if (GetTypeId() == TYPEID_UNIT && IsAIEnabled)
             ToCreature()->AI()->KilledUnit(victim);
 
         // last damage from non duel opponent or opponent controlled creature
         if (plrVictim->duel)
         {
             plrVictim->duel->opponent->CombatStopWithPets(true);
             plrVictim->CombatStopWithPets(true);
             plrVictim->DuelComplete(DUEL_INTERRUPTED);
         }
     }
     else                                                // creature died
     {
         TC_LOG_DEBUG("entities.unit", "DealDamageNotPlayer");
 
         if (!creature->IsPet())
         {
             creature->DeleteThreatList();
 
             // must be after setDeathState which resets dynamic flags
             if (!creature->loot.isLooted())
                 creature->SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
             else
                 creature->AllLootRemovedFromCorpse();
         }
 
         // Call KilledUnit for creatures, this needs to be called after the lootable flag is set
         if (GetTypeId() == TYPEID_UNIT && IsAIEnabled)
             ToCreature()->AI()->KilledUnit(victim);
 
         // Call creature just died function
         if (creature->IsAIEnabled)
             creature->AI()->JustDied(this);
 
         if (TempSummon* summon = creature->ToTempSummon())
             if (Unit* summoner = summon->GetSummoner())
                 if (summoner->ToCreature() && summoner->IsAIEnabled)
                     summoner->ToCreature()->AI()->SummonedCreatureDies(creature, this);
 
         // Dungeon specific stuff, only applies to players killing creatures
         if (creature->GetInstanceId())
         {
             Map* instanceMap = creature->GetMap();
             Player* creditedPlayer = GetCharmerOrOwnerPlayerOrPlayerItself();
 
             if (instanceMap->IsDungeon() && creditedPlayer)
             {
                 if (instanceMap->IsRaidOrHeroicDungeon())
                 {
                     if (creature->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_INSTANCE_BIND)
                         ((InstanceMap*)instanceMap)->PermBindAllPlayers(creditedPlayer);
                 }
                 else
                 {
                     // the reset time is set but not added to the scheduler
                     // until the players leave the instance
                     time_t resettime = creature->GetRespawnTimeEx() + 2 * HOUR;
                     if (InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(creature->GetInstanceId()))
                         if (save->GetResetTime() < resettime) save->SetResetTime(resettime);
                 }
             }
         }
     }
 
     // outdoor pvp things, do these after setting the death state, else the player activity notify won't work... doh...
     // handle player kill only if not suicide (spirit of redemption for example)
     if (player && this != victim)
     {
         if (OutdoorPvP* pvp = player->GetOutdoorPvP())
             pvp->HandleKill(player, victim);
 
         if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(player->GetZoneId()))
             bf->HandleKill(player, victim);
     }
 
     //if (victim->GetTypeId() == TYPEID_PLAYER)
     //    if (OutdoorPvP* pvp = victim->ToPlayer()->GetOutdoorPvP())
     //        pvp->HandlePlayerActivityChangedpVictim->ToPlayer();
 
     // battleground things (do this at the end, so the death state flag will be properly set to handle in the bg->handlekill)
     if (player && player->InBattleground())
     {
         if (Battleground* bg = player->GetBattleground())
         {
             if (Player* playerVictim = victim->ToPlayer())
                 bg->HandleKillPlayer(playerVictim, player);
             else
                 bg->HandleKillUnit(victim->ToCreature(), player);
         }
     }
 
     // achievement stuff
     if (victim->GetTypeId() == TYPEID_PLAYER)
     {
         if (GetTypeId() == TYPEID_UNIT)
             victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE, GetEntry());
         else if (GetTypeId() == TYPEID_PLAYER && victim != this)
             victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER, 1, ToPlayer()->GetTeam());
     }
 
     // Hook for OnPVPKill Event
     if (Player* killerPlr = ToPlayer())
     {
         if (Player* killedPlr = victim->ToPlayer())
             sScriptMgr->OnPVPKill(killerPlr, killedPlr);
         else if (Creature* killedCre = victim->ToCreature())
             sScriptMgr->OnCreatureKill(killerPlr, killedCre);
     }
     else if (Creature* killerCre = ToCreature())
     {
         if (Player* killed = victim->ToPlayer())
             sScriptMgr->OnPlayerKilledByCreature(killerCre, killed);
     }
 }

Here is the caller graph for this function:

void Unit::KillSelf ( bool durabilityLoss = true )

inline

1515 { Kill(this, durabilityLoss); }

Unit::Kill

void Kill(Unit *victim, bool durabilityLoss=true)

Definition: Unit.cpp:13513

Here is the caller graph for this function:

void Unit::KnockbackFrom	(	float	x,
		float	y,
		float	speedXY,
		float	speedZ
	)

 {
     Player* player = ToPlayer();
     if (!player)
     {
         if (Unit* charmer = GetCharmer())
         {
             player = charmer->ToPlayer();
             if (player && player->m_mover != this)
                 player = NULL;
         }
     }
 
     if (!player)
         GetMotionMaster()->MoveKnockbackFrom(x, y, speedXY, speedZ);
     else
     {
         float vcos, vsin;
         GetSinCos(x, y, vsin, vcos);
         SendMoveKnockBack(player, speedXY, -speedZ, vcos, vsin);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellMissInfo Unit::MagicSpellHitResult	(	Unit *	victim,
		SpellInfo const *	spellInfo
	)

Todo:: need use unit spell resistances in calculations

 {
     // Can`t miss on dead target (on skinning for example)
     if ((!victim->IsAlive() && victim->GetTypeId() != TYPEID_PLAYER) || spellInfo->HasAttribute(SPELL_ATTR3_IGNORE_HIT_RESULT))
         return SPELL_MISS_NONE;
 
     SpellSchoolMask schoolMask = spellInfo->GetSchoolMask();
     // PvP - PvE spell misschances per leveldif > 2
     int32 lchance = victim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
     int32 thisLevel = getLevelForTarget(victim);
     if (GetTypeId() == TYPEID_UNIT && ToCreature()->IsTrigger())
         thisLevel = std::max<int32>(thisLevel, spellInfo->SpellLevel);
     int32 leveldif = int32(victim->getLevelForTarget(this)) - thisLevel;
     int32 levelBasedHitDiff = leveldif;
 
     // Base hit chance from attacker and victim levels
     int32 modHitChance = 100;
     if (levelBasedHitDiff >= 0)
     {
         if (victim->GetTypeId() != TYPEID_PLAYER)
         {
             modHitChance = 94 - 3 * std::min(levelBasedHitDiff, 3);
             levelBasedHitDiff -= 3;
         }
         else
         {
             modHitChance = 96 - std::min(levelBasedHitDiff, 2);
             levelBasedHitDiff -= 2;
         }
         if (levelBasedHitDiff > 0)
             modHitChance -= lchance * std::min(levelBasedHitDiff, 7);
     }
     else
         modHitChance = 97 - levelBasedHitDiff;
 
     // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_RESIST_MISS_CHANCE, modHitChance);
 
     // Spells with SPELL_ATTR3_IGNORE_HIT_RESULT will ignore target's avoidance effects
     if (!spellInfo->HasAttribute(SPELL_ATTR3_IGNORE_HIT_RESULT))
     {
         // Chance hit from victim SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE auras
         modHitChance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
     }
 
     int32 HitChance = modHitChance * 100;
     // Increase hit chance from attacker SPELL_AURA_MOD_SPELL_HIT_CHANCE and attacker ratings
     HitChance += int32(m_modSpellHitChance * 100.0f);
 
     RoundToInterval(HitChance, 100, 10000);
 
     int32 tmp = 10000 - HitChance;
 
     int32 rand = irand(0, 10000);
 
     if (rand < tmp)
         return SPELL_MISS_MISS;
 
     // Chance resist mechanic (select max value from every mechanic spell effect)
     int32 resist_chance = victim->GetMechanicResistChance(spellInfo) * 100;
     tmp += resist_chance;
 
     // Roll chance
     if (rand < tmp)
         return SPELL_MISS_RESIST;
 
     // cast by caster in front of victim
     if (victim->HasInArc(float(M_PI), this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
     {
         int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
         tmp += deflect_chance;
         if (rand < tmp)
             return SPELL_MISS_DEFLECT;
     }
 
     return SPELL_MISS_NONE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::MeleeDamageBonusDone	(	Unit *	pVictim,
		uint32	damage,
		WeaponAttackType	attType,
		SpellInfo const *	spellProto = `NULL`
	)

 {
     if (!victim || pdamage == 0)
         return 0;
 
     uint32 creatureTypeMask = victim->GetCreatureTypeMask();
 
     // Done fixed damage bonus auras
     int32 DoneFlatBenefit = 0;
 
     // ..done
     AuraEffectList const& mDamageDoneCreature = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
     for (AuraEffectList::const_iterator i = mDamageDoneCreature.begin(); i != mDamageDoneCreature.end(); ++i)
         if (creatureTypeMask & uint32((*i)->GetMiscValue()))
             DoneFlatBenefit += (*i)->GetAmount();
 
     // ..done
     // SPELL_AURA_MOD_DAMAGE_DONE included in weapon damage
 
     // ..done (base at attack power for marked target and base at attack power for creature type)
     int32 APbonus = 0;
 
     if (attType == RANGED_ATTACK)
     {
         APbonus += victim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
 
         // ..done (base at attack power and creature type)
         AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS);
         for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin(); i != mCreatureAttackPower.end(); ++i)
             if (creatureTypeMask & uint32((*i)->GetMiscValue()))
                 APbonus += (*i)->GetAmount();
     }
     else
     {
         APbonus += victim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
 
         // ..done (base at attack power and creature type)
         AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS);
         for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin(); i != mCreatureAttackPower.end(); ++i)
             if (creatureTypeMask & uint32((*i)->GetMiscValue()))
                 APbonus += (*i)->GetAmount();
     }
 
     if (APbonus != 0)                                       // Can be negative
     {
         bool normalized = false;
         if (spellProto)
             for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
                 if (effect && effect->Effect == SPELL_EFFECT_NORMALIZED_WEAPON_DMG)
                 {
                     normalized = true;
                     break;
                 }
         DoneFlatBenefit += int32(APbonus/14.0f * GetAPMultiplier(attType, normalized));
     }
 
     // Done total percent damage auras
     float DoneTotalMod = 1.0f;
 
     // Some spells don't benefit from pct done mods
     if (spellProto)
         if (!spellProto->HasAttribute(SPELL_ATTR6_NO_DONE_PCT_DAMAGE_MODS))
         {
             AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
             for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
             {
                 if ((*i)->GetMiscValue() & spellProto->GetSchoolMask() && !(spellProto->GetSchoolMask() & SPELL_SCHOOL_MASK_NORMAL))
                 {
                     if ((*i)->GetSpellInfo()->EquippedItemClass == -1)
                         AddPct(DoneTotalMod, (*i)->GetAmount());
                     else if (!((*i)->GetSpellInfo()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK) && ((*i)->GetSpellInfo()->EquippedItemSubClassMask == 0))
                         AddPct(DoneTotalMod, (*i)->GetAmount());
                     else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellInfo()))
                         AddPct(DoneTotalMod, (*i)->GetAmount());
                 }
             }
         }
 
     AuraEffectList const& mDamageDoneVersus = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
     for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin(); i != mDamageDoneVersus.end(); ++i)
         if (creatureTypeMask & uint32((*i)->GetMiscValue()))
             AddPct(DoneTotalMod, (*i)->GetAmount());
 
     // bonus against aurastate
     AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
     for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
         if (victim->HasAuraState(AuraStateType((*i)->GetMiscValue())))
             AddPct(DoneTotalMod, (*i)->GetAmount());
 
     // Add SPELL_AURA_MOD_DAMAGE_DONE_FOR_MECHANIC percent bonus
     if (spellProto)
         AddPct(DoneTotalMod, GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_DAMAGE_DONE_FOR_MECHANIC, spellProto->Mechanic));
 
     // done scripted mod (take it from owner)
     // Unit* owner = GetOwner() ? GetOwner() : this;
     // AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
 
     float tmpDamage = float(int32(pdamage) + DoneFlatBenefit) * DoneTotalMod;
 
     // apply spellmod to Done damage
     if (spellProto)
         if (Player* modOwner = GetSpellModOwner())
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_DAMAGE, tmpDamage);
 
     // bonus result can be negative
     return uint32(std::max(tmpDamage, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::MeleeDamageBonusTaken	(	Unit *	attacker,
		uint32	pdamage,
		WeaponAttackType	attType,
		SpellInfo const *	spellProto = `NULL`
	)

 {
     if (pdamage == 0)
         return 0;
 
     int32 TakenFlatBenefit = 0;
     float TakenTotalCasterMod = 0.0f;
 
     // get all auras from caster that allow the spell to ignore resistance (sanctified wrath)
     SpellSchoolMask attackSchoolMask = spellProto ? spellProto->GetSchoolMask() : SPELL_SCHOOL_MASK_NORMAL;
     AuraEffectList const& IgnoreResistAuras = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
     for (AuraEffectList::const_iterator i = IgnoreResistAuras.begin(); i != IgnoreResistAuras.end(); ++i)
     {
         if ((*i)->GetMiscValue() & attackSchoolMask)
             TakenTotalCasterMod += (float((*i)->GetAmount()));
     }
 
     // ..taken
     AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
     for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
         if ((*i)->GetMiscValue() & attacker->GetMeleeDamageSchoolMask())
             TakenFlatBenefit += (*i)->GetAmount();
 
     if (attType != RANGED_ATTACK)
         TakenFlatBenefit += GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
     else
         TakenFlatBenefit += GetTotalAuraModifier(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
 
     // Taken total percent damage auras
     float TakenTotalMod = 1.0f;
 
     // ..taken
     TakenTotalMod *= GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, attacker->GetMeleeDamageSchoolMask());
 
     // .. taken pct (special attacks)
     if (spellProto)
     {
         // From caster spells
         AuraEffectList const& mOwnerTaken = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_FROM_CASTER);
         for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
             if ((*i)->GetCasterGUID() == attacker->GetGUID() && (*i)->IsAffectingSpell(spellProto))
                 AddPct(TakenTotalMod, (*i)->GetAmount());
 
         // Mod damage from spell mechanic
         uint32 mechanicMask = spellProto->GetAllEffectsMechanicMask();
 
         // Shred, Maul - "Effects which increase Bleed damage also increase Shred damage"
         if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID && spellProto->SpellFamilyFlags[0] & 0x00008800)
             mechanicMask |= (1<<MECHANIC_BLEED);
 
         if (mechanicMask)
         {
             AuraEffectList const& mDamageDoneMechanic = GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
             for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin(); i != mDamageDoneMechanic.end(); ++i)
                 if (mechanicMask & uint32(1<<((*i)->GetMiscValue())))
                     AddPct(TakenTotalMod, (*i)->GetAmount());
         }
     }
 
     // .. taken pct: dummy auras
     AuraEffectList const& mDummyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
     for (AuraEffectList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
     {
         switch ((*i)->GetSpellInfo()->SpellIconID)
         {
             // Cheat Death
             case 2109:
                 if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
                 {
                     if (Player* player = ToPlayer())
                     {
                         float mod = player->GetRatingBonusValue(CR_RESILIENCE_PLAYER_DAMAGE_TAKEN) * (-8.0f);
                         AddPct(TakenTotalMod, std::max(mod, float((*i)->GetAmount())));
                     }
                 }
                 break;
         }
     }
 
     // .. taken pct: class scripts
     //*AuraEffectList const& mclassScritAuras = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     //for (AuraEffectList::const_iterator i = mclassScritAuras.begin(); i != mclassScritAuras.end(); ++i)
     //{
     //    switch ((*i)->GetMiscValue())
     //    {
     //    }
     //}*/
 
     if (attType != RANGED_ATTACK)
     {
         AuraEffectList const& mModMeleeDamageTakenPercent = GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
         for (AuraEffectList::const_iterator i = mModMeleeDamageTakenPercent.begin(); i != mModMeleeDamageTakenPercent.end(); ++i)
             AddPct(TakenTotalMod, (*i)->GetAmount());
     }
     else
     {
         AuraEffectList const& mModRangedDamageTakenPercent = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
         for (AuraEffectList::const_iterator i = mModRangedDamageTakenPercent.begin(); i != mModRangedDamageTakenPercent.end(); ++i)
             AddPct(TakenTotalMod, (*i)->GetAmount());
     }
 
     float tmpDamage = 0.0f;
 
     if (TakenTotalCasterMod)
     {
         if (TakenFlatBenefit < 0)
         {
             if (TakenTotalMod < 1)
                 tmpDamage = ((float(CalculatePct(pdamage, TakenTotalCasterMod) + TakenFlatBenefit) * TakenTotalMod) + CalculatePct(pdamage, TakenTotalCasterMod));
             else
                 tmpDamage = ((float(CalculatePct(pdamage, TakenTotalCasterMod) + TakenFlatBenefit) + CalculatePct(pdamage, TakenTotalCasterMod)) * TakenTotalMod);
         }
         else if (TakenTotalMod < 1)
             tmpDamage = ((CalculatePct(float(pdamage) + TakenFlatBenefit, TakenTotalCasterMod) * TakenTotalMod) + CalculatePct(float(pdamage) + TakenFlatBenefit, TakenTotalCasterMod));
     }
     if (!tmpDamage)
         tmpDamage = (float(pdamage) + TakenFlatBenefit) * TakenTotalMod;
 
     // bonus result can be negative
     return uint32(std::max(tmpDamage, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellMissInfo Unit::MeleeSpellHitResult	(	Unit *	victim,
		SpellInfo const *	spellInfo
	)

 {
     // Spells with SPELL_ATTR3_IGNORE_HIT_RESULT will additionally fully ignore
     // resist and deflect chances
     if (spellInfo->HasAttribute(SPELL_ATTR3_IGNORE_HIT_RESULT))
         return SPELL_MISS_NONE;
 
     WeaponAttackType attType = BASE_ATTACK;
 
     // Check damage class instead of attack type to correctly handle judgements
     // - they are meele, but can't be dodged/parried/deflected because of ranged dmg class
     if (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED)
         attType = RANGED_ATTACK;
 
     uint32 roll = urand(0, 10000);
 
     uint32 missChance = uint32(MeleeSpellMissChance(victim, attType, spellInfo->Id) * 100.0f);
 
     // Roll miss
     uint32 tmp = missChance;
     if (roll < tmp)
         return SPELL_MISS_MISS;
 
     // Chance resist mechanic (select max value from every mechanic spell effect)
     int32 resist_mech = 0;
     // Get effects mechanic and chance
     for (uint8 eff = 0; eff < MAX_SPELL_EFFECTS; ++eff)
     {
         int32 effect_mech = spellInfo->GetEffectMechanic(eff, GetMap()->GetDifficultyID());
         if (effect_mech)
         {
             int32 temp = victim->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
             if (resist_mech < temp * 100)
                 resist_mech = temp * 100;
         }
     }
     // Roll chance
     tmp += resist_mech;
     if (roll < tmp)
         return SPELL_MISS_RESIST;
 
     bool canDodge = true;
     bool canParry = true;
     bool canBlock = spellInfo->HasAttribute(SPELL_ATTR3_BLOCKABLE_SPELL);
 
     // Same spells cannot be parry/dodge
     if (spellInfo->HasAttribute(SPELL_ATTR0_IMPOSSIBLE_DODGE_PARRY_BLOCK))
         return SPELL_MISS_NONE;
 
     // Chance resist mechanic
     int32 resist_chance = victim->GetMechanicResistChance(spellInfo) * 100;
     tmp += resist_chance;
     if (roll < tmp)
         return SPELL_MISS_RESIST;
 
     // Ranged attacks can only miss, resist and deflect
     if (attType == RANGED_ATTACK)
     {
         canParry = false;
         canDodge = false;
 
         // only if in front
         if (victim->HasInArc(float(M_PI), this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
         {
             int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
             tmp += deflect_chance;
             if (roll < tmp)
                 return SPELL_MISS_DEFLECT;
         }
         return SPELL_MISS_NONE;
     }
 
     // Check for attack from behind
     if (!victim->HasInArc(float(M_PI), this))
     {
         if (!victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
         {
             // Can`t dodge from behind in PvP (but its possible in PvE)
             if (victim->GetTypeId() == TYPEID_PLAYER)
                 canDodge = false;
             // Can`t parry or block
             canParry = false;
             canBlock = false;
         }
         else // Only deterrence as of 3.3.5
         {
             if (spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET))
                 canParry = false;
         }
     }
     // Check creatures flags_extra for disable parry
     if (victim->GetTypeId() == TYPEID_UNIT)
     {
         uint32 flagEx = victim->ToCreature()->GetCreatureTemplate()->flags_extra;
         if (flagEx & CREATURE_FLAG_EXTRA_NO_PARRY)
             canParry = false;
         // Check creatures flags_extra for disable block
         if (flagEx & CREATURE_FLAG_EXTRA_NO_BLOCK)
             canBlock = false;
     }
     // Ignore combat result aura
     AuraEffectList const& ignore = GetAuraEffectsByType(SPELL_AURA_IGNORE_COMBAT_RESULT);
     for (AuraEffectList::const_iterator i = ignore.begin(); i != ignore.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(spellInfo))
             continue;
         switch ((*i)->GetMiscValue())
         {
             case MELEE_HIT_DODGE:
                 canDodge = false;
                 break;
             case MELEE_HIT_BLOCK:
                 canBlock = false;
                 break;
             case MELEE_HIT_PARRY:
                 canParry = false;
                 break;
             default:
                 TC_LOG_DEBUG("entities.unit", "Spell %u SPELL_AURA_IGNORE_COMBAT_RESULT has unhandled state %d", (*i)->GetId(), (*i)->GetMiscValue());
                 break;
         }
     }
 
     if (canDodge)
     {
         // Roll dodge
         int32 dodgeChance = int32(victim->GetUnitDodgeChanceAgainst(this) * 100.0f);
         // Reduce enemy dodge chance by SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
         dodgeChance += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
         dodgeChance = int32(float(dodgeChance) * GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
         // Reduce dodge chance by attacker expertise rating
         if (GetTypeId() == TYPEID_PLAYER)
             dodgeChance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
         else
             dodgeChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
         if (dodgeChance < 0)
             dodgeChance = 0;
 
         if (roll < (tmp += dodgeChance))
             return SPELL_MISS_DODGE;
     }
 
     if (canParry)
     {
         // Roll parry
         int32 parryChance = int32(victim->GetUnitParryChanceAgainst(this) * 100.0f);
         // Reduce parry chance by attacker expertise rating
         if (GetTypeId() == TYPEID_PLAYER)
             parryChance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
         else
             parryChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
         if (parryChance < 0)
             parryChance = 0;
 
         tmp += parryChance;
         if (roll < tmp)
             return SPELL_MISS_PARRY;
     }
 
     if (canBlock)
     {
         int32 blockChance = int32(victim->GetUnitBlockChanceAgainst(this) * 100.0f);
         if (blockChance < 0)
             blockChance = 0;
         tmp += blockChance;
 
         if (roll < tmp)
             return SPELL_MISS_BLOCK;
     }
 
     return SPELL_MISS_NONE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::MeleeSpellMissChance	(	Unit const *	victim,
		WeaponAttackType	attType,
		uint32	spellId
	)		const

 {
     //calculate miss chance
     float missChance = victim->GetUnitMissChance(attType);
 
     if (!spellId && haveOffhandWeapon())
         missChance += 19;
 
     // Calculate hit chance
     float hitChance = 100.0f;
 
     // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
     if (spellId)
     {
         if (Player* modOwner = GetSpellModOwner())
             modOwner->ApplySpellMod(spellId, SPELLMOD_RESIST_MISS_CHANCE, hitChance);
     }
 
     missChance += hitChance - 100.0f;
 
     if (attType == RANGED_ATTACK)
         missChance -= m_modRangedHitChance;
     else
         missChance -= m_modMeleeHitChance;
 
     // Limit miss chance from 0 to 60%
     if (missChance < 0.0f)
         return 0.0f;
     if (missChance > 77.0f)
         return 77.0f;
     return missChance;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ModifyAuraState	(	AuraStateType	flag,
		bool	apply
	)

 {
     if (apply)
     {
         if (!HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1)))
         {
             SetFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
             if (GetTypeId() == TYPEID_PLAYER)
             {
                 PlayerSpellMap const& sp_list = 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->IsPassive())
                         continue;
                     if (spellInfo->CasterAuraState == uint32(flag))
                         CastSpell(this, itr->first, true, NULL);
                 }
             }
             else if (Pet* pet = ToCreature()->ToPet())
             {
                 for (PetSpellMap::const_iterator itr = pet->m_spells.begin(); itr != pet->m_spells.end(); ++itr)
                 {
                     if (itr->second.state == PETSPELL_REMOVED)
                         continue;
                     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first);
                     if (!spellInfo || !spellInfo->IsPassive())
                         continue;
                     if (spellInfo->CasterAuraState == uint32(flag))
                         CastSpell(this, itr->first, true, NULL);
                 }
             }
         }
     }
     else
     {
         if (HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1)))
         {
             RemoveFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
 
             if (flag != AURA_STATE_ENRAGE)                  // enrage aura state triggering continues auras
             {
                 Unit::AuraApplicationMap& tAuras = GetAppliedAuras();
                 for (Unit::AuraApplicationMap::iterator itr = tAuras.begin(); itr != tAuras.end();)
                 {
                     SpellInfo const* spellProto = (*itr).second->GetBase()->GetSpellInfo();
                     if (spellProto->CasterAuraState == uint32(flag))
                         RemoveAura(itr);
                     else
                         ++itr;
                 }
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::ModifyHealth ( int32 val )

 {
     int32 gain = 0;
 
     if (dVal == 0)
         return 0;
 
     int32 curHealth = (int32)GetHealth();
 
     int32 val = dVal + curHealth;
     if (val <= 0)
     {
         SetHealth(0);
         return -curHealth;
     }
 
     int32 maxHealth = (int32)GetMaxHealth();
 
     if (val < maxHealth)
     {
         SetHealth(val);
         gain = val - curHealth;
     }
     else if (curHealth != maxHealth)
     {
         SetHealth(maxHealth);
         gain = maxHealth - curHealth;
     }
 
     if (dVal < 0)
     {
         WorldPackets::Combat::HealthUpdate packet;
         packet.Guid = GetGUID();
         packet.Health = GetHealth();
 
         if (Player* player = GetCharmerOrOwnerPlayerOrPlayerItself())
             player->GetSession()->SendPacket(packet.Write());
 
     }
 
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::ModifyPower	(	Powers	power,
		int32	val
	)

 {
     int32 gain = 0;
 
     if (dVal == 0)
         return 0;
 
     int32 curPower = GetPower(power);
 
     int32 val = dVal + curPower;
     if (val <= GetMinPower(power))
     {
         SetPower(power, GetMinPower(power));
         return -curPower;
     }
 
     int32 maxPower = GetMaxPower(power);
 
     if (val < maxPower)
     {
         SetPower(power, val);
         gain = val - curPower;
     }
     else if (curPower != maxPower)
     {
         SetPower(power, maxPower);
         gain = maxPower - curPower;
     }
 
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::ModifyPowerPct	(	Powers	power,
		float	pct,
		bool	apply = `true`
	)

 {
     float amount = (float)GetMaxPower(power);
     ApplyPercentModFloatVar(amount, pct, apply);
 
     return ModifyPower(power, (int32)amount - GetMaxPower(power));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ModifyRedirectThreat ( int32 amount )

inline

2156 { _redirectThreadInfo.ModifyThreatPct(amount); }

void ModifyThreatPct(int32 amount)

Definition: Unit.h:1092

Unit::_redirectThreadInfo

RedirectThreatInfo _redirectThreadInfo

Definition: Unit.h:2350

void Unit::ModSpellCastTime	(	SpellInfo const *	spellProto,
		int32 &	castTime,
		Spell *	spell = `NULL`
	)

 {
     if (!spellInfo || castTime < 0)
         return;
 
     // called from caster
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CASTING_TIME, castTime, spell);
 
     if (!((spellInfo->Attributes & (SPELL_ATTR0_ABILITY | SPELL_ATTR0_TRADESPELL)) || (spellInfo->HasAttribute(SPELL_ATTR3_NO_DONE_BONUS))) &&
         ((GetTypeId() == TYPEID_PLAYER && spellInfo->SpellFamilyName) || GetTypeId() == TYPEID_UNIT))
         castTime = int32(float(castTime) * GetFloatValue(UNIT_MOD_CAST_SPEED));
     else if (spellInfo->HasAttribute(SPELL_ATTR0_REQ_AMMO) && !spellInfo->HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG))
         castTime = int32(float(castTime) * m_modAttackSpeedPct[RANGED_ATTACK]);
     else if (IsPartOfSkillLine(SKILL_COOKING, spellInfo->Id) && HasAura(67556)) // cooking with Chef Hat.
         castTime = 500;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::ModSpellDuration	(	SpellInfo const *	spellProto,
		Unit const *	target,
		int32	duration,
		bool	positive,
		uint32	effectMask
	)

 {
     // don't mod permanent auras duration
     if (duration < 0)
         return duration;
 
     // some auras are not affected by duration modifiers
     if (spellProto->HasAttribute(SPELL_ATTR7_IGNORE_DURATION_MODS))
         return duration;
 
     // cut duration only of negative effects
     if (!positive)
     {
         int32 mechanic = spellProto->GetSpellMechanicMaskByEffectMask(effectMask);
 
         int32 durationMod;
         int32 durationMod_always = 0;
         int32 durationMod_not_stack = 0;
 
         for (uint8 i = 1; i <= MECHANIC_ENRAGED; ++i)
         {
             if (!(mechanic & 1<<i))
                 continue;
             // Find total mod value (negative bonus)
             int32 new_durationMod_always = target->GetTotalAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD, i);
             // Find max mod (negative bonus)
             int32 new_durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK, i);
             // Check if mods applied before were weaker
             if (new_durationMod_always < durationMod_always)
                 durationMod_always = new_durationMod_always;
             if (new_durationMod_not_stack < durationMod_not_stack)
                 durationMod_not_stack = new_durationMod_not_stack;
         }
 
         // Select strongest negative mod
         if (durationMod_always > durationMod_not_stack)
             durationMod = durationMod_not_stack;
         else
             durationMod = durationMod_always;
 
         if (durationMod != 0)
             AddPct(duration, durationMod);
 
         // there are only negative mods currently
         durationMod_always = target->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL, spellProto->Dispel);
         durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL_NOT_STACK, spellProto->Dispel);
 
         durationMod = 0;
         if (durationMod_always > durationMod_not_stack)
             durationMod += durationMod_not_stack;
         else
             durationMod += durationMod_always;
 
         if (durationMod != 0)
             AddPct(duration, durationMod);
     }
     else
     {
         // else positive mods here, there are no currently
         // when there will be, change GetTotalAuraModifierByMiscValue to GetTotalPositiveAuraModifierByMiscValue
 
         // Mixology - duration boost
         if (target->GetTypeId() == TYPEID_PLAYER)
         {
             if (spellProto->SpellFamilyName == SPELLFAMILY_POTION && (
                 sSpellMgr->IsSpellMemberOfSpellGroup(spellProto->Id, SPELL_GROUP_ELIXIR_BATTLE) ||
                 sSpellMgr->IsSpellMemberOfSpellGroup(spellProto->Id, SPELL_GROUP_ELIXIR_GUARDIAN)))
             {
                 SpellEffectInfo const* effect = spellProto->GetEffect(DIFFICULTY_NONE, EFFECT_0);
                 if (target->HasAura(53042) && effect && target->HasSpell(effect->TriggerSpell))
                     duration *= 2;
             }
         }
     }
 
     // Glyphs which increase duration of selfcast buffs
     if (target == this)
     {
         switch (spellProto->SpellFamilyName)
         {
             case SPELLFAMILY_DRUID:
                 if (spellProto->SpellFamilyFlags[0] & 0x100)
                 {
                     // Glyph of Thorns
                     if (AuraEffect* aurEff = GetAuraEffect(57862, 0))
                         duration += aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
                 }
                 break;
         }
     }
     return std::max(duration, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ModSpellDurationTime	(	SpellInfo const *	spellProto,
		int32 &	castTime,
		Spell *	spell = `NULL`
	)

 {
     if (!spellInfo || duration < 0)
         return;
 
     if (spellInfo->IsChanneled() && !spellInfo->HasAttribute(SPELL_ATTR5_HASTE_AFFECT_DURATION))
         return;
 
     // called from caster
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CASTING_TIME, duration, spell);
 
     if (!(spellInfo->HasAttribute(SPELL_ATTR0_ABILITY) || spellInfo->HasAttribute(SPELL_ATTR0_TRADESPELL) || spellInfo->HasAttribute(SPELL_ATTR3_NO_DONE_BONUS)) &&
         ((GetTypeId() == TYPEID_PLAYER && spellInfo->SpellFamilyName) || GetTypeId() == TYPEID_UNIT))
         duration = int32(float(duration) * GetFloatValue(UNIT_MOD_CAST_SPEED));
     else if (spellInfo->HasAttribute(SPELL_ATTR0_REQ_AMMO) && !spellInfo->HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG))
         duration = int32(float(duration) * m_modAttackSpeedPct[RANGED_ATTACK]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::MonsterMoveWithSpeed	(	float	x,
		float	y,
		float	z,
		float	speed,
		bool	generatePath = `false`,
		bool	forceDestination = `false`
	)

 {
     Movement::MoveSplineInit init(this);
     init.MoveTo(x, y, z, generatePath, forceDestination);
     init.SetVelocity(speed);
     init.Launch();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::Mount	(	uint32	mount,
		uint32	vehicleId = `0`,
		uint32	creatureEntry = `0`
	)

 {
     if (mount)
         SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, mount);
 
     SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT);
 
     if (Player* player = ToPlayer())
     {
         // mount as a vehicle
         if (VehicleId)
         {
             if (CreateVehicleKit(VehicleId, creatureEntry))
             {
                 player->SendOnCancelExpectedVehicleRideAura();
 
                 // mounts can also have accessories
                 GetVehicleKit()->InstallAllAccessories(false);
             }
         }
 
         // unsummon pet
         Pet* pet = player->GetPet();
         if (pet)
         {
             Battleground* bg = ToPlayer()->GetBattleground();
             // don't unsummon pet in arena but SetFlag UNIT_FLAG_STUNNED to disable pet's interface
             if (bg && bg->isArena())
                 pet->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
             else
                 player->UnsummonPetTemporaryIfAny();
         }
 
         player->SendMovementSetCollisionHeight(player->GetCollisionHeight(true));
     }
 
     RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOUNT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::MustReacquireTarget ( )

inline

1373 { m_shouldReacquireTarget = true; } // flags the Unit for forced target reacquisition in the next ::Attack call

Unit::m_shouldReacquireTarget

bool m_shouldReacquireTarget

Definition: Unit.h:2257

Here is the caller graph for this function:

void Unit::NearTeleportTo	(	float	x,
		float	y,
		float	z,
		float	orientation,
		bool	casting = `false`
	)

 {
     DisableSpline();
     if (GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->TeleportTo(GetMapId(), x, y, z, orientation, TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET | (casting ? TELE_TO_SPELL : 0));
     else
     {
         Position pos = {x, y, z, orientation};
         SendTeleportPacket(pos);
         UpdatePosition(x, y, z, orientation, true);
         UpdateObjectVisibility();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::OutDebugInfo ( ) const

 {
     TC_LOG_ERROR("entities.unit", "Unit::OutDebugInfo");
     TC_LOG_DEBUG("entities.unit", "%s name %s", GetGUID().ToString().c_str(), GetName().c_str());
     TC_LOG_DEBUG("entities.unit", "Owner %s, Minion %s, Charmer %s, Charmed %s", GetOwnerGUID().ToString().c_str(), GetMinionGUID().ToString().c_str(), GetCharmerGUID().ToString().c_str(), GetCharmGUID().ToString().c_str());
     TC_LOG_DEBUG("entities.unit", "In world %u, unit type mask %u", (uint32)(IsInWorld() ? 1 : 0), m_unitTypeMask);
     if (IsInWorld())
         TC_LOG_DEBUG("entities.unit", "Mapid %u", GetMapId());
 
     std::ostringstream o;
     o << "Summon Slot: ";
     for (uint32 i = 0; i < MAX_SUMMON_SLOT; ++i)
         o << m_SummonSlot[i].ToString() << ", ";
 
     TC_LOG_DEBUG("entities.unit", "%s", o.str().c_str());
     o.str("");
 
     o << "Controlled List: ";
     for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
         o << (*itr)->GetGUID().ToString() << ", ";
     TC_LOG_DEBUG("entities.unit", "%s", o.str().c_str());
     o.str("");
 
     o << "Aura List: ";
     for (AuraApplicationMap::const_iterator itr = m_appliedAuras.begin(); itr != m_appliedAuras.end(); ++itr)
         o << itr->first << ", ";
     TC_LOG_DEBUG("entities.unit", "%s", o.str().c_str());
     o.str("");
 
     if (IsVehicle())
     {
         o << "Passenger List: ";
         for (SeatMap::iterator itr = GetVehicleKit()->Seats.begin(); itr != GetVehicleKit()->Seats.end(); ++itr)
             if (Unit* passenger = ObjectAccessor::GetUnit(*GetVehicleBase(), itr->second.Passenger.Guid))
                 o << passenger->GetGUID().ToString() << ", ";
         TC_LOG_DEBUG("entities.unit", "%s", o.str().c_str());
     }
 
     if (GetVehicle())
         TC_LOG_DEBUG("entities.unit", "On vehicle %u.", GetVehicleBase()->GetEntry());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::PlayOneShotAnimKitId ( uint16 animKitId )

 {
     if (!sAnimKitStore.LookupEntry(animKitId))
     {
         TC_LOG_ERROR("entities.unit", "Unit::PlayOneShotAnimKitId using invalid AnimKit ID: %u", animKitId);
         return;
     }
 
     WorldPackets::Misc::PlayOneShotAnimKit data;
     data.Unit = GetGUID();
     data.AnimKitID = animKitId;
     SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ProcDamageAndSpell	(	Unit *	victim,
		uint32	procAttacker,
		uint32	procVictim,
		uint32	procEx,
		uint32	amount,
		WeaponAttackType	attType = `BASE_ATTACK`,
		SpellInfo const *	procSpell = `NULL`,
		SpellInfo const *	procAura = `NULL`
	)

 {
      // Not much to do if no flags are set.
     if (procAttacker)
         ProcDamageAndSpellFor(false, victim, procAttacker, procExtra, attType, procSpell, amount, procAura);
     // Now go on with a victim's events'n'auras
     // Not much to do if no flags are set or there is no victim
     if (victim && victim->IsAlive() && procVictim)
         victim->ProcDamageAndSpellFor(true, this, procVictim, procExtra, attType, procSpell, amount, procAura);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ProcDamageAndSpellFor	(	bool	isVictim,
		Unit *	target,
		uint32	procFlag,
		uint32	procExtra,
		WeaponAttackType	attType,
		SpellInfo const *	procSpell,
		uint32	damage,
		SpellInfo const *	procAura = `NULL`
	)

 {
     // Player is loaded now - do not allow passive spell casts to proc
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetSession()->PlayerLoading())
         return;
     // For melee/ranged based attack need update skills and set some Aura states if victim present
     if (procFlag & MELEE_BASED_TRIGGER_MASK && target)
     {
         // If exist crit/parry/dodge/block need update aura state (for victim and attacker)
         if (procExtra & (PROC_EX_CRITICAL_HIT|PROC_EX_PARRY|PROC_EX_DODGE|PROC_EX_BLOCK))
         {
             // for victim
             if (isVictim)
             {
                 // if victim and dodge attack
                 if (procExtra & PROC_EX_DODGE)
                 {
                     // Update AURA_STATE on dodge
                     if (getClass() != CLASS_ROGUE) // skip Rogue Riposte
                     {
                         ModifyAuraState(AURA_STATE_DEFENSE, true);
                         StartReactiveTimer(REACTIVE_DEFENSE);
                     }
                 }
                 // if victim and parry attack
                 if (procExtra & PROC_EX_PARRY)
                 {
                     // For Hunters only Counterattack (skip Mongoose bite)
                     if (getClass() == CLASS_HUNTER)
                     {
                         ModifyAuraState(AURA_STATE_HUNTER_PARRY, true);
                         StartReactiveTimer(REACTIVE_HUNTER_PARRY);
                     }
                     else
                     {
                         ModifyAuraState(AURA_STATE_DEFENSE, true);
                         StartReactiveTimer(REACTIVE_DEFENSE);
                     }
                 }
                 // if and victim block attack
                 if (procExtra & PROC_EX_BLOCK)
                 {
                     ModifyAuraState(AURA_STATE_DEFENSE, true);
                     StartReactiveTimer(REACTIVE_DEFENSE);
                 }
             }
             else // For attacker
             {
                 // Overpower on victim dodge
                 if (procExtra & PROC_EX_DODGE && GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_WARRIOR)
                 {
                     ToPlayer()->AddComboPoints(1);
                     StartReactiveTimer(REACTIVE_OVERPOWER);
                 }
             }
         }
     }
 
     Unit* actor = isVictim ? target : this;
     Unit* actionTarget = !isVictim ? target : this;
 
     DamageInfo damageInfo = DamageInfo(actor, actionTarget, damage, procSpell, procSpell ? SpellSchoolMask(procSpell->SchoolMask) : SPELL_SCHOOL_MASK_NORMAL, SPELL_DIRECT_DAMAGE);
     HealInfo healInfo = HealInfo(actor, actionTarget, damage, procSpell, procSpell ? SpellSchoolMask(procSpell->SchoolMask) : SPELL_SCHOOL_MASK_NORMAL);
     ProcEventInfo eventInfo = ProcEventInfo(actor, actionTarget, target, procFlag, 0, 0, procExtra, nullptr, &damageInfo, &healInfo);
 
     ProcTriggeredList procTriggered;
     // Fill procTriggered list
     for (AuraApplicationMap::const_iterator itr = GetAppliedAuras().begin(); itr!= GetAppliedAuras().end(); ++itr)
     {
         // Do not allow auras to proc from effect triggered by itself
         if (procAura && procAura->Id == itr->first)
             continue;
         ProcTriggeredData triggerData(itr->second->GetBase());
         // Defensive procs are active on absorbs (so absorption effects are not a hindrance)
         bool active = damage || (procExtra & PROC_EX_BLOCK && isVictim);
         if (isVictim)
             procExtra &= ~PROC_EX_INTERNAL_REQ_FAMILY;
 
         SpellInfo const* spellProto = itr->second->GetBase()->GetSpellInfo();
 
         // only auras that has triggered spell should proc from fully absorbed damage
         if (procExtra & PROC_EX_ABSORB && isVictim && damage)
         {
             for (SpellEffectInfo const* effect : itr->second->GetBase()->GetSpellEffectInfos())
             {
                 if (effect && effect->TriggerSpell)
                 {
                     active = true;
                     break;
                 }
             }
         }
         if (!IsTriggeredAtSpellProcEvent(target, triggerData.aura, procSpell, procFlag, procExtra, attType, isVictim, active, triggerData.spellProcEvent))
             continue;
 
         // do checks using conditions table
         if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_SPELL_PROC, spellProto->Id, eventInfo.GetActor(), eventInfo.GetActionTarget()))
             continue;
 
         // AuraScript Hook
         if (!triggerData.aura->CallScriptCheckProcHandlers(itr->second, eventInfo))
             continue;
 
         // Triggered spells not triggering additional spells
         bool triggered = !spellProto->HasAttribute(SPELL_ATTR3_CAN_PROC_WITH_TRIGGERED) ?
             (procExtra & PROC_EX_INTERNAL_TRIGGERED && !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION)) : false;
 
         for (AuraEffect const* aurEff : itr->second->GetBase()->GetAuraEffects())
         {
             if (aurEff)
             {
                 // Skip this auras
                 if (isNonTriggerAura[aurEff->GetAuraType()])
                     continue;
                 // If not trigger by default and spellProcEvent == NULL - skip
                 if (!isTriggerAura[aurEff->GetAuraType()] && triggerData.spellProcEvent == NULL)
                     continue;
                 // Some spells must always trigger
                 if (!triggered || isAlwaysTriggeredAura[aurEff->GetAuraType()])
                     triggerData.effMask |= 1 << aurEff->GetEffIndex();
             }
         }
         if (triggerData.effMask)
             procTriggered.push_front(triggerData);
     }
 
     // Nothing found
     if (procTriggered.empty())
         return;
 
     // Note: must SetCantProc(false) before return
     if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC))
         SetCantProc(true);
 
     // Handle effects proceed this time
     for (ProcTriggeredList::const_iterator i = procTriggered.begin(); i != procTriggered.end(); ++i)
     {
         // look for aura in auras list, it may be removed while proc event processing
         if (i->aura->IsRemoved())
             continue;
 
         bool useCharges  = i->aura->IsUsingCharges();
         // no more charges to use, prevent proc
         if (useCharges && !i->aura->GetCharges())
             continue;
 
         bool takeCharges = false;
         SpellInfo const* spellInfo = i->aura->GetSpellInfo();
         uint32 Id = i->aura->GetId();
 
         AuraApplication* aurApp = i->aura->GetApplicationOfTarget(GetGUID());
         ASSERT(aurApp);
 
         bool prepare = i->aura->CallScriptPrepareProcHandlers(aurApp, eventInfo);
 
         // For players set spell cooldown if need
         uint32 cooldown = 0;
         if (prepare && GetTypeId() == TYPEID_PLAYER && i->spellProcEvent && i->spellProcEvent->cooldown)
             cooldown = i->spellProcEvent->cooldown;
 
         // Note: must SetCantProc(false) before return
         if (spellInfo->HasAttribute(SPELL_ATTR3_DISABLE_PROC))
             SetCantProc(true);
 
         bool handled = i->aura->CallScriptProcHandlers(aurApp, eventInfo);
 
         // "handled" is needed as long as proc can be handled in multiple places
         if (!handled && HandleAuraProc(target, damage, i->aura, procSpell, procFlag, procExtra, cooldown, &handled))
         {
             TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell %u (triggered with value by %s aura of spell %u)", spellInfo->Id, (isVictim?"a victim's":"an attacker's"), Id);
             takeCharges = true;
         }
 
         if (!handled)
         {
             for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
             {
                 if (!(i->effMask & (1<<effIndex)))
                     continue;
 
                 AuraEffect* triggeredByAura = i->aura->GetEffect(effIndex);
                 ASSERT(triggeredByAura);
 
                 bool prevented = i->aura->CallScriptEffectProcHandlers(triggeredByAura, aurApp, eventInfo);
                 if (prevented)
                 {
                     takeCharges = true;
                     continue;
                 }
 
                 switch (triggeredByAura->GetAuraType())
                 {
                     case SPELL_AURA_PROC_TRIGGER_SPELL:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell %u (triggered by %s aura of spell %u)", spellInfo->Id, (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
                         // Don`t drop charge or add cooldown for not started trigger
                         if (HandleProcTriggerSpell(target, damage, triggeredByAura, procSpell, procFlag, procExtra, cooldown))
                             takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_PROC_TRIGGER_DAMAGE:
                     {
                         // target has to be valid
                         if (!eventInfo.GetProcTarget())
                             break;
 
                         triggeredByAura->HandleProcTriggerDamageAuraProc(aurApp, eventInfo); // this function is part of the new proc system
                         takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_MANA_SHIELD:
                     case SPELL_AURA_DUMMY:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell id %u (triggered by %s dummy aura of spell %u)", spellInfo->Id, (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
                         if (HandleDummyAuraProc(target, damage, triggeredByAura, procSpell, procFlag, procExtra, cooldown))
                             takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_PROC_ON_POWER_AMOUNT:
                     {
                         triggeredByAura->HandleProcTriggerSpellOnPowerAmountAuraProc(aurApp, eventInfo);
                         takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_OBS_MOD_POWER:
                     case SPELL_AURA_MOD_SPELL_CRIT_CHANCE:
                     case SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN:
                     case SPELL_AURA_MOD_POWER_REGEN_PERCENT:
                     case SPELL_AURA_MOD_MELEE_HASTE:
                     case SPELL_AURA_MOD_MELEE_HASTE_3:
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell id %u (triggered by %s aura of spell %u)", spellInfo->Id, isVictim ? "a victim's" : "an attacker's", triggeredByAura->GetId());
                         takeCharges = true;
                         break;
                     case SPELL_AURA_OVERRIDE_CLASS_SCRIPTS:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell id %u (triggered by %s aura of spell %u)", spellInfo->Id, (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
                         if (HandleOverrideClassScriptAuraProc(target, damage, triggeredByAura, procSpell, cooldown))
                             takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_RAID_PROC_FROM_CHARGE_WITH_VALUE:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting mending (triggered by %s dummy aura of spell %u)",
                             (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
 
                         HandleAuraRaidProcFromChargeWithValue(triggeredByAura);
                         takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_RAID_PROC_FROM_CHARGE:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting mending (triggered by %s dummy aura of spell %u)",
                             (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
 
                         HandleAuraRaidProcFromCharge(triggeredByAura);
                         takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE:
                     {
                         TC_LOG_DEBUG("spells", "ProcDamageAndSpell: casting spell %u (triggered with value by %s aura of spell %u)", spellInfo->Id, (isVictim?"a victim's":"an attacker's"), triggeredByAura->GetId());
 
                         if (HandleProcTriggerSpell(target, damage, triggeredByAura, procSpell, procFlag, procExtra, cooldown))
                             takeCharges = true;
                         break;
                     }
                     case SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK:
                         // Skip melee hits or instant cast spells
                         if (procSpell && procSpell->CalcCastTime(getLevel()) > 0)
                             takeCharges = true;
                         break;
                     case SPELL_AURA_REFLECT_SPELLS_SCHOOL:
                         // Skip Melee hits and spells ws wrong school
                         if (procSpell && (triggeredByAura->GetMiscValue() & procSpell->SchoolMask))         // School check
                             takeCharges = true;
                         break;
                     case SPELL_AURA_SPELL_MAGNET:
                         // Skip Melee hits and targets with magnet aura
                         if (procSpell && (triggeredByAura->GetBase()->GetUnitOwner()->ToUnit() == ToUnit()))         // Magnet
                             takeCharges = true;
                         break;
                     case SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT:
                     case SPELL_AURA_MOD_POWER_COST_SCHOOL:
                         // Skip melee hits and spells ws wrong school or zero cost
                         if (procSpell && (triggeredByAura->GetMiscValue() & procSpell->SchoolMask)) // School check
                         {
                             std::vector<SpellInfo::CostData> costs = procSpell->CalcPowerCost(this, procSpell->GetSchoolMask());
                             auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Amount > 0; });
                             if (m != costs.end())
                                 takeCharges = true;
                         }
                         break;
                     case SPELL_AURA_MECHANIC_IMMUNITY:
                         // Compare mechanic
                         if (procSpell && procSpell->Mechanic == uint32(triggeredByAura->GetMiscValue()))
                             takeCharges = true;
                         break;
                     case SPELL_AURA_MOD_MECHANIC_RESISTANCE:
                         // Compare mechanic
                         if (procSpell && procSpell->Mechanic == uint32(triggeredByAura->GetMiscValue()))
                             takeCharges = true;
                         break;
                     case SPELL_AURA_MOD_SPELL_DAMAGE_FROM_CASTER:
                         // Compare casters
                         if (triggeredByAura->GetCasterGUID() == target->GetGUID())
                             takeCharges = true;
                         break;
                     // CC Auras which use their amount amount to drop
                     // Are there any more auras which need this?
                     case SPELL_AURA_MOD_CONFUSE:
                     case SPELL_AURA_MOD_FEAR:
                     case SPELL_AURA_MOD_STUN:
                     case SPELL_AURA_MOD_ROOT:
                     case SPELL_AURA_TRANSFORM:
                     {
                         // chargeable mods are breaking on hit
                         if (useCharges)
                             takeCharges = true;
                         else
                         {
                             // Spell own direct damage at apply wont break the CC
                             if (procSpell && (procSpell->Id == triggeredByAura->GetId()))
                             {
                                 Aura* aura = triggeredByAura->GetBase();
                                 // called from spellcast, should not have ticked yet
                                 if (aura->GetDuration() == aura->GetMaxDuration())
                                     break;
                             }
                             int32 damageLeft = triggeredByAura->GetAmount();
                             // No damage left
                             if (damageLeft < int32(damage))
                                 i->aura->Remove();
                             else
                                 triggeredByAura->SetAmount(damageLeft - damage);
                         }
                         break;
                     }
                     //case SPELL_AURA_ADD_FLAT_MODIFIER:
                     //case SPELL_AURA_ADD_PCT_MODIFIER:
                         // HandleSpellModAuraProc
                         //break;
                     default:
                         // nothing do, just charges counter
                         takeCharges = true;
                         break;
                 } // switch (triggeredByAura->GetAuraType())
                 i->aura->CallScriptAfterEffectProcHandlers(triggeredByAura, aurApp, eventInfo);
             } // for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
         } // if (!handled)
 
         // Remove charge (aura can be removed by triggers)
         if (prepare && useCharges && takeCharges)
         {
             // Set charge drop delay (only for missiles)
             if ((procExtra & PROC_EX_REFLECT) && target && procSpell && procSpell->Speed > 0.0f)
             {
                 // Set up missile speed based delay (from Spell.cpp: Spell::AddUnitTarget()::L2237)
                 uint32 delay = uint32(std::floor(std::max<float>(target->GetDistance(this), 5.0f) / procSpell->Speed * 1000.0f));
                 // Schedule charge drop
                 i->aura->DropChargeDelayed(delay);
             }
             else
                 i->aura->DropCharge();
         }
 
         i->aura->CallScriptAfterProcHandlers(aurApp, eventInfo);
 
         if (spellInfo->HasAttribute(SPELL_ATTR3_DISABLE_PROC))
             SetCantProc(false);
     }
 
     // Cleanup proc requirements
     if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC))
         SetCantProc(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::propagateSpeedChange ( )

inline

-------—End of Pet responses methods-------—

2130 { GetMotionMaster()->propagateSpeedChange(); }

Unit::GetMotionMaster

MotionMaster * GetMotionMaster()

Definition: Unit.h:2101

MotionMaster::propagateSpeedChange

void propagateSpeedChange()

Definition: MotionMaster.cpp:649

Here is the caller graph for this function:

void Unit::RemoveAllAttackers ( )

 {
     while (!m_attackers.empty())
     {
         AttackerSet::iterator iter = m_attackers.begin();
         if (!(*iter)->AttackStop())
         {
             TC_LOG_ERROR("entities.unit", "WORLD: Unit has an attacker that isn't attacking it!");
             m_attackers.erase(iter);
         }
     }
 }

Here is the caller graph for this function:

void Unit::RemoveAllAuras ( )

 {
     // this may be a dead loop if some events on aura remove will continiously apply aura on remove
     // we want to have all auras removed, so use your brain when linking events
     while (!m_appliedAuras.empty() || !m_ownedAuras.empty())
     {
         AuraApplicationMap::iterator aurAppIter;
         for (aurAppIter = m_appliedAuras.begin(); aurAppIter != m_appliedAuras.end();)
             _UnapplyAura(aurAppIter, AURA_REMOVE_BY_DEFAULT);
 
         AuraMap::iterator aurIter;
         for (aurIter = m_ownedAuras.begin(); aurIter != m_ownedAuras.end();)
             RemoveOwnedAura(aurIter);
     }
 }

Here is the call graph for this function:

void Unit::RemoveAllAurasExceptType ( AuraType type )

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type))
             ++iter;
         else
             _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
     }
 
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura* aura = iter->second;
         if (aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type))
             ++iter;
         else
             RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAllAurasExceptType	(	AuraType	type1,
		AuraType	type2
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type1) || aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type2))
             ++iter;
         else
             _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
     }
 
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura* aura = iter->second;
         if (aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type1) || aura->GetSpellInfo()->HasAura(GetMap()->GetDifficultyID(), type2))
             ++iter;
         else
             RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
     }
 }

Here is the call graph for this function:

void Unit::RemoveAllAurasOnDeath ( )

 {
     // used just after dieing to remove all visible auras
     // and disable the mods for the passive ones
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (!aura->IsPassive() && !aura->IsDeathPersistent())
             _UnapplyAura(iter, AURA_REMOVE_BY_DEATH);
         else
             ++iter;
     }
 
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura* aura = iter->second;
         if (!aura->IsPassive() && !aura->IsDeathPersistent())
             RemoveOwnedAura(iter, AURA_REMOVE_BY_DEATH);
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAllAurasRequiringDeadTarget ( )

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (!aura->IsPassive() && aura->GetSpellInfo()->IsRequiringDeadTarget())
             _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
         else
             ++iter;
     }
 
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura* aura = iter->second;
         if (!aura->IsPassive() && aura->GetSpellInfo()->IsRequiringDeadTarget())
             RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAllControlled ( )

 {
     // possessed pet and vehicle
     if (GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->StopCastingCharm();
 
     while (!m_Controlled.empty())
     {
         Unit* target = *m_Controlled.begin();
         m_Controlled.erase(m_Controlled.begin());
         if (target->GetCharmerGUID() == GetGUID())
             target->RemoveCharmAuras();
         else if (target->GetOwnerGUID() == GetGUID() && target->IsSummon())
             target->ToTempSummon()->UnSummon();
         else
             TC_LOG_ERROR("entities.unit", "Unit %u is trying to release unit %u which is neither charmed nor owned by it", GetEntry(), target->GetEntry());
     }
     if (!GetPetGUID().IsEmpty())
         TC_LOG_FATAL("entities.unit", "Unit %u is not able to release its pet %s", GetEntry(), GetPetGUID().ToString().c_str());
     if (!GetMinionGUID().IsEmpty())
         TC_LOG_FATAL("entities.unit", "Unit %u is not able to release its minion %s", GetEntry(), GetMinionGUID().ToString().c_str());
     if (!GetCharmGUID().IsEmpty())
         TC_LOG_FATAL("entities.unit", "Unit %u is not able to release its charm %s", GetEntry(), GetCharmGUID().ToString().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAllDynObjects ( )

 {
     while (!m_dynObj.empty())
         m_dynObj.front()->Remove();
 }

Here is the caller graph for this function:

void Unit::RemoveAllGameObjects ( )

 {
     // remove references to unit
     while (!m_gameObj.empty())
     {
         GameObjectList::iterator i = m_gameObj.begin();
         (*i)->SetOwnerGUID(ObjectGuid::Empty);
         (*i)->SetRespawnTime(0);
         (*i)->Delete();
         m_gameObj.erase(i);
     }
 }

Here is the caller graph for this function:

void Unit::RemoveAllMinionsByEntry ( uint32 entry )

 {
     for (Unit::ControlList::iterator itr = m_Controlled.begin(); itr != m_Controlled.end();)
     {
         Unit* unit = *itr;
         ++itr;
         if (unit->GetEntry() == entry && unit->GetTypeId() == TYPEID_UNIT
             && unit->ToCreature()->IsSummon()) // minion, actually
             unit->ToTempSummon()->UnSummon();
         // i think this is safe because i have never heard that a despawned minion will trigger a same minion
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAppliedAuras ( std::function< bool(AuraApplication const *)> const & check )

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         if (check(iter->second))
         {
             RemoveAura(iter);
             continue;
         }
         ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAppliedAuras	(	uint32	spellId,
		std::function< bool(AuraApplication const *)> const &	check
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
     {
         if (check(iter->second))
         {
             RemoveAura(iter);
             continue;
         }
         ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAreaAurasDueToLeaveWorld ( )

 {
     // make sure that all area auras not applied on self are removed - prevent access to deleted pointer later
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura* aura = iter->second;
         ++iter;
         Aura::ApplicationMap const& appMap = aura->GetApplicationMap();
         for (Aura::ApplicationMap::const_iterator itr = appMap.begin(); itr!= appMap.end();)
         {
             AuraApplication * aurApp = itr->second;
             ++itr;
             Unit* target = aurApp->GetTarget();
             if (target == this)
                 continue;
             target->RemoveAura(aurApp);
             // things linked on aura remove may apply new area aura - so start from the beginning
             iter = m_ownedAuras.begin();
         }
     }
 
     // remove area auras owned by others
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         if (iter->second->GetBase()->GetOwner() != this)
         {
             RemoveAura(iter);
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveArenaAuras ( )

 {
     // in join, remove positive buffs, on end, remove negative
     // used to remove positive visible auras in arenas
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         AuraApplication const* aurApp = iter->second;
         Aura const* aura = aurApp->GetBase();
         if (!(aura->GetSpellInfo()->AttributesEx4 & SPELL_ATTR4_UNK21) // don't remove stances, shadowform, pally/hunter auras
             && !aura->IsPassive()                               // don't remove passive auras
             && (aurApp->IsPositive() || !(aura->GetSpellInfo()->AttributesEx3 & SPELL_ATTR3_DEATH_PERSISTENT))) // not negative death persistent auras
             RemoveAura(iter);
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAura	(	AuraApplicationMap::iterator &	i,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     AuraApplication * aurApp = i->second;
     // Do not remove aura which is already being removed
     if (aurApp->GetRemoveMode())
         return;
     Aura* aura = aurApp->GetBase();
     _UnapplyAura(i, mode);
     // Remove aura - for Area and Target auras
     if (aura->GetOwner() == this)
         aura->Remove(mode);
 }

Here is the call graph for this function:

void Unit::RemoveAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     AuraApplicationMapBoundsNonConst range = m_appliedAuras.equal_range(spellId);
     for (AuraApplicationMap::iterator iter = range.first; iter != range.second;)
     {
         Aura const* aura = iter->second->GetBase();
         if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
                 && (!caster || aura->GetCasterGUID() == caster))
         {
             RemoveAura(iter, removeMode);
             return;
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAura	(	AuraApplication *	aurApp,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     // we've special situation here, RemoveAura called while during aura removal
     // this kind of call is needed only when aura effect removal handler
     // or event triggered by it expects to remove
     // not yet removed effects of an aura
     if (aurApp->GetRemoveMode())
     {
         // remove remaining effects of an aura
         for (uint8 itr = 0; itr < MAX_SPELL_EFFECTS; ++itr)
         {
             if (aurApp->HasEffect(itr))
                 aurApp->_HandleEffect(itr, false);
         }
         return;
     }
     // no need to remove
     if (aurApp->GetBase()->GetApplicationOfTarget(GetGUID()) != aurApp || aurApp->GetBase()->IsRemoved())
         return;
 
     uint32 spellId = aurApp->GetBase()->GetId();
     AuraApplicationMapBoundsNonConst range = m_appliedAuras.equal_range(spellId);
 
     for (AuraApplicationMap::iterator iter = range.first; iter != range.second;)
     {
         if (aurApp == iter->second)
         {
             RemoveAura(iter, mode);
             return;
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAura	(	Aura *	aur,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     if (aura->IsRemoved())
         return;
     if (AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID()))
         RemoveAura(aurApp, mode);
 }

Here is the call graph for this function:

void Unit::RemoveAuraFromStack	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
     for (AuraMap::iterator iter = range.first; iter != range.second;)
     {
         Aura* aura = iter->second;
         if ((aura->GetType() == UNIT_AURA_TYPE)
                 && (!casterGUID || aura->GetCasterGUID() == casterGUID))
         {
             aura->ModStackAmount(-1, removeMode);
             return;
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasByType	(	AuraType	auraType,
		std::function< bool(AuraApplication const *)> const &	check
	)

 {
     for (AuraEffectList::iterator iter = m_modAuras[auraType].begin(); iter != m_modAuras[auraType].end();)
     {
         Aura* aura = (*iter)->GetBase();
         AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID());
         ASSERT(aurApp);
 
         ++iter;
         if (check(aurApp))
         {
             uint32 removedAuras = m_removedAurasCount;
             RemoveAura(aurApp);
             if (m_removedAurasCount > removedAuras + 1)
                 iter = m_modAuras[auraType].begin();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasByType	(	AuraType	auraType,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		Aura *	except = `NULL`,
		bool	negative = `true`,
		bool	positive = `true`
	)

 {
     for (AuraEffectList::iterator iter = m_modAuras[auraType].begin(); iter != m_modAuras[auraType].end();)
     {
         Aura* aura = (*iter)->GetBase();
         AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID());
         ASSERT(aurApp);
 
         ++iter;
         if (aura != except && (!casterGUID || aura->GetCasterGUID() == casterGUID)
             && ((negative && !aurApp->IsPositive()) || (positive && aurApp->IsPositive())))
         {
             uint32 removedAuras = m_removedAurasCount;
             RemoveAura(aurApp);
             if (m_removedAurasCount > removedAuras + 1)
                 iter = m_modAuras[auraType].begin();
         }
     }
 }

Here is the call graph for this function:

void Unit::RemoveAurasDueToItemSpell	(	uint32	spellId,
		ObjectGuid	castItemGuid
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
     {
         if (iter->second->GetBase()->GetCastItemGUID() == castItemGuid)
         {
             RemoveAura(iter);
             iter = m_appliedAuras.lower_bound(spellId);
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAurasDueToSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
     {
         Aura const* aura = iter->second->GetBase();
         if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
             && (!casterGUID || aura->GetCasterGUID() == casterGUID))
         {
             RemoveAura(iter, removeMode);
             iter = m_appliedAuras.lower_bound(spellId);
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAurasDueToSpellByDispel	(	uint32	spellId,
		uint32	dispellerSpellId,
		ObjectGuid	casterGUID,
		Unit *	dispeller,
		uint8	chargesRemoved = `1`
	)

 {
     AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
     for (AuraMap::iterator iter = range.first; iter != range.second;)
     {
         Aura* aura = iter->second;
         if (aura->GetCasterGUID() == casterGUID)
         {
             DispelInfo dispelInfo(dispeller, dispellerSpellId, chargesRemoved);
 
             // Call OnDispel hook on AuraScript
             aura->CallScriptDispel(&dispelInfo);
 
             if (aura->GetSpellInfo()->AttributesEx7 & SPELL_ATTR7_DISPEL_CHARGES)
                 aura->ModCharges(-dispelInfo.GetRemovedCharges(), AURA_REMOVE_BY_ENEMY_SPELL);
             else
                 aura->ModStackAmount(-dispelInfo.GetRemovedCharges(), AURA_REMOVE_BY_ENEMY_SPELL);
 
             // Call AfterDispel hook on AuraScript
             aura->CallScriptAfterDispel(&dispelInfo);
 
             return;
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasDueToSpellBySteal	(	uint32	spellId,
		ObjectGuid	casterGUID,
		Unit *	stealer
	)

 {
     AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
     for (AuraMap::iterator iter = range.first; iter != range.second;)
     {
         Aura* aura = iter->second;
         if (aura->GetCasterGUID() == casterGUID)
         {
             int32 damage[MAX_SPELL_EFFECTS];
             int32 baseDamage[MAX_SPELL_EFFECTS];
             uint8 effMask = 0;
             uint8 recalculateMask = 0;
             Unit* caster = aura->GetCaster();
             for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
             {
                 if (aura->GetEffect(i))
                 {
                     baseDamage[i] = aura->GetEffect(i)->GetBaseAmount();
                     damage[i] = aura->GetEffect(i)->GetAmount();
                     effMask |= (1<<i);
                     if (aura->GetEffect(i)->CanBeRecalculated())
                         recalculateMask |= (1<<i);
                 }
                 else
                 {
                     baseDamage[i] = 0;
                     damage[i] = 0;
                 }
             }
 
             bool stealCharge = (aura->GetSpellInfo()->AttributesEx7 & SPELL_ATTR7_DISPEL_CHARGES) != 0;
             // Cast duration to unsigned to prevent permanent aura's such as Righteous Fury being permanently added to caster
             uint32 dur = std::min(2u * MINUTE * IN_MILLISECONDS, uint32(aura->GetDuration()));
 
             if (Aura* oldAura = stealer->GetAura(aura->GetId(), aura->GetCasterGUID()))
             {
                 if (stealCharge)
                     oldAura->ModCharges(1);
                 else
                     oldAura->ModStackAmount(1);
                 oldAura->SetDuration(int32(dur));
             }
             else
             {
                 // single target state must be removed before aura creation to preserve existing single target aura
                 if (aura->IsSingleTarget())
                     aura->UnregisterSingleTarget();
 
                 if (Aura* newAura = Aura::TryRefreshStackOrCreate(aura->GetSpellInfo(), effMask, stealer, NULL, &baseDamage[0], NULL, aura->GetCasterGUID()))
                 {
                     // created aura must not be single target aura,, so stealer won't loose it on recast
                     if (newAura->IsSingleTarget())
                     {
                         newAura->UnregisterSingleTarget();
                         // bring back single target aura status to the old aura
                         aura->SetIsSingleTarget(true);
                         caster->GetSingleCastAuras().push_back(aura);
                     }
                     // FIXME: using aura->GetMaxDuration() maybe not blizzlike but it fixes stealing of spells like Innervate
                     newAura->SetLoadedState(aura->GetMaxDuration(), int32(dur), stealCharge ? 1 : aura->GetCharges(), 1, recalculateMask, &damage[0]);
                     newAura->ApplyForTargets();
                 }
             }
 
             if (stealCharge)
                 aura->ModCharges(-1, AURA_REMOVE_BY_ENEMY_SPELL);
             else
                 aura->ModStackAmount(-1, AURA_REMOVE_BY_ENEMY_SPELL);
 
             return;
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasWithAttribute ( uint32 flags )

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         SpellInfo const* spell = iter->second->GetBase()->GetSpellInfo();
         if (spell->Attributes & flags)
             RemoveAura(iter);
         else
             ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveAurasWithFamily	(	SpellFamilyNames	family,
		flag128 const &	familyFlag,
		ObjectGuid	casterGUID
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (!casterGUID || aura->GetCasterGUID() == casterGUID)
         {
             SpellInfo const* spell = aura->GetSpellInfo();
             if (spell->SpellFamilyName == uint32(family) && spell->SpellFamilyFlags & familyFlag)
             {
                 RemoveAura(iter);
                 continue;
             }
         }
         ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasWithInterruptFlags	(	uint32	flag,
		uint32	except = `0`
	)

 {
     if (!(m_interruptMask & flag))
         return;
 
     // interrupt auras
     for (AuraApplicationList::iterator iter = m_interruptableAuras.begin(); iter != m_interruptableAuras.end();)
     {
         Aura* aura = (*iter)->GetBase();
         ++iter;
         if ((aura->GetSpellInfo()->AuraInterruptFlags & flag) && (!except || aura->GetId() != except)
             && !(flag & AURA_INTERRUPT_FLAG_MOVE && HasAuraTypeWithAffectMask(SPELL_AURA_CAST_WHILE_WALKING, aura->GetSpellInfo())))
         {
             uint32 removedAuras = m_removedAurasCount;
             RemoveAura(aura);
             if (m_removedAurasCount > removedAuras + 1)
                 iter = m_interruptableAuras.begin();
         }
     }
 
     // interrupt channeled spell
     if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL])
         if (spell->getState() == SPELL_STATE_CASTING
             && (spell->m_spellInfo->ChannelInterruptFlags & flag)
             && spell->m_spellInfo->Id != except
             && !(flag & AURA_INTERRUPT_FLAG_MOVE && HasAuraTypeWithAffectMask(SPELL_AURA_CAST_WHILE_WALKING, spell->GetSpellInfo())))
             InterruptNonMeleeSpells(false);
 
     UpdateInterruptMask();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveAurasWithMechanic	(	uint32	mechanic_mask,
		AuraRemoveMode	removemode = `AURA_REMOVE_BY_DEFAULT`,
		uint32	except = `0`
	)

 {
     for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
     {
         Aura const* aura = iter->second->GetBase();
         if (!except || aura->GetId() != except)
         {
             if (aura->GetSpellInfo()->GetAllEffectsMechanicMask() & mechanic_mask)
             {
                 RemoveAura(iter, removemode);
                 continue;
             }
         }
         ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveBindSightAuras ( )

 {
     RemoveAurasByType(SPELL_AURA_BIND_SIGHT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveCharmAuras ( )

 {
     RemoveAurasByType(SPELL_AURA_MOD_CHARM);
     RemoveAurasByType(SPELL_AURA_MOD_POSSESS_PET);
     RemoveAurasByType(SPELL_AURA_MOD_POSSESS);
     RemoveAurasByType(SPELL_AURA_AOE_CHARM);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveCharmedBy ( Unit * charmer )

Todo:: CombatStop(true) may cause crash (interrupt spells)

 {
     if (!IsCharmed())
         return;
 
     if (!charmer)
         charmer = GetCharmer();
     if (charmer != GetCharmer()) // one aura overrides another?
     {
 //        TC_LOG_FATAL("entities.unit", "Unit::RemoveCharmedBy: this: " UI64FMTD " true charmer: " UI64FMTD " false charmer: " UI64FMTD,
 //            GetGUID(), GetCharmerGUID(), charmer->GetGUID());
 //        ABORT();
         return;
     }
 
     CharmType type;
     if (HasUnitState(UNIT_STATE_POSSESSED))
         type = CHARM_TYPE_POSSESS;
     else if (charmer && charmer->IsOnVehicle(this))
         type = CHARM_TYPE_VEHICLE;
     else
         type = CHARM_TYPE_CHARM;
 
     CastStop();
     CombatStop(); 
     getHostileRefManager().deleteReferences();
     DeleteThreatList();
 
     if (_oldFactionId)
     {
         setFaction(_oldFactionId);
         _oldFactionId = 0;
     }
     else
         RestoreFaction();
 
     GetMotionMaster()->InitDefault();
 
     if (Creature* creature = ToCreature())
     {
         // Creature will restore its old AI on next update
         if (creature->AI())
             creature->AI()->OnCharmed(false);
 
         // Vehicle should not attack its passenger after he exists the seat
         if (type != CHARM_TYPE_VEHICLE)
             LastCharmerGUID = ASSERT_NOTNULL(charmer)->GetGUID();
     }
 
     // If charmer still exists
     if (!charmer)
         return;
 
     ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
     ASSERT(type != CHARM_TYPE_VEHICLE || (GetTypeId() == TYPEID_UNIT && IsVehicle()));
 
     charmer->SetCharm(this, false);
 
     Player* playerCharmer = charmer->ToPlayer();
 
     if (playerCharmer)
     {
         switch (type)
         {
             case CHARM_TYPE_VEHICLE:
                 playerCharmer->SetClientControl(this, false);
                 playerCharmer->SetClientControl(charmer, true);
                 RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
                 break;
             case CHARM_TYPE_POSSESS:
                 playerCharmer->SetClientControl(this, false);
                 playerCharmer->SetClientControl(charmer, true);
                 charmer->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
                 RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
                 ClearUnitState(UNIT_STATE_POSSESSED);
                 break;
             case CHARM_TYPE_CHARM:
                 if (GetTypeId() == TYPEID_UNIT && charmer->getClass() == CLASS_WARLOCK)
                 {
                     CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate();
                     if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
                     {
                         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_CLASS, uint8(cinfo->unit_class));
                         if (GetCharmInfo())
                             GetCharmInfo()->SetPetNumber(0, true);
                         else
                             TC_LOG_ERROR("entities.unit", "Aura::HandleModCharm: %s has a charm aura but no charm info!", GetGUID().ToString().c_str());
                     }
                 }
                 break;
             case CHARM_TYPE_CONVERT:
                 break;
         }
     }
 
     if (Player* player = ToPlayer())
         player->SetClientControl(this, true);
 
     // a guardian should always have charminfo
     if (playerCharmer && this != charmer->GetFirstControlled())
         playerCharmer->SendRemoveControlBar();
     else if (GetTypeId() == TYPEID_PLAYER || (GetTypeId() == TYPEID_UNIT && !IsGuardian()))
         DeleteCharmInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveDynObject ( uint32 spellId )

 {
     if (m_dynObj.empty())
         return;
     for (DynObjectList::iterator i = m_dynObj.begin(); i != m_dynObj.end();)
     {
         DynamicObject* dynObj = *i;
         if (dynObj->GetSpellId() == spellId)
         {
             dynObj->Remove();
             i = m_dynObj.begin();
         }
         else
             ++i;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveExtraUnitMovementFlag ( uint16 f )

inline

2114 { m_movementInfo.RemoveExtraMovementFlag(f); }

MovementInfo::RemoveExtraMovementFlag

MovementInfo m_movementInfo

Definition: Object.h:612

void RemoveExtraMovementFlag(uint16 flag)

Definition: Object.h:335

void Unit::removeFollower ( FollowerReference * )

inline

2099 { /* nothing to do yet */ }

Here is the caller graph for this function:

void Unit::RemoveFromWorld ( )

overridevirtual

Reimplemented from WorldObject.

 {
     // cleanup
     ASSERT(GetGUID());
 
     if (IsInWorld())
     {
         m_duringRemoveFromWorld = true;
         if (IsVehicle())
             RemoveVehicleKit(true);
 
         RemoveCharmAuras();
         RemoveBindSightAuras();
         RemoveNotOwnSingleTargetAuras();
 
         RemoveAllGameObjects();
         RemoveAllDynObjects();
 
         ExitVehicle();  // Remove applied auras with SPELL_AURA_CONTROL_VEHICLE
         UnsummonAllTotems();
         RemoveAllControlled();
 
         RemoveAreaAurasDueToLeaveWorld();
 
         if (!GetCharmerGUID().IsEmpty())
         {
             TC_LOG_FATAL("entities.unit", "Unit %u has charmer guid when removed from world", GetEntry());
             ABORT();
         }
 
         if (Unit* owner = GetOwner())
         {
             if (owner->m_Controlled.find(this) != owner->m_Controlled.end())
             {
                 TC_LOG_FATAL("entities.unit", "Unit %u is in controlled list of %u when removed from world", GetEntry(), owner->GetEntry());
                 ABORT();
             }
         }
 
         WorldObject::RemoveFromWorld();
         m_duringRemoveFromWorld = false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveGameObject	(	GameObject *	gameObj,
		bool	del
	)

 {
     if (!gameObj || gameObj->GetOwnerGUID() != GetGUID())
         return;
 
     gameObj->SetOwnerGUID(ObjectGuid::Empty);
 
     for (uint8 i = 0; i < MAX_GAMEOBJECT_SLOT; ++i)
     {
         if (m_ObjectSlot[i] == gameObj->GetGUID())
         {
             m_ObjectSlot[i].Clear();
             break;
         }
     }
 
     // GO created by some spell
     if (uint32 spellid = gameObj->GetSpellId())
     {
         RemoveAurasDueToSpell(spellid);
 
         SpellInfo const* createBySpell = sSpellMgr->GetSpellInfo(spellid);
         // Need activate spell use for owner
         if (createBySpell && createBySpell->IsCooldownStartedOnEvent())
             // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existing cases)
             GetSpellHistory()->SendCooldownEvent(createBySpell);
     }
 
     m_gameObj.remove(gameObj);
 
     if (del)
     {
         gameObj->SetRespawnTime(0);
         gameObj->Delete();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveGameObject	(	uint32	spellid,
		bool	del
	)

 {
     if (m_gameObj.empty())
         return;
     GameObjectList::iterator i, next;
     for (i = m_gameObj.begin(); i != m_gameObj.end(); i = next)
     {
         next = i;
         if (spellid == 0 || (*i)->GetSpellId() == spellid)
         {
             (*i)->SetOwnerGUID(ObjectGuid::Empty);
             if (del)
             {
                 (*i)->SetRespawnTime(0);
                 (*i)->Delete();
             }
 
             next = m_gameObj.erase(i);
         }
         else
             ++next;
     }
 }

Here is the call graph for this function:

void Unit::removeHatedBy ( HostileReference * )

inline

2000 { /* nothing to do yet */ }

Here is the caller graph for this function:

void Unit::RemoveMovementImpairingAuras ( )

 {
     RemoveAurasWithMechanic((1<<MECHANIC_SNARE)|(1<<MECHANIC_ROOT));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveNotOwnSingleTargetAuras	(	uint32	newPhase = `0x0`,
		bool	phaseid = `false`
	)

 {
     // single target auras from other casters
     // Iterate m_ownedAuras - aura is marked as single target in Unit::AddAura (and pushed to m_ownedAuras).
     // m_appliedAuras will NOT contain the aura before first Unit::Update after adding it to m_ownedAuras.
     // Quickly removing such an aura will lead to it not being unregistered from caster's single cast auras container
     // leading to assertion failures if the aura was cast on a player that can
     // (and is changing map at the point where this function is called).
     // Such situation occurs when player is logging in inside an instance and fails the entry check for any reason.
     // The aura that was loaded from db (indirectly, via linked casts) gets removed before it has a chance
     // to register in m_appliedAuras
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         Aura const* aura = iter->second;
 
         if (aura->GetCasterGUID() != GetGUID() && aura->IsSingleTarget())
         {
             if (!newPhase && !phaseid)
                 RemoveOwnedAura(iter);
             else
             {
                 Unit* caster = aura->GetCaster();
                 if (!caster || (newPhase && !caster->IsInPhase(newPhase)) || (!newPhase && !caster->IsInPhase(this)))
                     RemoveOwnedAura(iter);
                 else
                     ++iter;
             }
         }
         else
             ++iter;
     }
 
     // single target auras at other targets
     AuraList& scAuras = GetSingleCastAuras();
     for (AuraList::iterator iter = scAuras.begin(); iter != scAuras.end();)
     {
         Aura* aura = *iter;
         if (aura->GetUnitOwner() != this && !aura->GetUnitOwner()->IsInPhase(newPhase))
         {
             aura->Remove();
             iter = scAuras.begin();
         }
         else
             ++iter;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveOwnedAura	(	AuraMap::iterator &	i,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     Aura* aura = i->second;
     ASSERT(!aura->IsRemoved());
 
     // if unit currently update aura list then make safe update iterator shift to next
     if (m_auraUpdateIterator == i)
         ++m_auraUpdateIterator;
 
     m_ownedAuras.erase(i);
     m_removedAuras.push_back(aura);
 
     // Unregister single target aura
     if (aura->IsSingleTarget())
         aura->UnregisterSingleTarget();
 
     aura->_Remove(removeMode);
 
     i = m_ownedAuras.begin();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveOwnedAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint32	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     for (AuraMap::iterator itr = m_ownedAuras.lower_bound(spellId); itr != m_ownedAuras.upper_bound(spellId);)
         if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask) && (!casterGUID || itr->second->GetCasterGUID() == casterGUID))
         {
             RemoveOwnedAura(itr, removeMode);
             itr = m_ownedAuras.lower_bound(spellId);
         }
         else
             ++itr;
 }

Here is the call graph for this function:

void Unit::RemoveOwnedAura	(	Aura *	aura,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

 {
     if (aura->IsRemoved())
         return;
 
     ASSERT(aura->GetOwner() == this);
 
     if (removeMode == AURA_REMOVE_NONE)
     {
         TC_LOG_ERROR("spells", "Unit::RemoveOwnedAura() called with unallowed removeMode AURA_REMOVE_NONE, spellId %u", aura->GetId());
         return;
     }
 
     uint32 spellId = aura->GetId();
     AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
 
     for (AuraMap::iterator itr = range.first; itr != range.second; ++itr)
     {
         if (itr->second == aura)
         {
             RemoveOwnedAura(itr, removeMode);
             return;
         }
     }
 
     ABORT();
 }

Here is the call graph for this function:

void Unit::RemoveOwnedAuras ( std::function< bool(Aura const *)> const & check )

 {
     for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
     {
         if (check(iter->second))
         {
             RemoveOwnedAura(iter);
             continue;
         }
         ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemoveOwnedAuras	(	uint32	spellId,
		std::function< bool(Aura const *)> const &	check
	)

 {
     for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId); iter != m_ownedAuras.upper_bound(spellId);)
     {
         if (check(iter->second))
         {
             RemoveOwnedAura(iter);
             continue;
         }
         ++iter;
     }
 }

Here is the call graph for this function:

void Unit::RemovePetAura ( PetAura const * petSpell )

 {
     if (GetTypeId() != TYPEID_PLAYER)
         return;
 
     m_petAuras.erase(petSpell);
     if (Pet* pet = ToPlayer()->GetPet())
         pet->RemoveAurasDueToSpell(petSpell->GetAura(pet->GetEntry()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemovePlayerFromVision ( Player * player )

 {
     m_sharedVision.remove(player);
     if (m_sharedVision.empty())
     {
         setActive(false);
         SetWorldObject(false);
     }
 }

Here is the call graph for this function:

void Unit::RemoveStandFlags ( uint8 flags )

inline

1494 { RemoveByteFlag(UNIT_FIELD_BYTES_1, 2, flags); }

Object::RemoveByteFlag

void RemoveByteFlag(uint16 index, uint8 offset, uint8 newFlag)

Definition: Object.cpp:1271

UNIT_FIELD_BYTES_1

Definition: UpdateFields.h:124

flags

uint8 flags

Definition: DisableMgr.cpp:44

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveUnitMovementFlag ( uint32 f )

inline

2108 { m_movementInfo.RemoveMovementFlag(f); }

MovementInfo::RemoveMovementFlag

void RemoveMovementFlag(uint32 flag)

Definition: Object.h:329

UNIT_FIELD_BASEATTACKTIME

MovementInfo m_movementInfo

Definition: Object.h:612

Here is the caller graph for this function:

void Unit::RemoveVehicleKit ( bool onRemoveFromWorld = false )

 {
     if (!m_vehicleKit)
         return;
 
     if (!onRemoveFromWorld)
         SendSetVehicleRecId(0);
 
     m_vehicleKit->Uninstall();
     delete m_vehicleKit;
 
     m_vehicleKit = NULL;
 
     m_updateFlag &= ~UPDATEFLAG_VEHICLE;
     m_unitTypeMask &= ~UNIT_MASK_VEHICLE;
     RemoveFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK | UNIT_NPC_FLAG_PLAYER_VEHICLE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RemoveVisibleAura ( uint8 slot )

 {
     m_visibleAuras.erase(slot);
     UpdateAuraForGroup(slot);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::resetAttackTimer ( WeaponAttackType type = BASE_ATTACK )

 {
     m_attackTimer[type] = uint32(GetAttackTime(type) * m_modAttackSpeedPct[type]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::ResetRedirectThreat ( )

inline

2155 { SetRedirectThreat(ObjectGuid::Empty, 0); }

ObjectGuid::Empty

static ObjectGuid const Empty

Definition: ObjectGuid.h:196

Unit::SetRedirectThreat

void SetRedirectThreat(ObjectGuid guid, uint32 pct)

Definition: Unit.h:2154

Here is the caller graph for this function:

void Unit::RestoreDisplayId ( )

 {
     AuraEffect* handledAura = NULL;
     // try to receive model from transform auras
     Unit::AuraEffectList const& transforms = GetAuraEffectsByType(SPELL_AURA_TRANSFORM);
     if (!transforms.empty())
     {
         // iterate over already applied transform auras - from newest to oldest
         for (Unit::AuraEffectList::const_reverse_iterator i = transforms.rbegin(); i != transforms.rend(); ++i)
         {
             if (AuraApplication const* aurApp = (*i)->GetBase()->GetApplicationOfTarget(GetGUID()))
             {
                 if (!handledAura)
                     handledAura = (*i);
                 // prefer negative auras
                 if (!aurApp->IsPositive())
                 {
                     handledAura = (*i);
                     break;
                 }
             }
         }
     }
     // transform aura was found
     if (handledAura)
         handledAura->HandleEffect(this, AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true);
     // we've found shapeshift
     else if (uint32 modelId = GetModelForForm(GetShapeshiftForm()))
         SetDisplayId(modelId);
     // no auras found - set modelid to default
     else
         SetDisplayId(GetNativeDisplayId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RestoreFaction ( )

 {
     if (GetTypeId() == TYPEID_PLAYER)
         ToPlayer()->setFactionForRace(getRace());
     else
     {
         if (HasUnitTypeMask(UNIT_MASK_MINION))
         {
             if (Unit* owner = GetOwner())
             {
                 setFaction(owner->getFaction());
                 return;
             }
         }
 
         if (CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate())  // normal creature
             setFaction(cinfo->faction);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::RewardRage	(	uint32	baseRage,
		bool	attacker
	)

ToDo: Check formula

 {
     float addRage;
 
     if (attacker)
     {
         addRage = baseRage;
         // talent who gave more rage on attack
         AddPct(addRage, GetTotalAuraModifier(SPELL_AURA_MOD_RAGE_FROM_DAMAGE_DEALT));
     }
     else
     {
         // Calculate rage from health and damage taken
         addRage = floor(0.5f + (25.7f * baseRage / GetMaxHealth()));
         // Berserker Rage effect
         if (HasAura(18499))
             addRage *= 2.0f;
     }
 
     addRage *= sWorld->getRate(RATE_POWER_RAGE_INCOME);
 
     ModifyPower(POWER_RAGE, uint32(addRage * 10));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

MeleeHitOutcome Unit::RollMeleeOutcomeAgainst	(	Unit const *	victim,
		WeaponAttackType	attType
	)		const

 {
     if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode())
         return MELEE_HIT_EVADE;
 
     // Miss chance based on melee
     //float miss_chance = MeleeMissChanceCalc(victim, attType);
     int32 miss_chance = int32(MeleeSpellMissChance(victim, attType, 0) * 100);
 
     // Critical hit chance
     int32 crit_chance = int32(GetUnitCriticalChance(attType, victim) * 100);
 
     // stunned target cannot dodge and this is check in GetUnitDodgeChance() (returned 0 in this case)
     int32 dodge_chance = int32(victim->GetUnitDodgeChanceAgainst(this) * 100);
     int32 block_chance = int32(victim->GetUnitBlockChanceAgainst(this) * 100);
     int32 parry_chance = int32(victim->GetUnitParryChanceAgainst(this) * 100);
 
     int32    sum = 0, tmp = 0;
     int32    roll = urand (0, 10000);
 
     int32 attackerLevel = getLevelForTarget(victim);
     int32 victimLevel = getLevelForTarget(this);
 
     TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: rolled %d, miss %d, dodge %d, parry %d, block %d, crit %d",
         roll, miss_chance, dodge_chance, parry_chance, block_chance, crit_chance);
 
     tmp = miss_chance;
 
     if (tmp > 0 && roll < (sum += tmp))
     {
         TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: MISS");
         return MELEE_HIT_MISS;
     }
 
     // always crit against a sitting target (except 0 crit chance)
     if (victim->GetTypeId() == TYPEID_PLAYER && crit_chance > 0 && !victim->IsStandState())
     {
         TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRIT (sitting victim)");
         return MELEE_HIT_CRIT;
     }
 
     // Dodge chance
 
     // only players can't dodge if attacker is behind
     if (victim->GetTypeId() == TYPEID_PLAYER && !victim->HasInArc(float(M_PI), this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
     {
         TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: attack came from behind and victim was a player.");
     }
     else
     {
         // Reduce dodge chance by attacker expertise rating
         if (GetTypeId() == TYPEID_PLAYER)
             dodge_chance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100);
         else
             dodge_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
         // Modify dodge chance by attacker SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
         dodge_chance += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
         dodge_chance = int32(float(dodge_chance) * GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
 
         tmp = dodge_chance;
         if ((tmp > 0)                                        // check if unit _can_ dodge
             && roll < (sum += tmp))
         {
             TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: DODGE <%d, %d)", sum - tmp, sum);
             return MELEE_HIT_DODGE;
         }
     }
 
     // parry & block chances
 
     // check if attack comes from behind, nobody can parry or block if attacker is behind
     if (!victim->HasInArc(float(M_PI), this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
         TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: attack came from behind.");
     else
     {
         // Reduce parry chance by attacker expertise rating
         if (GetTypeId() == TYPEID_PLAYER)
             parry_chance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100);
         else
             parry_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
         if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY))
         {
             int32 tmp2 = int32(parry_chance);
             if (tmp2 > 0                                         // check if unit _can_ parry
                 && roll < (sum += tmp2))
             {
                 TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: PARRY <%d, %d)", sum-tmp2, sum);
                 return MELEE_HIT_PARRY;
             }
         }
 
         if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK))
         {
             tmp = block_chance;
             if (tmp > 0                                          // check if unit _can_ block
                 && roll < (sum += tmp))
             {
                 TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: BLOCK <%d, %d)", sum-tmp, sum);
                 return MELEE_HIT_BLOCK;
             }
         }
     }
 
     // Critical chance
     tmp = crit_chance;
 
     if (tmp > 0 && roll < (sum += tmp))
     {
         TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRIT <%d, %d)", sum-tmp, sum);
         if (GetTypeId() == TYPEID_UNIT && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRIT))
             TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRIT DISABLED)");
         else
             return MELEE_HIT_CRIT;
     }
 
     // Max 40% chance to score a glancing blow against mobs that are higher level (can do only players and pets and not with ranged weapon)
     if (attType != RANGED_ATTACK &&
         (GetTypeId() == TYPEID_PLAYER || IsPet()) &&
         victim->GetTypeId() != TYPEID_PLAYER && !victim->IsPet() &&
         attackerLevel + 3 < victimLevel)
     {
         // cap possible value (with bonuses > max skill)
         tmp = (10 + 10 * (victimLevel - attackerLevel)) * 100;
         if (roll < (sum += tmp))
         {
             TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: GLANCING <%d, %d)", sum-4000, sum);
             return MELEE_HIT_GLANCING;
         }
     }
 
     // mobs can score crushing blows if they're 4 or more levels above victim
     if (attackerLevel >= victimLevel + 4 &&
         // can be from by creature (if can) or from controlled player that considered as creature
         !IsControlledByPlayer() &&
         !(GetTypeId() == TYPEID_UNIT && ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRUSH))
     {
         // add 2% chance per level, min. is 15%
         tmp = attackerLevel - victimLevel * 1000 - 1500;
         if (roll < (sum += tmp))
         {
             TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRUSHING <%d, %d)", sum-tmp, sum);
             return MELEE_HIT_CRUSHING;
         }
     }
 
     TC_LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: NORMAL");
     return MELEE_HIT_NORMAL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::Say	(	std::string const &	text,
		Language	language,
		WorldObject const *	target = `nullptr`
	)

virtual

 {
     Talk(text, CHAT_MSG_MONSTER_SAY, language, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::Say	(	uint32	textId,
		WorldObject const *	target = `nullptr`
	)

 {
     Talk(textId, CHAT_MSG_MONSTER_SAY, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
 }

Here is the call graph for this function:

Unit * Unit::SelectNearbyTarget	(	Unit *	exclude = `NULL`,
		float	dist = `NOMINAL_MELEE_RANGE`
	)		const

 {
     std::list<Unit*> targets;
     Trinity::AnyUnfriendlyUnitInObjectRangeCheck u_check(this, this, dist);
     Trinity::UnitListSearcher<Trinity::AnyUnfriendlyUnitInObjectRangeCheck> searcher(this, targets, u_check);
     VisitNearbyObject(dist, searcher);
 
     // remove current target
     if (GetVictim())
         targets.remove(GetVictim());
 
     if (exclude)
         targets.remove(exclude);
 
     // remove not LoS targets
     for (std::list<Unit*>::iterator tIter = targets.begin(); tIter != targets.end();)
     {
         if (!IsWithinLOSInMap(*tIter) || (*tIter)->IsTotem() || (*tIter)->IsSpiritService() || (*tIter)->IsCritter())
             targets.erase(tIter++);
         else
             ++tIter;
     }
 
     // no appropriate targets
     if (targets.empty())
         return NULL;
 
     // select random
     return Trinity::Containers::SelectRandomContainerElement(targets);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendAttackStateUpdate ( CalcDamageInfo * damageInfo )

 {
     WorldPackets::CombatLog::AttackerStateUpdate packet;
     packet.HitInfo = damageInfo->HitInfo;
     packet.AttackerGUID = damageInfo->attacker->GetGUID();
     packet.VictimGUID = damageInfo->target->GetGUID();
     packet.Damage = damageInfo->damage;
     int32 overkill = damageInfo->damage - damageInfo->target->GetHealth();
     packet.OverDamage = (overkill < 0 ? -1 : overkill);
 
     packet.SubDmg = boost::in_place();
     packet.SubDmg->SchoolMask = damageInfo->damageSchoolMask;   // School of sub damage
     packet.SubDmg->FDamage = damageInfo->damage;                // sub damage
     packet.SubDmg->Damage = damageInfo->damage;                 // Sub Damage
     packet.SubDmg->Absorbed = damageInfo->absorb;
     packet.SubDmg->Resisted = damageInfo->resist;
 
     packet.VictimState = damageInfo->TargetState;
     packet.BlockAmount = damageInfo->blocked_amount;
 
     packet.LogData.Initialize(damageInfo->attacker);
 
     SendCombatLogMessage(&packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendAttackStateUpdate	(	uint32	HitInfo,
		Unit *	target,
		uint8	SwingType,
		SpellSchoolMask	damageSchoolMask,
		uint32	Damage,
		uint32	AbsorbDamage,
		uint32	Resist,
		VictimState	TargetState,
		uint32	BlockedAmount
	)

 {
     CalcDamageInfo dmgInfo;
     dmgInfo.HitInfo = HitInfo;
     dmgInfo.attacker = this;
     dmgInfo.target = target;
     dmgInfo.damage = Damage - AbsorbDamage - Resist - BlockedAmount;
     dmgInfo.damageSchoolMask = damageSchoolMask;
     dmgInfo.absorb = AbsorbDamage;
     dmgInfo.resist = Resist;
     dmgInfo.TargetState = TargetState;
     dmgInfo.blocked_amount = BlockedAmount;
     SendAttackStateUpdate(&dmgInfo);
 }

Here is the call graph for this function:

void Unit::SendChangeCurrentVictimOpcode ( HostileReference * pHostileReference )

 {
     if (!getThreatManager().isThreatListEmpty())
     {
         WorldPackets::Combat::HighestThreatUpdate packet;
         packet.UnitGUID = GetGUID();
         packet.HighestThreatGUID = pHostileReference->getUnitGuid();
         ThreatContainer::StorageType const &tlist = getThreatManager().getThreatList();
         packet.ThreatList.reserve(tlist.size());
         for (ThreatContainer::StorageType::const_iterator itr = tlist.begin(); itr != tlist.end(); ++itr)
         {
             WorldPackets::Combat::ThreatInfo info;
             info.UnitGUID = (*itr)->getUnitGuid();
             info.Threat = int32((*itr)->getThreat() * 100);
             packet.ThreatList.push_back(info);
         }
         SendMessageToSet(packet.Write(), false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendClearTarget ( )

 {
     WorldPackets::Combat::BreakTarget breakTarget;
     breakTarget.UnitGUID = GetGUID();
     SendMessageToSet(breakTarget.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendClearThreatListOpcode ( )

 {
     WorldPackets::Combat::ThreatClear packet;
     packet.UnitGUID = GetGUID();
     SendMessageToSet(packet.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendCombatLogMessage ( WorldPackets::CombatLog::CombatLogServerPacket * combatLog ) const

 {
     CombatLogSender notifier(this, combatLog, GetVisibilityRange());
     VisitNearbyWorldObject(GetVisibilityRange(), notifier);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendDurabilityLoss	(	Player *	receiver,
		uint32	percent
	)

 {
     WorldPackets::Misc::DurabilityDamageDeath packet;
     packet.Percent = percent;
     receiver->GetSession()->SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendEnergizeSpellLog	(	Unit *	victim,
		uint32	spellID,
		int32	damage,
		Powers	powertype
	)

 {
     WorldPackets::CombatLog::SpellEnergizeLog data;
     data.CasterGUID = GetGUID();
     data.TargetGUID = victim->GetGUID();
     data.SpellID = spellId;
     data.Type = powerType;
     data.Amount = damage;
     data.LogData.Initialize(victim);
     SendCombatLogMessage(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendHealSpellLog	(	Unit *	victim,
		uint32	spellID,
		uint32	health,
		uint32	overHeal,
		uint32	absorbed,
		bool	crit = `false`
	)

Todo:: : 6.x Has to be implemented

 {
     WorldPackets::CombatLog::SpellHealLog spellHealLog;
 
     TC_LOG_DEBUG("spells", "HealSpellLog -- SpellId: %u Caster: %s Target: %s (Health: %u OverHeal: %u Absorbed: %u Crit: %d)", spellID, GetGUID().ToString().c_str(), victim->GetGUID().ToString().c_str(),
         health, overHeal, absorbed, crit);
 
     spellHealLog.TargetGUID = victim->GetGUID();
     spellHealLog.CasterGUID = GetGUID();
 
     spellHealLog.SpellID = spellID;
     spellHealLog.Health = health;
     spellHealLog.OverHeal = overHeal;
     spellHealLog.Absorbed = absorbed;
 
     spellHealLog.Crit = crit;
 
     /*
     packet.ReadBit("Multistrike");
 
     var hasCritRollMade = packet.ReadBit("HasCritRollMade");
     var hasCritRollNeeded = packet.ReadBit("HasCritRollNeeded");
     var hasLogData = packet.ReadBit("HasLogData");
 
     if (hasCritRollMade)
         packet.ReadSingle("CritRollMade");
 
     if (hasCritRollNeeded)
         packet.ReadSingle("CritRollNeeded");
 
     if (hasLogData)
         SpellParsers.ReadSpellCastLogData(packet);
     */
 
     spellHealLog.LogData.Initialize(victim);
     SendCombatLogMessage(&spellHealLog);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendMeleeAttackStart ( Unit * victim )

 {
     WorldPackets::Combat::AttackStart packet;
     packet.Attacker = GetGUID();
     packet.Victim = victim->GetGUID();
     SendMessageToSet(packet.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendMeleeAttackStop ( Unit * victim = NULL )

 {
     SendMessageToSet(WorldPackets::Combat::SAttackStop(this, victim).Write(), true);
 
     if (victim)
         TC_LOG_DEBUG("entities.unit", "%s stopped attacking %s", GetGUID().ToString().c_str(), victim->GetGUID().ToString().c_str());
     else
         TC_LOG_DEBUG("entities.unit", "%s stopped attacking", GetGUID().ToString().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendMoveKnockBack	(	Player *	player,
		float	speedXY,
		float	speedZ,
		float	vcos,
		float	vsin
	)

 {
     WorldPackets::Movement::MoveKnockBack moveKnockBack;
     moveKnockBack.MoverGUID = GetGUID();
     moveKnockBack.SequenceIndex = m_movementCounter++;
     moveKnockBack.HorzSpeed = speedXY;
     moveKnockBack.VertSpeed = speedZ;
     moveKnockBack.Direction.x = vcos;
     moveKnockBack.Direction.y = vsin;
     player->GetSession()->SendPacket(moveKnockBack.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendPeriodicAuraLog ( SpellPeriodicAuraLogInfo * pInfo )

Todo:: : should send more logs in one packet when multistrike

Todo:: : implement debug info

 {
     AuraEffect const* aura = info->auraEff;
     WorldPackets::CombatLog::SpellPeriodicAuraLog data;
     data.TargetGUID = GetGUID();
     data.CasterGUID = aura->GetCasterGUID();
     data.SpellID = aura->GetId();
     data.LogData.Initialize(this);
 
     WorldPackets::CombatLog::SpellPeriodicAuraLog::SpellLogEffect spellLogEffect;
     spellLogEffect.Effect = aura->GetAuraType();
     spellLogEffect.Amount = info->damage;
     spellLogEffect.OverHealOrKill = info->overDamage;
     spellLogEffect.SchoolMaskOrPower = aura->GetSpellInfo()->GetSchoolMask();
     spellLogEffect.AbsorbedOrAmplitude = info->absorb;
     spellLogEffect.Resisted = info->resist;
     spellLogEffect.Crit = info->critical;
     spellLogEffect.Multistrike = false; // NYI
 
     data.Effects.push_back(spellLogEffect);
 
     SendCombatLogMessage(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendPetActionFeedback ( uint8 msg )

-------—Pet responses methods--------------—

 {
     Unit* owner = GetOwner();
     if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
         return;
 
     WorldPacket data(SMSG_PET_ACTION_FEEDBACK, 1);
     data << uint8(msg);
     owner->ToPlayer()->GetSession()->SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendPetAIReaction ( ObjectGuid guid )

 {
     Unit* owner = GetOwner();
     if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
         return;
 
     WorldPackets::Combat::AIReaction packet;
     packet.UnitGUID = guid;
     packet.Reaction = AI_REACTION_HOSTILE;
     owner->ToPlayer()->SendDirectMessage(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendPetTalk ( uint32 pettalk )

 {
     Unit* owner = GetOwner();
     if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
         return;
 
     WorldPacket data(SMSG_PET_ACTION_SOUND, 8 + 4);
     data << GetGUID();
     data << uint32(pettalk);
     owner->ToPlayer()->GetSession()->SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendPlaySpellVisualKit	(	uint32	id,
		uint32	type
	)

 {
     WorldPackets::Spells::PlaySpellVisualKit playSpellVisualKit;
     playSpellVisualKit.Unit = GetGUID();
     playSpellVisualKit.KitRecID = id;
     playSpellVisualKit.KitType = type;
     playSpellVisualKit.Duration = 0;
     SendMessageToSet(playSpellVisualKit.Write(), true);
 }

Here is the call graph for this function:

void Unit::SendRemoveFromThreatListOpcode ( HostileReference * pHostileReference )

 {
     WorldPackets::Combat::ThreatRemove packet;
     packet.UnitGUID = GetGUID();
     packet.AboutGUID = pHostileReference->getUnitGuid();
     SendMessageToSet(packet.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendSetPlayHoverAnim ( bool enable )

 {
     WorldPackets::Misc::SetPlayHoverAnim data;
     data.UnitGUID = GetGUID();
     data.PlayHoverAnim = enable;
 
     SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

void Unit::SendSetVehicleRecId ( uint32 vehicleId )

 {
     if (Player* player = ToPlayer())
     {
         WorldPackets::Vehicle::MoveSetVehicleRecID moveSetVehicleRec;
         moveSetVehicleRec.MoverGUID = GetGUID();
         moveSetVehicleRec.SequenceIndex = m_movementCounter++;
         moveSetVehicleRec.VehicleRecID = vehicleId;
         player->SendDirectMessage(moveSetVehicleRec.Write());
     }
 
     WorldPackets::Vehicle::SetVehicleRecID setVehicleRec;
     setVehicleRec.VehicleGUID = GetGUID();
     setVehicleRec.VehicleRecID = vehicleId;
     SendMessageToSet(setVehicleRec.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendSpellDamageImmune	(	Unit *	target,
		uint32	spellId,
		bool	isPeriodic
	)

 {
     WorldPackets::CombatLog::SpellOrDamageImmune spellOrDamageImmune;
     spellOrDamageImmune.CasterGUID = GetGUID();
     spellOrDamageImmune.VictimGUID = target->GetGUID();
     spellOrDamageImmune.SpellID = spellId;
     spellOrDamageImmune.IsPeriodic = isPeriodic;
     SendMessageToSet(spellOrDamageImmune.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendSpellDamageResist	(	Unit *	target,
		uint32	spellId
	)

 {
     WorldPackets::CombatLog::ProcResist procResist;
     procResist.Caster = GetGUID();
     procResist.SpellID = spellId;
     procResist.Target = target->GetGUID();
     SendMessageToSet(procResist.Write(), true);
 }

Here is the call graph for this function:

void Unit::SendSpellMiss	(	Unit *	target,
		uint32	spellID,
		SpellMissInfo	missInfo
	)

 {
     WorldPackets::CombatLog::SpellMissLog spellMissLog;
     spellMissLog.SpellID = spellID;
     spellMissLog.Caster = GetGUID();
     spellMissLog.Entries.emplace_back(target->GetGUID(), missInfo);
     SendMessageToSet(spellMissLog.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendSpellNonMeleeDamageLog ( SpellNonMeleeDamage const * log )

 {
     WorldPackets::CombatLog::SpellNonMeleeDamageLog packet;
     packet.Me = log->target->GetGUID();
     packet.CasterGUID = log->attacker->GetGUID();
     packet.SpellID = log->SpellID;
     packet.Damage = log->damage;
     if (log->damage > log->preHitHealth)
         packet.Overkill = log->damage - log->preHitHealth;
     else
         packet.Overkill = 0;
 
     packet.SchoolMask = log->schoolMask;
     packet.ShieldBlock = log->blocked;
     packet.Resisted = log->resist;
     packet.Absorbed = log->absorb;
     packet.Periodic = log->periodicLog;
     packet.Flags = log->HitInfo;
     SendCombatLogMessage(&packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendTeleportPacket ( Position & pos )

 {
     // SMSG_MOVE_UPDATE_TELEPORT is sent to nearby players to signal the teleport
     // SMSG_MOVE_TELEPORT is sent to self in order to trigger CMSG_MOVE_TELEPORT_ACK and update the position server side
 
     WorldPackets::Movement::MoveUpdateTeleport moveUpdateTeleport;
     moveUpdateTeleport.movementInfo = &m_movementInfo;
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         WorldPackets::Movement::MoveTeleport moveTeleport;
         moveTeleport.MoverGUID = GetGUID();
         moveTeleport.Pos.Relocate(pos);
         if (TransportBase* transportBase = GetDirectTransport())
             transportBase->CalculatePassengerOffset(moveTeleport.Pos.m_positionX, moveTeleport.Pos.m_positionY, moveTeleport.Pos.m_positionZ);
         moveTeleport.TransportGUID = GetTransGUID();
         moveTeleport.Facing = pos.GetOrientation();
         moveTeleport.SequenceIndex = m_movementCounter++;
         ToPlayer()->SendDirectMessage(moveTeleport.Write());
     }
     else
     {
         // This is the only packet sent for creatures which contains MovementInfo structure
         // we do not update m_movementInfo for creatures so it needs to be done manually here
         moveUpdateTeleport.movementInfo->guid = GetGUID();
         moveUpdateTeleport.movementInfo->pos.Relocate(pos);
         moveUpdateTeleport.movementInfo->time = getMSTime();
     }
 
     // Broadcast the packet to everyone except self.
     SendMessageToSet(moveUpdateTeleport.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SendThreatListUpdate ( )

 {
     if (!getThreatManager().isThreatListEmpty())
     {
         WorldPackets::Combat::ThreatUpdate packet;
         packet.UnitGUID = GetGUID();
         ThreatContainer::StorageType const &tlist = getThreatManager().getThreatList();
         packet.ThreatList.reserve(tlist.size());
         for (ThreatContainer::StorageType::const_iterator itr = tlist.begin(); itr != tlist.end(); ++itr)
         {
             WorldPackets::Combat::ThreatInfo info;
             info.UnitGUID = (*itr)->getUnitGuid();
             info.Threat = (*itr)->getThreat() * 100;
             packet.ThreatList.push_back(info);
         }
         SendMessageToSet(packet.Write(), false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetAI ( UnitAI * newAI )

inline

1332 { i_AI = newAI; }

Unit::i_AI

UnitAI * i_AI

Definition: Unit.h:2242

Here is the caller graph for this function:

void Unit::SetAIAnimKitId ( uint16 animKitId )

 {
     if (_aiAnimKitId == animKitId)
         return;
 
     if (animKitId && !sAnimKitStore.LookupEntry(animKitId))
         return;
 
     _aiAnimKitId = animKitId;
 
     WorldPackets::Misc::SetAIAnimKit data;
     data.Unit = GetGUID();
     data.AnimKitID = animKitId;
     SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

void Unit::SetArmor ( int32 val )

inline

1420 { SetResistance(SPELL_SCHOOL_NORMAL, val); }

Unit::SetResistance

void SetResistance(SpellSchools school, int32 val)

Definition: Unit.h:1424

SPELL_SCHOOL_NORMAL

Definition: SharedDefines.h:274

Here is the caller graph for this function:

void Unit::SetAttackTime	(	WeaponAttackType	att,
		uint32	val
	)

inline

1458 { SetFloatValue(UNIT_FIELD_BASEATTACKTIME + att, val*m_modAttackSpeedPct[att]); }

Definition: UpdateFields.h:113

Unit::m_modAttackSpeedPct

float m_modAttackSpeedPct[3]

Definition: Unit.h:1945

Object::SetFloatValue

void SetFloatValue(uint16 index, float value)

Definition: Object.cpp:1067

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::setAttackTimer	(	WeaponAttackType	type,
		uint32	time
	)

inline

1354 { m_attackTimer[type] = time; }

Unit::m_attackTimer

uint32 m_attackTimer[MAX_ATTACK]

Definition: Unit.h:2251

Here is the caller graph for this function:

void Unit::SetAuraStack	(	uint32	spellId,
		Unit *	target,
		uint32	stack
	)

 {
     Aura* aura = target->GetAura(spellId, GetGUID());
     if (!aura)
         aura = AddAura(spellId, target);
     if (aura && stack)
         aura->SetStackAmount(stack);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetBaseWeaponDamage	(	WeaponAttackType	attType,
		WeaponDamageRange	damageRange,
		float	value
	)

inline

1972 { m_weaponDamage[attType][damageRange] = value; }

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

Unit::m_weaponDamage

float m_weaponDamage[MAX_ATTACK][2]

Definition: Unit.h:2286

Here is the caller graph for this function:

virtual void Unit::SetCanDualWield ( bool value )

inlinevirtual

Reimplemented in Creature.

1360 { m_canDualWield = value; }

Unit::m_canDualWield

bool m_canDualWield

Definition: Unit.h:1367

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

Here is the caller graph for this function:

bool Unit::SetCanFly ( bool enable )

 {
     if (enable == HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
         return false;
 
     if (enable)
     {
         AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
         RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_SPLINE_ELEVATION);
         SetFall(false);
     }
     else
     {
         RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_MASK_MOVING_FLY);
         if (!IsLevitating())
             SetFall(true);
     }
 
     static OpcodeServer const flyOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_UNSET_FLYING, SMSG_MOVE_UNSET_CAN_FLY },
         { SMSG_MOVE_SPLINE_SET_FLYING,   SMSG_MOVE_SET_CAN_FLY   }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(flyOpcodeTable[enable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(flyOpcodeTable[enable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCanModifyStats ( bool modifyStats )

inline

1960 { m_canModifyStats = modifyStats; }

Unit::m_canModifyStats

bool m_canModifyStats

Definition: Unit.h:2287

Here is the caller graph for this function:

void Unit::SetCantProc ( bool apply )

 {
     if (apply)
         ++m_procDeep;
     else
     {
         ASSERT(m_procDeep);
         --m_procDeep;
     }
 }

Here is the caller graph for this function:

void Unit::SetChannelObjectGuid ( ObjectGuid guid )

inline

1905 { SetGuidValue(UNIT_FIELD_CHANNEL_OBJECT, guid); }

UNIT_FIELD_CHANNEL_OBJECT

void SetGuidValue(uint16 index, ObjectGuid const &value)

Definition: Object.cpp:1120

Definition: UpdateFields.h:92

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCharm	(	Unit *	target,
		bool	apply
	)

Todo:: maybe we can use this flag to check if controlled by player

 {
     if (apply)
     {
         if (GetTypeId() == TYPEID_PLAYER)
         {
             if (!AddGuidValue(UNIT_FIELD_CHARM, charm->GetGUID()))
                 TC_LOG_FATAL("entities.unit", "Player %s is trying to charm unit %u, but it already has a charmed unit %s", GetName().c_str(), charm->GetEntry(), GetCharmGUID().ToString().c_str());
 
             charm->m_ControlledByPlayer = true;
             charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
         }
         else
             charm->m_ControlledByPlayer = false;
 
         // PvP, FFAPvP
         charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, GetByteValue(UNIT_FIELD_BYTES_2, 1));
 
         if (!charm->AddGuidValue(UNIT_FIELD_CHARMEDBY, GetGUID()))
             TC_LOG_FATAL("entities.unit", "Unit %u is being charmed, but it already has a charmer %s", charm->GetEntry(), charm->GetCharmerGUID().ToString().c_str());
 
         _isWalkingBeforeCharm = charm->IsWalking();
         if (_isWalkingBeforeCharm)
             charm->SetWalk(false);
 
         m_Controlled.insert(charm);
     }
     else
     {
         if (GetTypeId() == TYPEID_PLAYER)
         {
             if (!RemoveGuidValue(UNIT_FIELD_CHARM, charm->GetGUID()))
                 TC_LOG_FATAL("entities.unit", "Player %s is trying to uncharm unit %u, but it has another charmed unit %s", GetName().c_str(), charm->GetEntry(), GetCharmGUID().ToString().c_str());
         }
 
         if (!charm->RemoveGuidValue(UNIT_FIELD_CHARMEDBY, GetGUID()))
             TC_LOG_FATAL("entities.unit", "Unit %u is being uncharmed, but it has another charmer %s", charm->GetEntry(), charm->GetCharmerGUID().ToString().c_str());
 
         if (charm->GetTypeId() == TYPEID_PLAYER)
         {
             charm->m_ControlledByPlayer = true;
             charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
             charm->ToPlayer()->UpdatePvPState();
         }
         else if (Player* player = charm->GetCharmerOrOwnerPlayerOrPlayerItself())
         {
             charm->m_ControlledByPlayer = true;
             charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
             charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, player->GetByteValue(UNIT_FIELD_BYTES_2, 1));
         }
         else
         {
             charm->m_ControlledByPlayer = false;
             charm->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
             charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, 0);
         }
 
         if (charm->IsWalking() != _isWalkingBeforeCharm)
             charm->SetWalk(_isWalkingBeforeCharm);
 
         if (charm->GetTypeId() == TYPEID_PLAYER
             || !charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_MINION)
             || charm->GetOwnerGUID() != GetGUID())
         {
             m_Controlled.erase(charm);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetCharmedBy	(	Unit *	charmer,
		CharmType	type,
		AuraApplication const *	aurApp = `NULL`
	)

Todo:: CombatStop(true) may cause crash (interrupt spells)

 {
     if (!charmer)
         return false;
 
     // dismount players when charmed
     if (GetTypeId() == TYPEID_PLAYER)
         RemoveAurasByType(SPELL_AURA_MOUNTED);
 
     if (charmer->GetTypeId() == TYPEID_PLAYER)
         charmer->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
     ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
     ASSERT((type == CHARM_TYPE_VEHICLE) == IsVehicle());
 
     TC_LOG_DEBUG("entities.unit", "SetCharmedBy: charmer %u (%s), charmed %u (%s), type %u.", charmer->GetEntry(), charmer->GetGUID().ToString().c_str(), GetEntry(), GetGUID().ToString().c_str(), uint32(type));
 
     if (this == charmer)
     {
         TC_LOG_FATAL("entities.unit", "Unit::SetCharmedBy: Unit %u (%s) is trying to charm itself!", GetEntry(), GetGUID().ToString().c_str());
         return false;
     }
 
     //if (HasUnitState(UNIT_STATE_UNATTACKABLE))
     //    return false;
 
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetTransport())
     {
         TC_LOG_FATAL("entities.unit", "Unit::SetCharmedBy: Player on transport is trying to charm %u (%s)", GetEntry(), GetGUID().ToString().c_str());
         return false;
     }
 
     // Already charmed
     if (!GetCharmerGUID().IsEmpty())
     {
         TC_LOG_FATAL("entities.unit", "Unit::SetCharmedBy: %u (%s) has already been charmed but %u (%s) is trying to charm it!", GetEntry(), GetGUID().ToString().c_str(), charmer->GetEntry(), charmer->GetGUID().ToString().c_str());
         return false;
     }
 
     CastStop();
     CombatStop(); 
     DeleteThreatList();
 
     Player* playerCharmer = charmer->ToPlayer();
 
     // Charmer stop charming
     if (playerCharmer)
     {
         playerCharmer->StopCastingCharm();
         playerCharmer->StopCastingBindSight();
     }
 
     // Charmed stop charming
     if (GetTypeId() == TYPEID_PLAYER)
     {
         ToPlayer()->StopCastingCharm();
         ToPlayer()->StopCastingBindSight();
     }
 
     // StopCastingCharm may remove a possessed pet?
     if (!IsInWorld())
     {
         TC_LOG_FATAL("entities.unit", "Unit::SetCharmedBy: %u (%s) is not in world but %u (%s) is trying to charm it!", GetEntry(), GetGUID().ToString().c_str(), charmer->GetEntry(), charmer->GetGUID().ToString().c_str());
         return false;
     }
 
     // charm is set by aura, and aura effect remove handler was called during apply handler execution
     // prevent undefined behaviour
     if (aurApp && aurApp->GetRemoveMode())
         return false;
 
     _oldFactionId = getFaction();
     setFaction(charmer->getFaction());
 
     // Set charmed
     charmer->SetCharm(this, true);
 
     if (GetTypeId() == TYPEID_UNIT)
     {
         ToCreature()->AI()->OnCharmed(true);
         GetMotionMaster()->MoveIdle();
     }
     else
     {
         Player* player = ToPlayer();
         if (player->isAFK())
             player->ToggleAFK();
         player->SetClientControl(this, false);
     }
 
     // charm is set by aura, and aura effect remove handler was called during apply handler execution
     // prevent undefined behaviour
     if (aurApp && aurApp->GetRemoveMode())
         return false;
 
     // Pets already have a properly initialized CharmInfo, don't overwrite it.
     if (type != CHARM_TYPE_VEHICLE && !GetCharmInfo())
     {
         InitCharmInfo();
         if (type == CHARM_TYPE_POSSESS)
             GetCharmInfo()->InitPossessCreateSpells();
         else
             GetCharmInfo()->InitCharmCreateSpells();
     }
 
     if (playerCharmer)
     {
         switch (type)
         {
             case CHARM_TYPE_VEHICLE:
                 SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
                 playerCharmer->SetClientControl(this, true);
                 playerCharmer->VehicleSpellInitialize();
                 break;
             case CHARM_TYPE_POSSESS:
                 AddUnitState(UNIT_STATE_POSSESSED);
                 SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
                 charmer->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
                 playerCharmer->SetClientControl(this, true);
                 playerCharmer->PossessSpellInitialize();
                 break;
             case CHARM_TYPE_CHARM:
                 if (GetTypeId() == TYPEID_UNIT && charmer->getClass() == CLASS_WARLOCK)
                 {
                     CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate();
                     if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
                     {
                         // to prevent client crash
                         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_CLASS, (uint8)CLASS_MAGE);
 
                         // just to enable stat window
                         if (GetCharmInfo())
                             GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
 
                         // if charmed two demons the same session, the 2nd gets the 1st one's name
                         SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(time(NULL))); // cast can't be helped
                     }
                 }
                 playerCharmer->CharmSpellInitialize();
                 break;
             default:
             case CHARM_TYPE_CONVERT:
                 break;
         }
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCharmerGUID ( ObjectGuid owner )

inline

1705 { SetGuidValue(UNIT_FIELD_CHARMEDBY, owner); }

UNIT_FIELD_CHARMEDBY

Definition: UpdateFields.h:85

void SetGuidValue(uint16 index, ObjectGuid const &value)

Definition: Object.cpp:1120

Here is the call graph for this function:

bool Unit::SetCollision ( bool disable )

 {
     if (disable == HasUnitMovementFlag(MOVEMENTFLAG_DISABLE_COLLISION))
         return false;
 
     if (disable)
         AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_COLLISION);
     else
         RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_COLLISION);
 
     static OpcodeServer const collisionOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_ENABLE_COLLISION,  SMSG_MOVE_ENABLE_COLLISION },
         { SMSG_MOVE_SPLINE_DISABLE_COLLISION, SMSG_MOVE_DISABLE_COLLISION }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(collisionOpcodeTable[disable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(collisionOpcodeTable[disable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

void Unit::SetConfused ( bool apply )

protected

 {
     if (apply)
     {
         SetTarget(ObjectGuid::Empty);
         GetMotionMaster()->MoveConfused();
     }
     else
     {
         if (IsAlive())
         {
             if (GetMotionMaster()->GetCurrentMovementGeneratorType() == CONFUSED_MOTION_TYPE)
                 GetMotionMaster()->MovementExpired();
             if (GetVictim())
                 SetTarget(EnsureVictim()->GetGUID());
         }
     }
 
     if (Player* player = ToPlayer())
         if (!player->HasUnitState(UNIT_STATE_POSSESSED))
             player->SetClientControl(this, !apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetContestedPvP ( Player * attackedPlayer = NULL )

 {
     Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
 
     if (!player || (attackedPlayer && (attackedPlayer == player || (player->duel && player->duel->opponent == attackedPlayer))))
         return;
 
     player->SetContestedPvPTimer(30000);
     if (!player->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
     {
         player->AddUnitState(UNIT_STATE_ATTACK_PLAYER);
         player->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP);
         // call MoveInLineOfSight for nearby contested guards
         UpdateObjectVisibility();
     }
     if (!HasUnitState(UNIT_STATE_ATTACK_PLAYER))
     {
         AddUnitState(UNIT_STATE_ATTACK_PLAYER);
         // call MoveInLineOfSight for nearby contested guards
         UpdateObjectVisibility();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetControlled	(	bool	apply,
		UnitState	state
	)

 {
     if (apply)
     {
         if (HasUnitState(state))
             return;
 
         AddUnitState(state);
         switch (state)
         {
             case UNIT_STATE_STUNNED:
                 SetStunned(true);
                 CastStop();
                 break;
             case UNIT_STATE_ROOT:
                 if (!HasUnitState(UNIT_STATE_STUNNED))
                     SetRooted(true);
                 break;
             case UNIT_STATE_CONFUSED:
                 if (!HasUnitState(UNIT_STATE_STUNNED))
                 {
                     ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                     SendMeleeAttackStop();
                     // SendAutoRepeatCancel ?
                     SetConfused(true);
                     CastStop();
                 }
                 break;
             case UNIT_STATE_FLEEING:
                 if (!HasUnitState(UNIT_STATE_STUNNED | UNIT_STATE_CONFUSED))
                 {
                     ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                     SendMeleeAttackStop();
                     // SendAutoRepeatCancel ?
                     SetFeared(true);
                     CastStop();
                 }
                 break;
             default:
                 break;
         }
     }
     else
     {
         switch (state)
         {
             case UNIT_STATE_STUNNED:
                 if (HasAuraType(SPELL_AURA_MOD_STUN))
                     return;
 
                 SetStunned(false);
                 break;
             case UNIT_STATE_ROOT:
                 if (HasAuraType(SPELL_AURA_MOD_ROOT) || GetVehicle())
                     return;
 
                 if (!HasUnitState(UNIT_STATE_STUNNED))
                     SetRooted(false);
                 break;
             case UNIT_STATE_CONFUSED:
                 if (HasAuraType(SPELL_AURA_MOD_CONFUSE))
                     return;
 
                 SetConfused(false);
                 break;
             case UNIT_STATE_FLEEING:
                 if (HasAuraType(SPELL_AURA_MOD_FEAR))
                     return;
 
                 SetFeared(false);
                 break;
             default:
                 return;
         }
 
         ClearUnitState(state);
 
         // Unit States might have been already cleared but auras still present. I need to check with HasAuraType
         if (HasAuraType(SPELL_AURA_MOD_STUN))
             SetStunned(true);
         else
         {
             if (HasAuraType(SPELL_AURA_MOD_ROOT))
                 SetRooted(true);
 
             if (HasAuraType(SPELL_AURA_MOD_CONFUSE))
                 SetConfused(true);
             else if (HasAuraType(SPELL_AURA_MOD_FEAR))
                 SetFeared(true);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCreateHealth ( uint32 val )

inline

1894 { SetUInt32Value(UNIT_FIELD_BASE_HEALTH, val); }

void SetUInt32Value(uint16 index, uint32 value)

Definition: Object.cpp:996

UNIT_FIELD_BASE_HEALTH

Definition: UpdateFields.h:145

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCreateMana ( uint32 val )

inline

1896 { SetUInt32Value(UNIT_FIELD_BASE_MANA, val); }

void SetUInt32Value(uint16 index, uint32 value)

Definition: Object.cpp:996

UNIT_FIELD_BASE_MANA

Definition: UpdateFields.h:144

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCreateStat	(	Stats	stat,
		float	val
	)

inline

1893 { m_createStats[stat] = val; }

Unit::m_createStats

float m_createStats[MAX_STATS]

Definition: Unit.h:2253

Here is the caller graph for this function:

void Unit::SetCreatorGUID ( ObjectGuid creator )

inline

1701 { SetGuidValue(UNIT_FIELD_CREATEDBY, creator); }

void SetGuidValue(uint16 index, ObjectGuid const &value)

Definition: Object.cpp:1120

UNIT_FIELD_CREATEDBY

Definition: UpdateFields.h:87

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCritterGUID ( ObjectGuid guid )

inline

1709 { SetGuidValue(UNIT_FIELD_CRITTER, guid); }

UNIT_FIELD_CRITTER

Definition: UpdateFields.h:84

void SetGuidValue(uint16 index, ObjectGuid const &value)

Definition: Object.cpp:1120

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetCurrentCastSpell ( Spell * pSpell )

 {
     ASSERT(pSpell);                                         // NULL may be never passed here, use InterruptSpell or InterruptNonMeleeSpells
 
     CurrentSpellTypes CSpellType = pSpell->GetCurrentContainer();
 
     if (pSpell == m_currentSpells[CSpellType])             // avoid breaking self
         return;
 
     // break same type spell if it is not delayed
     InterruptSpell(CSpellType, false);
 
     // special breakage effects:
     switch (CSpellType)
     {
         case CURRENT_GENERIC_SPELL:
         {
             // generic spells always break channeled not delayed spells
             InterruptSpell(CURRENT_CHANNELED_SPELL, false);
 
             // autorepeat breaking
             if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
             {
                 // break autorepeat if not Auto Shot
                 if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->GetSpellInfo()->Id != 75)
                     InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
                 m_AutoRepeatFirstCast = true;
             }
             if (pSpell->GetCastTime() > 0)
                 AddUnitState(UNIT_STATE_CASTING);
 
             break;
         }
         case CURRENT_CHANNELED_SPELL:
         {
             // channel spells always break generic non-delayed and any channeled spells
             InterruptSpell(CURRENT_GENERIC_SPELL, false);
             InterruptSpell(CURRENT_CHANNELED_SPELL);
 
             // it also does break autorepeat if not Auto Shot
             if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL] &&
                 m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->GetSpellInfo()->Id != 75)
                 InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
             AddUnitState(UNIT_STATE_CASTING);
 
             break;
         }
         case CURRENT_AUTOREPEAT_SPELL:
         {
             // only Auto Shoot does not break anything
             if (pSpell->GetSpellInfo()->Id != 75)
             {
                 // generic autorepeats break generic non-delayed and channeled non-delayed spells
                 InterruptSpell(CURRENT_GENERIC_SPELL, false);
                 InterruptSpell(CURRENT_CHANNELED_SPELL, false);
             }
             // special action: set first cast flag
             m_AutoRepeatFirstCast = true;
 
             break;
         }
         default:
             break; // other spell types don't break anything now
     }
 
     // current spell (if it is still here) may be safely deleted now
     if (m_currentSpells[CSpellType])
         m_currentSpells[CSpellType]->SetReferencedFromCurrent(false);
 
     // set new current spell
     m_currentSpells[CSpellType] = pSpell;
     pSpell->SetReferencedFromCurrent(true);
 
     pSpell->m_selfContainer = &(m_currentSpells[pSpell->GetCurrentContainer()]);
 }

Here is the call graph for this function:

void Unit::setDeathState ( DeathState s )

virtual

Reimplemented in Creature, and Pet.

 {
     // Death state needs to be updated before RemoveAllAurasOnDeath() is called, to prevent entering combat
     m_deathState = s;
 
     if (s != ALIVE && s != JUST_RESPAWNED)
     {
         CombatStop();
         DeleteThreatList();
         getHostileRefManager().deleteReferences();
 
         if (IsNonMeleeSpellCast(false))
             InterruptNonMeleeSpells(false);
 
         ExitVehicle();                                      // Exit vehicle before calling RemoveAllControlled
                                                             // vehicles use special type of charm that is not removed by the next function
                                                             // triggering an assert
         UnsummonAllTotems();
         RemoveAllControlled();
         RemoveAllAurasOnDeath();
     }
 
     if (s == JUST_DIED)
     {
         ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, false);
         ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, false);
         // remove aurastates allowing special moves
         ClearAllReactives();
         ClearDiminishings();
         if (IsInWorld())
         {
             // Only clear MotionMaster for entities that exists in world
             // Avoids crashes in the following conditions :
             //  * Using 'call pet' on dead pets
             //  * Using 'call stabled pet'
             //  * Logging in with dead pets
             GetMotionMaster()->Clear(false);
             GetMotionMaster()->MoveIdle();
         }
         StopMoving();
         DisableSpline();
         // without this when removing IncreaseMaxHealth aura player may stuck with 1 hp
         // do not why since in IncreaseMaxHealth currenthealth is checked
         SetHealth(0);
         SetPower(getPowerType(), 0);
 
         // players in instance don't have ZoneScript, but they have InstanceScript
         if (ZoneScript* zoneScript = GetZoneScript() ? GetZoneScript() : GetInstanceScript())
             zoneScript->OnUnitDeath(this);
     }
     else if (s == JUST_RESPAWNED)
         RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); // clear skinnable for creature and player (at battleground)
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetDisableGravity	(	bool	disable,
		bool	packetOnly = `false`
	)

 {
     if (!packetOnly)
     {
         if (disable == IsLevitating())
             return false;
 
         if (disable)
         {
             AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
             RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_SPLINE_ELEVATION);
             SetFall(false);
         }
         else
         {
             RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
             if (!HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
                 SetFall(true);
         }
     }
 
     static OpcodeServer const gravityOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_ENABLE_GRAVITY,  SMSG_MOVE_ENABLE_GRAVITY  },
         { SMSG_MOVE_SPLINE_DISABLE_GRAVITY, SMSG_MOVE_DISABLE_GRAVITY }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(gravityOpcodeTable[disable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(gravityOpcodeTable[disable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

void Unit::SetDisplayId ( uint32 modelId )

virtual

Reimplemented in Creature, and Pet.

 {
     SetUInt32Value(UNIT_FIELD_DISPLAYID, modelId);
     // Set Gender by modelId
     if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(modelId))
         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetExtraUnitMovementFlags ( uint16 f )

inline

2117 { m_movementInfo.SetExtraMovementFlags(f); }

MovementInfo::SetExtraMovementFlags

MovementInfo m_movementInfo

Definition: Object.h:612

void SetExtraMovementFlags(uint16 flag)

Definition: Object.h:333

Here is the caller graph for this function:

void Unit::SetFacingTo ( float ori )

 {
     Movement::MoveSplineInit init(this);
     init.MoveTo(GetPositionX(), GetPositionY(), GetPositionZMinusOffset(), false);
     if (GetTransport())
         init.DisableTransportPathTransformations(); // It makes no sense to target global orientation
     init.SetFacing(ori);
     init.Launch();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetFacingToObject ( WorldObject const * object )

Todo:: figure out under what conditions creature will move towards object instead of facing it where it currently is.

 {
     // never face when already moving
     if (!IsStopped())
         return;
 
     Movement::MoveSplineInit init(this);
     init.MoveTo(GetPositionX(), GetPositionY(), GetPositionZMinusOffset());
     init.SetFacing(GetAngle(object));   // when on transport, GetAngle will still return global coordinates (and angle) that needs transforming
     init.Launch();
 }

Here is the call graph for this function:

void Unit::setFaction ( uint32 faction )

inline

1467 { SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, faction); }

UNIT_FIELD_FACTIONTEMPLATE

void SetUInt32Value(uint16 index, uint32 value)

Definition: Object.cpp:996

Definition: UpdateFields.h:107

Here is the call graph for this function:

bool Unit::SetFall ( bool enable )

 {
     if (enable == HasUnitMovementFlag(MOVEMENTFLAG_FALLING))
         return false;
 
     if (enable)
     {
         AddUnitMovementFlag(MOVEMENTFLAG_FALLING);
         m_movementInfo.SetFallTime(0);
     }
     else
         RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING | MOVEMENTFLAG_FALLING_FAR);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetFeared ( bool apply )

protected

 {
     if (apply)
     {
         SetTarget(ObjectGuid::Empty);
 
         Unit* caster = NULL;
         Unit::AuraEffectList const& fearAuras = GetAuraEffectsByType(SPELL_AURA_MOD_FEAR);
         if (!fearAuras.empty())
             caster = ObjectAccessor::GetUnit(*this, fearAuras.front()->GetCasterGUID());
         if (!caster)
             caster = getAttackerForHelper();
         GetMotionMaster()->MoveFleeing(caster, fearAuras.empty() ? sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_FLEE_DELAY) : 0);             // caster == NULL processed in MoveFleeing
     }
     else
     {
         if (IsAlive())
         {
             if (GetMotionMaster()->GetCurrentMovementGeneratorType() == FLEEING_MOTION_TYPE)
                 GetMotionMaster()->MovementExpired();
             if (GetVictim())
                 SetTarget(EnsureVictim()->GetGUID());
         }
     }
 
     if (Player* player = ToPlayer())
         if (!player->HasUnitState(UNIT_STATE_POSSESSED))
             player->SetClientControl(this, !apply);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetFeatherFall	(	bool	enable,
		bool	packetOnly = `false`
	)

 {
     if (!packetOnly)
     {
         if (enable == HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW))
             return false;
 
         if (enable)
             AddUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
         else
             RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
     }
 
     static OpcodeServer const featherFallOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_SET_NORMAL_FALL,  SMSG_MOVE_SET_NORMAL_FALL  },
         { SMSG_MOVE_SPLINE_SET_FEATHER_FALL, SMSG_MOVE_SET_FEATHER_FALL }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(featherFallOpcodeTable[enable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(featherFallOpcodeTable[enable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetFullHealth ( )

inline

1440 { SetHealth(GetMaxHealth()); }

uint32 GetMaxHealth() const

Definition: Unit.h:1427

Unit::SetHealth

void SetHealth(uint32 val)

Definition: Unit.cpp:11537

Here is the caller graph for this function:

void Unit::SetHealth ( uint32 val )

 {
     if (getDeathState() == JUST_DIED)
         val = 0;
     else if (GetTypeId() == TYPEID_PLAYER && getDeathState() == DEAD)
         val = 1;
     else
     {
         uint32 maxHealth = GetMaxHealth();
         if (maxHealth < val)
             val = maxHealth;
     }
 
     SetUInt32Value(UNIT_FIELD_HEALTH, val);
 
     // group update
     if (Player* player = ToPlayer())
     {
         if (player->GetGroup())
             player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_HP);
     }
     else if (Pet* pet = ToCreature()->ToPet())
     {
         if (pet->isControlled())
             pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_HP);
     }
 }

Here is the call graph for this function:

bool Unit::SetHover	(	bool	enable,
		bool	packetOnly = `false`
	)

No need to check height on ascent

 {
     if (!packetOnly)
     {
         if (enable == HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
             return false;
 
         float hoverHeight = GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
         if (enable)
         {
             AddUnitMovementFlag(MOVEMENTFLAG_HOVER);
             if (hoverHeight)
                 UpdateHeight(GetPositionZ() + hoverHeight);
         }
         else
         {
             RemoveUnitMovementFlag(MOVEMENTFLAG_HOVER);
             if (hoverHeight)
             {
                 float newZ = GetPositionZ() - hoverHeight;
                 UpdateAllowedPositionZ(GetPositionX(), GetPositionY(), newZ);
                 UpdateHeight(newZ);
             }
         }
     }
 
     static OpcodeServer const hoverOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_UNSET_HOVER, SMSG_MOVE_UNSET_HOVERING },
         { SMSG_MOVE_SPLINE_SET_HOVER,   SMSG_MOVE_SET_HOVERING   }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(hoverOpcodeTable[enable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(hoverOpcodeTable[enable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetInCombatState	(	bool	PvP,
		Unit *	enemy = `NULL`
	)

 {
     // only alive units can be in combat
     if (!IsAlive())
         return;
 
     if (PvP)
         m_CombatTimer = 5000;
 
     if (IsInCombat() || HasUnitState(UNIT_STATE_EVADE))
         return;
 
     SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
 
     if (Creature* creature = ToCreature())
     {
         // Set home position at place of engaging combat for escorted creatures
         if ((IsAIEnabled && creature->AI()->IsEscorted()) ||
             GetMotionMaster()->GetCurrentMovementGeneratorType() == WAYPOINT_MOTION_TYPE ||
             GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
             creature->SetHomePosition(GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation());
 
         if (enemy)
         {
             if (IsAIEnabled)
             {
                 creature->AI()->EnterCombat(enemy);
                 RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC); // unit has engaged in combat, remove immunity so players can fight back
             }
             if (creature->GetFormation())
                 creature->GetFormation()->MemberAttackStart(creature, enemy);
         }
 
         if (IsPet())
         {
             UpdateSpeed(MOVE_RUN, true);
             UpdateSpeed(MOVE_SWIM, true);
             UpdateSpeed(MOVE_FLIGHT, true);
         }
 
         if (!(creature->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_MOUNTED_COMBAT))
             Dismount();
     }
 
     for (Unit::ControlList::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
     {
         (*itr)->SetInCombatState(PvP, enemy);
         (*itr)->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetInCombatWith ( Unit * enemy )

 {
     Unit* eOwner = enemy->GetCharmerOrOwnerOrSelf();
     if (eOwner->IsPvP() || eOwner->IsFFAPvP())
     {
         SetInCombatState(true, enemy);
         return;
     }
 
     // check for duel
     if (eOwner->GetTypeId() == TYPEID_PLAYER && eOwner->ToPlayer()->duel)
     {
         Unit const* myOwner = GetCharmerOrOwnerOrSelf();
         if (((Player const*)eOwner)->duel->opponent == myOwner)
         {
             SetInCombatState(true, enemy);
             return;
         }
     }
     SetInCombatState(false, enemy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetInFront ( WorldObject const * target )

 {
     if (!HasUnitState(UNIT_STATE_CANNOT_TURN))
         SetOrientation(GetAngle(target));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetInPhase	(	uint32	id,
		bool	update,
		bool	apply
	)

overridevirtual

Reimplemented from WorldObject.

 {
     bool res = WorldObject::SetInPhase(id, update, apply);
 
     if (!IsInWorld())
         return res;
 
     if (GetTypeId() == TYPEID_UNIT || (!ToPlayer()->IsGameMaster() && !ToPlayer()->GetSession()->PlayerLogout()))
     {
         HostileRefManager& refManager = getHostileRefManager();
         HostileReference* ref = refManager.getFirst();
 
         while (ref)
         {
             if (Unit* unit = ref->GetSource()->GetOwner())
                 if (Creature* creature = unit->ToCreature())
                     refManager.setOnlineOfflineState(creature, creature->IsInPhase(this));
 
             ref = ref->next();
         }
 
         // modify threat lists for new phasemask
         if (GetTypeId() != TYPEID_PLAYER)
         {
             std::list<HostileReference*> threatList = getThreatManager().getThreatList();
             std::list<HostileReference*> offlineThreatList = getThreatManager().getOfflineThreatList();
 
             // merge expects sorted lists
             threatList.sort();
             offlineThreatList.sort();
             threatList.merge(offlineThreatList);
 
             for (std::list<HostileReference*>::const_iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
                 if (Unit* unit = (*itr)->getTarget())
                     unit->getHostileRefManager().setOnlineOfflineState(ToCreature(), unit->IsInPhase(this));
         }
     }
 
     for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
         if ((*itr)->GetTypeId() == TYPEID_UNIT)
             (*itr)->SetInPhase(id, true, apply);
 
     for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
         if (!m_SummonSlot[i].IsEmpty())
             if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
                 summon->SetInPhase(id, true, apply);
 
     RemoveNotOwnSingleTargetAuras(0, true);
 
     return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetLastDamagedTime ( time_t val )

inline

2217 { _lastDamagedTime = val; }

Unit::_lastDamagedTime

time_t _lastDamagedTime

Definition: Unit.h:2362

Here is the caller graph for this function:

void Unit::SetLevel ( uint8 lvl )

 {
     SetUInt32Value(UNIT_FIELD_LEVEL, lvl);
 
     if (Player* player = ToPlayer())
     {
         // group update
         if (player->GetGroup())
             player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_LEVEL);
 
         sWorld->UpdateCharacterInfoLevel(GetGUID(), lvl);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetMaxHealth ( uint32 val )

 {
     if (!val)
         val = 1;
 
     uint32 health = GetHealth();
     SetUInt32Value(UNIT_FIELD_MAXHEALTH, val);
 
     // group update
     if (GetTypeId() == TYPEID_PLAYER)
     {
         if (ToPlayer()->GetGroup())
             ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_HP);
     }
     else if (Pet* pet = ToCreature()->ToPet())
     {
         if (pet->isControlled())
             pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_HP);
     }
 
     if (val < health)
         SetHealth(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetMaxPower	(	Powers	power,
		int32	val
	)

 {
     uint32 powerIndex = GetPowerIndex(power);
     if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
         return;
 
     int32 cur_power = GetPower(power);
     SetInt32Value(UNIT_FIELD_MAXPOWER + powerIndex, val);
 
     // group update
     if (GetTypeId() == TYPEID_PLAYER)
     {
         if (ToPlayer()->GetGroup())
             ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_POWER);
     }
     /*else if (Pet* pet = ToCreature()->ToPet()) TODO 6.x
     {
         if (pet->isControlled())
             pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_POWER);
     }*/
 
     if (val < cur_power)
         SetPower(power, val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetMeleeAnimKitId ( uint16 animKitId )

 {
     if (_meleeAnimKitId == animKitId)
         return;
 
     if (animKitId && !sAnimKitStore.LookupEntry(animKitId))
         return;
 
     _meleeAnimKitId = animKitId;
 
     WorldPackets::Misc::SetMeleeAnimKit data;
     data.Unit = GetGUID();
     data.AnimKitID = animKitId;
     SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetMinion	(	Minion *	minion,
		bool	apply
	)

 {
     TC_LOG_DEBUG("entities.unit", "SetMinion %u for %u, apply %u", minion->GetEntry(), GetEntry(), apply);
 
     if (apply)
     {
         if (!minion->GetOwnerGUID().IsEmpty())
         {
             TC_LOG_FATAL("entities.unit", "SetMinion: Minion %u is not the minion of owner %u", minion->GetEntry(), GetEntry());
             return;
         }
 
         minion->SetOwnerGUID(GetGUID());
 
         m_Controlled.insert(minion);
 
         if (GetTypeId() == TYPEID_PLAYER)
         {
             minion->m_ControlledByPlayer = true;
             minion->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
         }
 
         // Can only have one pet. If a new one is summoned, dismiss the old one.
         if (minion->IsGuardianPet())
         {
             if (Guardian* oldPet = GetGuardianPet())
             {
                 if (oldPet != minion && (oldPet->IsPet() || minion->IsPet() || oldPet->GetEntry() != minion->GetEntry()))
                 {
                     // remove existing minion pet
                     if (oldPet->IsPet())
                         ((Pet*)oldPet)->Remove(PET_SAVE_AS_CURRENT);
                     else
                         oldPet->UnSummon();
                     SetPetGUID(minion->GetGUID());
                     SetMinionGUID(ObjectGuid::Empty);
                 }
             }
             else
             {
                 SetPetGUID(minion->GetGUID());
                 SetMinionGUID(ObjectGuid::Empty);
             }
         }
 
         if (minion->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
         {
             if (AddGuidValue(UNIT_FIELD_SUMMON, minion->GetGUID()))
             {
             }
         }
 
         if (minion->m_Properties && minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
             SetCritterGUID(minion->GetGUID());
 
         // PvP, FFAPvP
         minion->SetByteValue(UNIT_FIELD_BYTES_2, 1, GetByteValue(UNIT_FIELD_BYTES_2, 1));
 
         // FIXME: hack, speed must be set only at follow
         if (GetTypeId() == TYPEID_PLAYER && minion->IsPet())
             for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
                 minion->SetSpeed(UnitMoveType(i), m_speed_rate[i], true);
 
         // Ghoul pets have energy instead of mana (is anywhere better place for this code?)
         if (minion->IsPetGhoul())
             minion->setPowerType(POWER_ENERGY);
 
         // Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
 
         if (spellInfo && (spellInfo->IsCooldownStartedOnEvent()))
             GetSpellHistory()->StartCooldown(spellInfo, 0, nullptr, true);
     }
     else
     {
         if (minion->GetOwnerGUID() != GetGUID())
         {
             TC_LOG_FATAL("entities.unit", "SetMinion: Minion %u is not the minion of owner %u", minion->GetEntry(), GetEntry());
             return;
         }
 
         m_Controlled.erase(minion);
 
         if (minion->m_Properties && minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
             if (GetCritterGUID() == minion->GetGUID())
                 SetCritterGUID(ObjectGuid::Empty);
 
         if (minion->IsGuardianPet())
         {
             if (GetPetGUID() == minion->GetGUID())
                 SetPetGUID(ObjectGuid::Empty);
         }
         else if (minion->IsTotem())
         {
             // All summoned by totem minions must disappear when it is removed.
             if (SpellInfo const* spInfo = sSpellMgr->GetSpellInfo(minion->ToTotem()->GetSpell()))
                 for (SpellEffectInfo const* effect : spInfo->GetEffectsForDifficulty(DIFFICULTY_NONE))
                     {
                         if (!effect || effect->Effect != SPELL_EFFECT_SUMMON)
                             continue;
 
                         RemoveAllMinionsByEntry(effect->MiscValue);
                     }
         }
 
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
         // Remove infinity cooldown
         if (spellInfo && (spellInfo->IsCooldownStartedOnEvent()))
             GetSpellHistory()->SendCooldownEvent(spellInfo);
 
         //if (minion->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
         {
             if (RemoveGuidValue(UNIT_FIELD_SUMMON, minion->GetGUID()))
             {
                 // Check if there is another minion
                 for (ControlList::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
                 {
                     // do not use this check, creature do not have charm guid
                     //if (GetCharmGUID() == (*itr)->GetGUID())
                     if (GetGUID() == (*itr)->GetCharmerGUID())
                         continue;
 
                     //ASSERT((*itr)->GetOwnerGUID() == GetGUID());
                     if ((*itr)->GetOwnerGUID() != GetGUID())
                     {
                         OutDebugInfo();
                         (*itr)->OutDebugInfo();
                         ABORT();
                     }
                     ASSERT((*itr)->GetTypeId() == TYPEID_UNIT);
 
                     if (!(*itr)->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
                         continue;
 
                     if (AddGuidValue(UNIT_FIELD_SUMMON, (*itr)->GetGUID()))
                     {
                         // show another pet bar if there is no charm bar
                         if (GetTypeId() == TYPEID_PLAYER && !GetCharmGUID())
                         {
                             if ((*itr)->IsPet())
                                 ToPlayer()->PetSpellInitialize();
                             else
                                 ToPlayer()->CharmSpellInitialize();
                         }
                     }
                     break;
                 }
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetMinionGUID ( ObjectGuid guid )

inline

1703 { SetGuidValue(UNIT_FIELD_SUMMON, guid); }

Unit::m_auraModifiersGroup

void SetGuidValue(uint16 index, ObjectGuid const &value)

Definition: Object.cpp:1120

UNIT_FIELD_SUMMON

Definition: UpdateFields.h:83

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetModifierValue	(	UnitMods	unitMod,
		UnitModifierType	modifierType,
		float	value
	)

inline

1952 { m_auraModifiersGroup[unitMod][modifierType] = value; }

float m_auraModifiersGroup[UNIT_MOD_END][MODIFIER_TYPE_END]

Definition: Unit.h:2285

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

Here is the caller graph for this function:

void Unit::SetMovementAnimKitId ( uint16 animKitId )

 {
     if (_movementAnimKitId == animKitId)
         return;
 
     if (animKitId && !sAnimKitStore.LookupEntry(animKitId))
         return;
 
     _movementAnimKitId = animKitId;
 
     WorldPackets::Misc::SetMovementAnimKit data;
     data.Unit = GetGUID();
     data.AnimKitID = animKitId;
     SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

void Unit::SetNativeDisplayId ( uint32 modelId )

inline

2016 { SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, modelId); }

UNIT_FIELD_NATIVEDISPLAYID

Definition: UpdateFields.h:118

Unit::_redirectThreadInfo

void SetUInt32Value(uint16 index, uint32 value)

Definition: Object.cpp:996

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetOwnerGUID ( ObjectGuid owner )

 {
     if (GetOwnerGUID() == owner)
         return;
 
     SetGuidValue(UNIT_FIELD_SUMMONEDBY, owner);
     if (!owner)
         return;
 
     // Update owner dependent fields
     Player* player = ObjectAccessor::GetPlayer(*this, owner);
     if (!player || !player->HaveAtClient(this)) // if player cannot see this unit yet, he will receive needed data with create object
         return;
 
     SetFieldNotifyFlag(UF_FLAG_OWNER);
 
     UpdateData udata(GetMapId());
     WorldPacket packet;
     BuildValuesUpdateBlockForPlayer(&udata, player);
     udata.BuildPacket(&packet);
     player->SendDirectMessage(&packet);
 
     RemoveFieldNotifyFlag(UF_FLAG_OWNER);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetPetGUID ( ObjectGuid guid )

inline

1707 { m_SummonSlot[SUMMON_SLOT_PET] = guid; }

Unit::m_SummonSlot

ObjectGuid m_SummonSlot[MAX_SUMMON_SLOT]

Definition: Unit.h:1929

SUMMON_SLOT_PET

#define SUMMON_SLOT_PET

Definition: Unit.h:1280

Here is the caller graph for this function:

void Unit::SetPower	(	Powers	power,
		int32	val
	)

Todo:: : Support multiple counts ?

 {
     uint32 powerIndex = GetPowerIndex(power);
     if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
         return;
 
     int32 maxPower = int32(GetMaxPower(power));
     if (maxPower < val)
         val = maxPower;
 
     SetInt32Value(UNIT_FIELD_POWER + powerIndex, val);
 
     if (IsInWorld())
     {
         WorldPackets::Combat::PowerUpdate packet;
         packet.Guid = GetGUID();
         packet.Powers.emplace_back(val, powerIndex);
         SendMessageToSet(packet.Write(), GetTypeId() == TYPEID_PLAYER);
     }
 
     // group update
     if (Player* player = ToPlayer())
     {
         if (player->GetGroup())
             player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_POWER);
     }
     /*else if (Pet* pet = ToCreature()->ToPet()) TODO 6.x
     {
         if (pet->isControlled())
             pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_POWER);
     }*/
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::setPowerType ( Powers power )

 {
     if (getPowerType() == new_powertype)
         return;
 
     SetUInt32Value(UNIT_FIELD_DISPLAY_POWER, new_powertype);
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         if (ToPlayer()->GetGroup())
             ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_POWER_TYPE);
     }
     /*else if (Pet* pet = ToCreature()->ToPet()) TODO 6.x
     {
         if (pet->isControlled())
             pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_POWER_TYPE);
     }*/
 
     float powerMultiplier = 1.0f;
     if (!IsPet())
         if (Creature* creature = ToCreature())
             powerMultiplier = creature->GetCreatureTemplate()->ModMana;
 
     switch (new_powertype)
     {
         default:
         case POWER_MANA:
             break;
         case POWER_RAGE:
             SetMaxPower(POWER_RAGE, uint32(std::ceil(GetCreatePowers(POWER_RAGE) * powerMultiplier)));
             SetPower(POWER_RAGE, 0);
             break;
         case POWER_FOCUS:
             SetMaxPower(POWER_FOCUS, uint32(std::ceil(GetCreatePowers(POWER_FOCUS) * powerMultiplier)));
             SetPower(POWER_FOCUS, uint32(std::ceil(GetCreatePowers(POWER_FOCUS) * powerMultiplier)));
             break;
         case POWER_ENERGY:
             SetMaxPower(POWER_ENERGY, uint32(std::ceil(GetCreatePowers(POWER_ENERGY) * powerMultiplier)));
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetPvP ( bool state )

virtual

 {
     if (state)
         SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
     else
         RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetRedirectThreat	(	ObjectGuid	guid,
		uint32	pct
	)

inline

2154 { _redirectThreadInfo.Set(guid, pct); }

RedirectThreatInfo::Set

void Set(ObjectGuid guid, uint32 pct)

Definition: Unit.h:1086

RedirectThreatInfo _redirectThreadInfo

Definition: Unit.h:2350

Here is the caller graph for this function:

void Unit::SetResistance	(	SpellSchools	school,
		int32	val
	)

inline

1424 { SetStatInt32Value(UNIT_FIELD_RESISTANCES+school, val); }

Object::SetStatInt32Value

void SetStatInt32Value(uint16 index, int32 value)

Definition: Object.cpp:1143

UNIT_FIELD_RESISTANCES

Definition: UpdateFields.h:140

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetResistanceBuffMods	(	SpellSchools	school,
		bool	positive,
		float	val
	)

 {
     SetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val);
 }

Here is the call graph for this function:

void Unit::SetRooted	(	bool	apply,
		bool	packetOnly = `false`
	)

protected

 {
     if (!packetOnly)
     {
         if (apply)
         {
             // MOVEMENTFLAG_ROOT cannot be used in conjunction with MOVEMENTFLAG_MASK_MOVING (tested 3.3.5a)
             // this will freeze clients. That's why we remove MOVEMENTFLAG_MASK_MOVING before
             // setting MOVEMENTFLAG_ROOT
             RemoveUnitMovementFlag(MOVEMENTFLAG_MASK_MOVING);
             AddUnitMovementFlag(MOVEMENTFLAG_ROOT);
             StopMoving();
         }
         else
             RemoveUnitMovementFlag(MOVEMENTFLAG_ROOT);
     }
 
 
     static OpcodeServer const rootOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_UNROOT, SMSG_MOVE_UNROOT },
         { SMSG_MOVE_SPLINE_ROOT, SMSG_MOVE_ROOT }
     };
 
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER)
     {
         WorldPackets::Movement::MoveSetFlag packet(rootOpcodeTable[apply][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(rootOpcodeTable[apply][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetShapeshiftForm ( ShapeshiftForm form )

 {
     SetByteValue(UNIT_FIELD_BYTES_2, 3, form);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Unit::SetSheath ( SheathState sheathed )

inlinevirtual

1463 { SetByteValue(UNIT_FIELD_BYTES_2, 0, sheathed); }

Object::SetStatInt32Value

Definition: UpdateFields.h:146

Object::SetByteValue

void SetByteValue(uint16 index, uint8 offset, uint8 value)

Definition: Object.cpp:1080

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetSpeed	(	UnitMoveType	mtype,
		float	rate,
		bool	forced = `false`
	)

 {
     if (rate < 0)
         rate = 0.0f;
 
     // Update speed only on change
     if (m_speed_rate[mtype] == rate)
         return;
 
     m_speed_rate[mtype] = rate;
 
     propagateSpeedChange();
 
     // Spline packets are for creatures and move_update are for players
     static OpcodeServer const moveTypeToOpcode[MAX_MOVE_TYPE][3] =
     {
         {SMSG_MOVE_SPLINE_SET_WALK_SPEED,        SMSG_MOVE_SET_WALK_SPEED,        SMSG_MOVE_UPDATE_WALK_SPEED       },
         {SMSG_MOVE_SPLINE_SET_RUN_SPEED,         SMSG_MOVE_SET_RUN_SPEED,         SMSG_MOVE_UPDATE_RUN_SPEED        },
         {SMSG_MOVE_SPLINE_SET_RUN_BACK_SPEED,    SMSG_MOVE_SET_RUN_BACK_SPEED,    SMSG_MOVE_UPDATE_RUN_BACK_SPEED   },
         {SMSG_MOVE_SPLINE_SET_SWIM_SPEED,        SMSG_MOVE_SET_SWIM_SPEED,        SMSG_MOVE_UPDATE_SWIM_SPEED       },
         {SMSG_MOVE_SPLINE_SET_SWIM_BACK_SPEED,   SMSG_MOVE_SET_SWIM_BACK_SPEED,   SMSG_MOVE_UPDATE_SWIM_BACK_SPEED  },
         {SMSG_MOVE_SPLINE_SET_TURN_RATE,         SMSG_MOVE_SET_TURN_RATE,         SMSG_MOVE_UPDATE_TURN_RATE        },
         {SMSG_MOVE_SPLINE_SET_FLIGHT_SPEED,      SMSG_MOVE_SET_FLIGHT_SPEED,      SMSG_MOVE_UPDATE_FLIGHT_SPEED     },
         {SMSG_MOVE_SPLINE_SET_FLIGHT_BACK_SPEED, SMSG_MOVE_SET_FLIGHT_BACK_SPEED, SMSG_MOVE_UPDATE_FLIGHT_BACK_SPEED},
         {SMSG_MOVE_SPLINE_SET_PITCH_RATE,        SMSG_MOVE_SET_PITCH_RATE,        SMSG_MOVE_UPDATE_PITCH_RATE       },
     };
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         // register forced speed changes for WorldSession::HandleForceSpeedChangeAck
         // and do it only for real sent packets and use run for run/mounted as client expected
         ++ToPlayer()->m_forced_speed_changes[mtype];
 
         if (!IsInCombat())
             if (Pet* pet = ToPlayer()->GetPet())
                 pet->SetSpeed(mtype, m_speed_rate[mtype], forced);
     }
 
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER)
     {
         // Send notification to self
         WorldPackets::Movement::MoveSetSpeed selfpacket(moveTypeToOpcode[mtype][1]);
         selfpacket.MoverGUID = GetGUID();
         selfpacket.SequenceIndex = m_movementCounter++;
         selfpacket.Speed = GetSpeed(mtype);
         ToPlayer()->GetSession()->SendPacket(selfpacket.Write());
 
         // Send notification to other players
         WorldPackets::Movement::MoveUpdateSpeed packet(moveTypeToOpcode[mtype][2]);
         packet.movementInfo = &m_movementInfo;
         packet.Speed = GetSpeed(mtype);
         SendMessageToSet(packet.Write(), false);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetSpeed packet(moveTypeToOpcode[mtype][0]);
         packet.MoverGUID = GetGUID();
         packet.Speed = GetSpeed(mtype);
         SendMessageToSet(packet.Write(), true);
     }
 }

Here is the call graph for this function:

void Unit::SetStandFlags ( uint8 flags )

inline

1493 { SetByteFlag(UNIT_FIELD_BYTES_1, 2, flags); }

Object::SetByteFlag

void SetByteFlag(uint16 index, uint8 offset, uint8 newFlag)

Definition: Object.cpp:1252

UNIT_FIELD_BYTES_1

Definition: UpdateFields.h:124

flags

uint8 flags

Definition: DisableMgr.cpp:44

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetStandState	(	UnitStandStateType	state,
		uint32	animKitID = `0`
	)

 {
     SetByteValue(UNIT_FIELD_BYTES_1, 0, uint8(state));
 
     if (IsStandState())
        RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_SEATED);
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         WorldPackets::Misc::StandStateUpdate packet(state, animKitID);
         ToPlayer()->GetSession()->SendPacket(packet.Write());
     }
 }

Here is the call graph for this function:

void Unit::SetStat	(	Stats	stat,
		int32	val
	)

inline

1418 { SetStatInt32Value(UNIT_FIELD_STAT+stat, val); }

void SetStatInt32Value(uint16 index, int32 value)

Definition: Object.cpp:1143

UNIT_FIELD_STAT

Definition: UpdateFields.h:137

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetStunned ( bool apply )

protected

 {
     if (apply)
     {
         SetTarget(ObjectGuid::Empty);
         SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
 
         StopMoving();
 
         if (GetTypeId() == TYPEID_PLAYER)
             SetStandState(UNIT_STAND_STATE_STAND);
 
         SetRooted(true);
 
         CastStop();
     }
     else
     {
         if (IsAlive() && GetVictim())
             SetTarget(EnsureVictim()->GetGUID());
 
         // don't remove UNIT_FLAG_STUNNED for pet when owner is mounted (disabled pet's interface)
         Unit* owner = GetOwner();
         if (!owner || (owner->GetTypeId() == TYPEID_PLAYER && !owner->ToPlayer()->IsMounted()))
             RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
 
         if (!HasUnitState(UNIT_STATE_ROOT))         // prevent moving if it also has root effect
             SetRooted(false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetSwim ( bool enable )

 {
     if (enable == HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING))
         return false;
 
     if (enable)
         AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
     else
         RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
 
     static OpcodeServer const swimOpcodeTable[2] = { SMSG_MOVE_SPLINE_STOP_SWIM, SMSG_MOVE_SPLINE_START_SWIM};
 
     WorldPackets::Movement::MoveSplineSetFlag packet(swimOpcodeTable[enable]);
     packet.MoverGUID = GetGUID();
     SendMessageToSet(packet.Write(), true);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Unit::SetTarget ( ObjectGuid const & )

pure virtual

Implemented in Creature.

Here is the caller graph for this function:

void Unit::setTransForm ( uint32 spellid )

inline

2017 { m_transform = spellid;}

Unit::m_transform

uint32 m_transform

Definition: Unit.h:2269

Here is the caller graph for this function:

void Unit::SetUnitMovementFlags ( uint32 f )

inline

2111 { m_movementInfo.SetMovementFlags(f); }

MovementInfo::SetMovementFlags

MovementInfo m_movementInfo

Definition: Object.h:612

void SetMovementFlags(uint32 flag)

Definition: Object.h:327

Here is the caller graph for this function:

void Unit::SetVehicle ( Vehicle * vehicle )

inline

2167 { m_vehicle = vehicle; }

Unit::m_vehicle

Vehicle * m_vehicle

Definition: Unit.h:2304

Here is the caller graph for this function:

void Unit::SetVirtualItem	(	uint32	slot,
		uint32	itemId,
		uint16	appearanceModId = `0`
	)

 {
     if (slot >= MAX_EQUIPMENT_ITEMS)
         return;
 
     SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + slot * 2, itemId);
     SetUInt16Value(UNIT_VIRTUAL_ITEM_SLOT_ID + slot * 2 + 1, 0, appearanceModId);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::SetVisible ( bool x )

 {
     if (!x)
         m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_GAMEMASTER);
     else
         m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_PLAYER);
 
     UpdateObjectVisibility();
 }

Here is the call graph for this function:

void Unit::SetVisibleAura	(	uint8	slot,
		AuraApplication *	aur
	)

 {
     m_visibleAuras[slot]=aur;
     UpdateAuraForGroup(slot);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Unit::SetWalk ( bool enable )

 {
     if (enable == IsWalking())
         return false;
 
     if (enable)
         AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
     else
         RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
 
     static OpcodeServer const walkModeTable[2] = { SMSG_MOVE_SPLINE_SET_RUN_MODE, SMSG_MOVE_SPLINE_SET_WALK_MODE };
 
     WorldPackets::Movement::MoveSplineSetFlag packet(walkModeTable[enable]);
     packet.MoverGUID = GetGUID();
     SendMessageToSet(packet.Write(), true);
     return true;
 }

Here is the call graph for this function:

bool Unit::SetWaterWalking	(	bool	enable,
		bool	packetOnly = `false`
	)

 {
     if (!packetOnly)
     {
         if (enable == HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING))
             return false;
 
         if (enable)
             AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
         else
             RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
     }
 
     static OpcodeServer const waterWalkingOpcodeTable[2][2] =
     {
         { SMSG_MOVE_SPLINE_SET_LAND_WALK,  SMSG_MOVE_SET_LAND_WALK  },
         { SMSG_MOVE_SPLINE_SET_WATER_WALK, SMSG_MOVE_SET_WATER_WALK }
     };
 
     bool player = GetTypeId() == TYPEID_PLAYER && ToPlayer()->m_mover->GetTypeId() == TYPEID_PLAYER;
 
     if (player)
     {
         WorldPackets::Movement::MoveSetFlag packet(waterWalkingOpcodeTable[enable][1]);
         packet.MoverGUID = GetGUID();
         packet.SequenceIndex = m_movementCounter++;
         SendMessageToSet(packet.Write(), true);
     }
     else
     {
         WorldPackets::Movement::MoveSplineSetFlag packet(waterWalkingOpcodeTable[enable][0]);
         packet.MoverGUID = GetGUID();
         SendMessageToSet(packet.Write(), true);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::SpellBaseDamageBonusDone ( SpellSchoolMask schoolMask ) const

 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
         float overrideSP = GetFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
         if (overrideSP > 0.0f)
             return int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), overrideSP) + 0.5f);
     }
 
     int32 DoneAdvertisedBenefit = 0;
 
     AuraEffectList const& mDamageDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE);
     for (AuraEffectList::const_iterator i = mDamageDone.begin(); i != mDamageDone.end(); ++i)
         if (((*i)->GetMiscValue() & schoolMask) != 0 &&
         (*i)->GetSpellInfo()->EquippedItemClass == -1 &&
                                                             // -1 == any item class (not wand then)
         (*i)->GetSpellInfo()->EquippedItemInventoryTypeMask == 0)
                                                             // 0 == any inventory type (not wand then)
             DoneAdvertisedBenefit += (*i)->GetAmount();
 
     if (GetTypeId() == TYPEID_PLAYER)
     {
         // Base value
         DoneAdvertisedBenefit += ToPlayer()->GetBaseSpellPowerBonus();
 
         // Check if we are ever using mana - PaperDollFrame.lua
         if (GetPowerIndex(POWER_MANA) != MAX_POWERS)
             DoneAdvertisedBenefit += std::max(0, int32(GetStat(STAT_INTELLECT)));  // spellpower from intellect
 
         // Damage bonus from stats
         AuraEffectList const& mDamageDoneOfStatPercent = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT);
         for (AuraEffectList::const_iterator i = mDamageDoneOfStatPercent.begin(); i != mDamageDoneOfStatPercent.end(); ++i)
         {
             if ((*i)->GetMiscValue() & schoolMask)
             {
                 // stat used stored in miscValueB for this aura
                 Stats usedStat = Stats((*i)->GetMiscValueB());
                 DoneAdvertisedBenefit += int32(CalculatePct(GetStat(usedStat), (*i)->GetAmount()));
             }
         }
         // ... and attack power
         AuraEffectList const& mDamageDonebyAP = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER);
         for (AuraEffectList::const_iterator i =mDamageDonebyAP.begin(); i != mDamageDonebyAP.end(); ++i)
             if ((*i)->GetMiscValue() & schoolMask)
                 DoneAdvertisedBenefit += int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), (*i)->GetAmount()));
 
     }
     return DoneAdvertisedBenefit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::SpellBaseDamageBonusTaken ( SpellSchoolMask schoolMask ) const

 {
     int32 TakenAdvertisedBenefit = 0;
 
     AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
     for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
         if (((*i)->GetMiscValue() & schoolMask) != 0)
             TakenAdvertisedBenefit += (*i)->GetAmount();
 
     return TakenAdvertisedBenefit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::SpellBaseHealingBonusDone ( SpellSchoolMask schoolMask ) const

 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
         float overrideSP = GetFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
         if (overrideSP > 0.0f)
             return int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), overrideSP) + 0.5f);
     }
 
     int32 advertisedBenefit = 0;
 
     AuraEffectList const& mHealingDone = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_DONE);
     for (AuraEffectList::const_iterator i = mHealingDone.begin(); i != mHealingDone.end(); ++i)
         if (!(*i)->GetMiscValue() || ((*i)->GetMiscValue() & schoolMask) != 0)
             advertisedBenefit += (*i)->GetAmount();
 
     // Healing bonus of spirit, intellect and strength
     if (GetTypeId() == TYPEID_PLAYER)
     {
         // Base value
         advertisedBenefit += ToPlayer()->GetBaseSpellPowerBonus();
 
         // Check if we are ever using mana - PaperDollFrame.lua
         if (GetPowerIndex(POWER_MANA) != MAX_POWERS)
             advertisedBenefit += std::max(0, int32(GetStat(STAT_INTELLECT)));  // spellpower from intellect
 
         // Healing bonus from stats
         AuraEffectList const& mHealingDoneOfStatPercent = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT);
         for (AuraEffectList::const_iterator i = mHealingDoneOfStatPercent.begin(); i != mHealingDoneOfStatPercent.end(); ++i)
         {
             // stat used dependent from misc value (stat index)
             Stats usedStat = Stats((*i)->GetSpellEffectInfo()->MiscValue);
             advertisedBenefit += int32(CalculatePct(GetStat(usedStat), (*i)->GetAmount()));
         }
 
         // ... and attack power
         AuraEffectList const& mHealingDonebyAP = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER);
         for (AuraEffectList::const_iterator i = mHealingDonebyAP.begin(); i != mHealingDonebyAP.end(); ++i)
             if ((*i)->GetMiscValue() & schoolMask)
                 advertisedBenefit += int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), (*i)->GetAmount()));
     }
     return advertisedBenefit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Unit::SpellBaseHealingBonusTaken ( SpellSchoolMask schoolMask ) const

 {
     int32 advertisedBenefit = 0;
 
     AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING);
     for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
         if (((*i)->GetMiscValue() & schoolMask) != 0)
             advertisedBenefit += (*i)->GetAmount();
 
     return advertisedBenefit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellCriticalDamageBonus	(	SpellInfo const *	spellProto,
		uint32	damage,
		Unit *	victim
	)

Todo:: write here full calculation for melee/ranged spells

 {
     // Calculate critical bonus
     int32 crit_bonus = damage;
     float crit_mod = 0.0f;
 
     switch (spellProto->DmgClass)
     {
         case SPELL_DAMAGE_CLASS_MELEE:                      // for melee based spells is 100%
         case SPELL_DAMAGE_CLASS_RANGED:
             crit_bonus += damage;
             break;
         default:
             crit_bonus += damage / 2;                       // for spells is 50%
             break;
     }
 
     crit_mod += (GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, spellProto->GetSchoolMask()) - 1.0f) * 100;
 
     if (crit_bonus != 0)
         AddPct(crit_bonus, crit_mod);
 
     crit_bonus -= damage;
 
     if (damage > uint32(crit_bonus))
     {
         // adds additional damage to critBonus (from talents)
         if (Player* modOwner = GetSpellModOwner())
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
     }
 
     crit_bonus += damage;
 
     return crit_bonus;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellCriticalHealingBonus	(	SpellInfo const *	spellProto,
		uint32	damage,
		Unit *	victim
	)

 {
     // Calculate critical bonus
     int32 crit_bonus = damage;
 
     damage += crit_bonus;
 
     damage = int32(float(damage) * GetTotalAuraMultiplier(SPELL_AURA_MOD_CRITICAL_HEALING_AMOUNT));
 
     return damage;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellDamageBonusDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		uint32	pdamage,
		DamageEffectType	damagetype,
		SpellEffectInfo const *	effect,
		uint32	stack = `1`
	)		const

 {
     if (!spellProto || !victim || damagetype == DIRECT_DAMAGE)
         return pdamage;
 
     // Some spells don't benefit from done mods
     if (spellProto->HasAttribute(SPELL_ATTR3_NO_DONE_BONUS))
         return pdamage;
 
     // For totems get damage bonus from owner
     if (GetTypeId() == TYPEID_UNIT && IsTotem())
         if (Unit* owner = GetOwner())
             return owner->SpellDamageBonusDone(victim, spellProto, pdamage, damagetype, effect, stack);
 
     float ApCoeffMod = 1.0f;
     int32 DoneTotal = 0;
 
     // done scripted mod (take it from owner)
     Unit const* owner = GetOwner() ? GetOwner() : this;
     AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(spellProto))
             continue;
 
         switch ((*i)->GetMiscValue())
         {
             case 4418: // Increased Shock Damage
             case 4554: // Increased Lightning Damage
             case 4555: // Improved Moonfire
             case 5142: // Increased Lightning Damage
             case 5147: // Improved Consecration / Libram of Resurgence
             case 5148: // Idol of the Shooting Star
             case 6008: // Increased Lightning Damage
             case 8627: // Totem of Hex
             {
                 DoneTotal += (*i)->GetAmount();
                 break;
             }
         }
     }
 
     // Custom scripted damage
     /*switch (spellProto->SpellFamilyName)
     {
         case SPELLFAMILY_DEATHKNIGHT:
             break;
     }*/
 
     // Done fixed damage bonus auras
     int32 DoneAdvertisedBenefit  = SpellBaseDamageBonusDone(spellProto->GetSchoolMask());
     // Pets just add their bonus damage to their spell damage
     // note that their spell damage is just gain of their own auras
     if (HasUnitTypeMask(UNIT_MASK_GUARDIAN))
         DoneAdvertisedBenefit += ((Guardian*)this)->GetBonusDamage();
 
     // Check for table values
     float coeff = effect->BonusCoefficient;
     if (effect->BonusCoefficientFromAP > 0)
     {
         WeaponAttackType attType = (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK;
         float APbonus = float(victim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS));
         APbonus += GetTotalAttackPowerValue(attType);
         DoneTotal += int32(effect->BonusCoefficientFromAP * stack * ApCoeffMod * APbonus);
     }
 
     // Default calculation
     if (DoneAdvertisedBenefit)
     {
         float factorMod = CalculateLevelPenalty(spellProto) * stack;
 
         if (Player* modOwner = GetSpellModOwner())
         {
             coeff *= 100.0f;
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
             coeff /= 100.0f;
         }
         DoneTotal += int32(DoneAdvertisedBenefit * coeff * factorMod);
     }
 
     // Done Percentage for DOT is already calculated, no need to do it again. The percentage mod is applied in Aura::HandleAuraSpecificMods.
     float tmpDamage = (int32(pdamage) + DoneTotal) * (damagetype == DOT ? 1.0f : SpellDamagePctDone(victim, spellProto, damagetype));
     // apply spellmod to Done damage (flat and pct)
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, tmpDamage);
 
     return uint32(std::max(tmpDamage, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellDamageBonusTaken	(	Unit *	caster,
		SpellInfo const *	spellProto,
		uint32	pdamage,
		DamageEffectType	damagetype,
		SpellEffectInfo const *	effect,
		uint32	stack = `1`
	)		const

 {
     if (!spellProto || damagetype == DIRECT_DAMAGE)
         return pdamage;
 
     int32 TakenTotal = 0;
     float TakenTotalMod = 1.0f;
     float TakenTotalCasterMod = 0.0f;
 
     // Mod damage from spell mechanic
     if (uint32 mechanicMask = spellProto->GetAllEffectsMechanicMask())
     {
         AuraEffectList const& mDamageDoneMechanic = GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
         for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin(); i != mDamageDoneMechanic.end(); ++i)
             if (mechanicMask & uint32(1 << ((*i)->GetMiscValue())))
                 AddPct(TakenTotalMod, (*i)->GetAmount());
     }
 
     //.. taken pct: dummy auras
     AuraEffectList const& mDummyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
     for (AuraEffectList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
     {
         switch ((*i)->GetSpellInfo()->SpellIconID)
         {
             // Cheat Death
             case 2109:
                 if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
                     AddPct(TakenTotalMod, (*i)->GetAmount());
                 break;
         }
     }
         // Spells with SPELL_ATTR4_FIXED_DAMAGE should only benefit from mechanic damage mod auras.
     if (!spellProto->HasAttribute(SPELL_ATTR4_FIXED_DAMAGE))
     {
         // get all auras from caster that allow the spell to ignore resistance (sanctified wrath)
         AuraEffectList const& IgnoreResistAuras = caster->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
         for (AuraEffectList::const_iterator i = IgnoreResistAuras.begin(); i != IgnoreResistAuras.end(); ++i)
         {
             if ((*i)->GetMiscValue() & spellProto->GetSchoolMask())
                 TakenTotalCasterMod += (float((*i)->GetAmount()));
         }
 
         // From caster spells
         AuraEffectList const& mOwnerTaken = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_FROM_CASTER);
         for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
             if ((*i)->GetCasterGUID() == caster->GetGUID() && (*i)->IsAffectingSpell(spellProto))
                 AddPct(TakenTotalMod, (*i)->GetAmount());
 
         int32 TakenAdvertisedBenefit = SpellBaseDamageBonusTaken(spellProto->GetSchoolMask());
 
         // Check for table values
         float coeff = effect->BonusCoefficient;
 
         // Default calculation
         if (TakenAdvertisedBenefit)
         {
             float factorMod = CalculateLevelPenalty(spellProto) * stack;
             // level penalty still applied on Taken bonus - is it blizzlike?
             if (Player* modOwner = GetSpellModOwner())
             {
                 coeff *= 100.0f;
                 modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
                 coeff /= 100.0f;
             }
             TakenTotal += int32(TakenAdvertisedBenefit * coeff * factorMod);
         }
     }
 
     float tmpDamage = 0.0f;
 
     if (TakenTotalCasterMod)
     {
         if (TakenTotal < 0)
         {
             if (TakenTotalMod < 1)
                 tmpDamage = ((float(CalculatePct(pdamage, TakenTotalCasterMod) + TakenTotal) * TakenTotalMod) + CalculatePct(pdamage, TakenTotalCasterMod));
             else
                 tmpDamage = ((float(CalculatePct(pdamage, TakenTotalCasterMod) + TakenTotal) + CalculatePct(pdamage, TakenTotalCasterMod)) * TakenTotalMod);
         }
         else if (TakenTotalMod < 1)
             tmpDamage = ((CalculatePct(float(pdamage) + TakenTotal, TakenTotalCasterMod) * TakenTotalMod) + CalculatePct(float(pdamage) + TakenTotal, TakenTotalCasterMod));
     }
     if (!tmpDamage)
         tmpDamage = (float(pdamage) + TakenTotal) * TakenTotalMod;
 
     return uint32(std::max(tmpDamage, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::SpellDamagePctDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		DamageEffectType	damagetype
	)		const

 {
     if (!spellProto || !victim || damagetype == DIRECT_DAMAGE)
         return 1.0f;
 
     // Some spells don't benefit from pct done mods
     if (spellProto->HasAttribute(SPELL_ATTR6_NO_DONE_PCT_DAMAGE_MODS))
         return 1.0f;
 
     // For totems pct done mods are calculated when its calculation is run on the player in SpellDamageBonusDone.
     if (GetTypeId() == TYPEID_UNIT && IsTotem())
         return 1.0f;
 
     // Done total percent damage auras
     float DoneTotalMod = 1.0f;
 
     // Pet damage?
     if (GetTypeId() == TYPEID_UNIT && !IsPet())
         DoneTotalMod *= ToCreature()->GetSpellDamageMod(ToCreature()->GetCreatureTemplate()->rank);
 
     AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
     for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
     {
         if (spellProto->EquippedItemClass == -1 && (*i)->GetSpellInfo()->EquippedItemClass != -1)    //prevent apply mods from weapon specific case to non weapon specific spells (Example: thunder clap and two-handed weapon specialization)
             continue;
 
         if ((*i)->GetMiscValue() & spellProto->GetSchoolMask())
         {
             if ((*i)->GetSpellInfo()->EquippedItemClass == -1)
                 AddPct(DoneTotalMod, (*i)->GetAmount());
             else if (!((*i)->GetSpellInfo()->AttributesEx5 & SPELL_ATTR5_SPECIAL_ITEM_CLASS_CHECK) && ((*i)->GetSpellInfo()->EquippedItemSubClassMask == 0))
                 AddPct(DoneTotalMod, (*i)->GetAmount());
             else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellInfo()))
                 AddPct(DoneTotalMod, (*i)->GetAmount());
         }
     }
 
     uint32 creatureTypeMask = victim->GetCreatureTypeMask();
 
     AuraEffectList const& mDamageDoneVersus = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
     for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin(); i != mDamageDoneVersus.end(); ++i)
         if (creatureTypeMask & uint32((*i)->GetMiscValue()))
             AddPct(DoneTotalMod, (*i)->GetAmount());
 
     // bonus against aurastate
     AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
     for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
         if (victim->HasAuraState(AuraStateType((*i)->GetMiscValue())))
             AddPct(DoneTotalMod, (*i)->GetAmount());
 
     // Add SPELL_AURA_MOD_DAMAGE_DONE_FOR_MECHANIC percent bonus
     AddPct(DoneTotalMod, GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_DAMAGE_DONE_FOR_MECHANIC, spellProto->Mechanic));
 
     // done scripted mod (take it from owner)
     Unit const* owner = GetOwner() ? GetOwner() : this;
     AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(spellProto))
             continue;
 
         switch ((*i)->GetMiscValue())
         {
             case 4920: // Molten Fury
             case 4919:
             {
                 if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             }
             case 6917: // Death's Embrace damage effect
             case 6926:
             case 6928:
             {
                 // Health at 25% or less (25% stored at effect 2 of the spell)
                 if (victim->HealthBelowPct(CalculateSpellDamage(this, (*i)->GetSpellInfo(), EFFECT_2)))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             }
             case 6916: // Death's Embrace heal effect
             case 6925:
             case 6927:
                 if (HealthBelowPct(CalculateSpellDamage(this, (*i)->GetSpellInfo(), EFFECT_2)))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             // Soul Siphon
             case 4992:
             case 4993:
             {
                 // effect 1 m_amount
                 int32 maxPercent = (*i)->GetAmount();
                 // effect 0 m_amount
                 int32 stepPercent = CalculateSpellDamage(this, (*i)->GetSpellInfo(), 0);
                 // count affliction effects and calc additional damage in percentage
                 int32 modPercent = 0;
                 AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
                 for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
                 {
                     Aura const* aura = itr->second->GetBase();
                     SpellInfo const* spell = aura->GetSpellInfo();
                     if (spell->SpellFamilyName != SPELLFAMILY_WARLOCK || !(spell->SpellFamilyFlags[1] & 0x0004071B || spell->SpellFamilyFlags[0] & 0x8044C402))
                         continue;
                     modPercent += stepPercent * aura->GetStackAmount();
                     if (modPercent >= maxPercent)
                     {
                         modPercent = maxPercent;
                         break;
                     }
                 }
                 AddPct(DoneTotalMod, modPercent);
                 break;
             }
             case 5481: // Starfire Bonus
             {
                 if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, flag128(0x200002, 0, 0)))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             }
         }
     }
 
     // Custom scripted damage
     switch (spellProto->SpellFamilyName)
     {
         case SPELLFAMILY_MAGE:
             // Ice Lance
             if (spellProto->SpellIconID == 186)
                 if (victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
                     DoneTotalMod *= 2.0f;
 
             // Torment the weak
             if (spellProto->GetSchoolMask() & SPELL_SCHOOL_MASK_ARCANE)
             {
                 if (victim->HasAuraWithMechanic((1<<MECHANIC_SNARE)|(1<<MECHANIC_SLOW_ATTACK)))
                 {
                     AuraEffectList const& mDumyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
                     for (AuraEffectList::const_iterator i = mDumyAuras.begin(); i != mDumyAuras.end(); ++i)
                     {
                         if ((*i)->GetSpellInfo()->SpellIconID == 2215)
                         {
                             AddPct(DoneTotalMod, (*i)->GetAmount());
                             break;
                         }
                     }
                 }
             }
             break;
         case SPELLFAMILY_PRIEST:
             // Smite
             if (spellProto->SpellFamilyFlags[0] & 0x80)
             {
                 // Glyph of Smite
                 if (AuraEffect* aurEff = GetAuraEffect(55692, 0))
                     if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, flag128(0x100000, 0, 0), GetGUID()))
                         AddPct(DoneTotalMod, aurEff->GetAmount());
             }
             break;
         case SPELLFAMILY_WARLOCK:
             // Fire and Brimstone
             if (spellProto->SpellFamilyFlags[1] & 0x00020040)
                 if (victim->HasAuraState(AURA_STATE_CONFLAGRATE))
                 {
                     AuraEffectList const& mDumyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
                     for (AuraEffectList::const_iterator i = mDumyAuras.begin(); i != mDumyAuras.end(); ++i)
                         if ((*i)->GetSpellInfo()->SpellIconID == 3173)
                         {
                             AddPct(DoneTotalMod, (*i)->GetAmount());
                             break;
                         }
                 }
 
             // Shadow Bite (30% increase from each dot)
             if (spellProto->SpellFamilyFlags[1] & 0x00400000 && IsPet())
                 if (uint8 count = victim->GetDoTsByCaster(GetOwnerGUID()))
                     AddPct(DoneTotalMod, 30 * count);
 
             // Drain Soul - increased damage for targets under 25 % HP
             if (spellProto->SpellFamilyFlags[0] & 0x00004000)
                 if (HasAura(100001))
                     DoneTotalMod *= 2;
             break;
         case SPELLFAMILY_DEATHKNIGHT:
             // Sigil of the Vengeful Heart
             if (spellProto->SpellFamilyFlags[0] & 0x2000)
                 if (AuraEffect* aurEff = GetAuraEffect(64962, EFFECT_1))
                     DoneTotalMod += aurEff->GetAmount();
             break;
     }
 
     return DoneTotalMod;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellHealingBonusDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		uint32	healamount,
		DamageEffectType	damagetype,
		SpellEffectInfo const *	effect,
		uint32	stack = `1`
	)		const

 {
     // For totems get healing bonus from owner (statue isn't totem in fact)
     if (GetTypeId() == TYPEID_UNIT && IsTotem())
         if (Unit* owner = GetOwner())
             return owner->SpellHealingBonusDone(victim, spellProto, healamount, damagetype, spellEffect, stack);
 
     // No bonus healing for potion spells
     if (spellProto->SpellFamilyName == SPELLFAMILY_POTION)
         return healamount;
 
     int32 DoneTotal = 0;
 
     // done scripted mod (take it from owner)
     Unit const* owner = GetOwner() ? GetOwner() : this;
     AuraEffectList const& mOverrideClassScript= owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(spellProto))
             continue;
         switch ((*i)->GetMiscValue())
         {
             case 4415: // Increased Rejuvenation Healing
             case 4953:
             case 3736: // Hateful Totem of the Third Wind / Increased Lesser Healing Wave / LK Arena (4/5/6) Totem of the Third Wind / Savage Totem of the Third Wind
                 DoneTotal += (*i)->GetAmount();
                 break;
             case   21: // Test of Faith
             case 6935:
             case 6918:
                 if (victim->HealthBelowPct(50))
                     AddPct(DoneTotal, (*i)->GetAmount());
                 break;
             case 8477: // Nourish Heal Boost
             {
                 int32 stepPercent = (*i)->GetAmount();
                 int32 modPercent = 0;
                 AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
                 for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
                 {
                     Aura const* aura = itr->second->GetBase();
                     if (aura->GetCasterGUID() != GetGUID())
                         continue;
                     SpellInfo const* m_spell = aura->GetSpellInfo();
                     if (m_spell->SpellFamilyName != SPELLFAMILY_DRUID ||
                         !(m_spell->SpellFamilyFlags[1] & 0x00000010 || m_spell->SpellFamilyFlags[0] & 0x50))
                         continue;
                     modPercent += stepPercent * aura->GetStackAmount();
                 }
                 AddPct(DoneTotal, modPercent);
                 break;
             }
             default:
                 break;
         }
     }
 
     // Done fixed damage bonus auras
     int32 DoneAdvertisedBenefit = SpellBaseHealingBonusDone(spellProto->GetSchoolMask());
 
     // Check for table values
     float coeff = spellEffect->BonusCoefficient;
     float factorMod = 1.0f;
     if (spellEffect->BonusCoefficientFromAP > 0.0f)
     {
         DoneTotal += int32(spellEffect->BonusCoefficientFromAP * stack * GetTotalAttackPowerValue(
             (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK));
     }
     else if (coeff <= 0.0f)
     {
         // No bonus healing for SPELL_DAMAGE_CLASS_NONE class spells by default
         if (spellProto->DmgClass == SPELL_DAMAGE_CLASS_NONE)
             return healamount;
     }
 
     // Default calculation
     if (DoneAdvertisedBenefit)
     {
         factorMod *= CalculateLevelPenalty(spellProto) * stack;
 
         if (Player* modOwner = GetSpellModOwner())
         {
             coeff *= 100.0f;
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
             coeff /= 100.0f;
         }
 
         DoneTotal += int32(DoneAdvertisedBenefit * coeff * factorMod);
     }
 
     for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect)
             continue;
         switch (effect->ApplyAuraName)
         {
             // Bonus healing does not apply to these spells
             case SPELL_AURA_PERIODIC_LEECH:
             case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
                 DoneTotal = 0;
                 break;
         }
         if (effect->Effect == SPELL_EFFECT_HEALTH_LEECH)
             DoneTotal = 0;
     }
 
     // Done Percentage for DOT is already calculated, no need to do it again. The percentage mod is applied in Aura::HandleAuraSpecificMods.
     float heal = float(int32(healamount) + DoneTotal) * (damagetype == DOT ? 1.0f : SpellHealingPctDone(victim, spellProto));
     // apply spellmod to Done amount
     if (Player* modOwner = GetSpellModOwner())
         modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, heal);
 
     return uint32(std::max(heal, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Unit::SpellHealingBonusTaken	(	Unit *	caster,
		SpellInfo const *	spellProto,
		uint32	healamount,
		DamageEffectType	damagetype,
		SpellEffectInfo const *	effect,
		uint32	stack = `1`
	)		const

 {
     float TakenTotalMod = 1.0f;
 
     // Healing taken percent
     float minval = float(GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT));
     if (minval)
         AddPct(TakenTotalMod, minval);
 
     float maxval = float(GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT));
     if (maxval)
         AddPct(TakenTotalMod, maxval);
 
     // Tenacity increase healing % taken
     if (AuraEffect const* Tenacity = GetAuraEffect(58549, 0))
         AddPct(TakenTotalMod, Tenacity->GetAmount());
 
     // Healing Done
     int32 TakenTotal = 0;
 
     // Taken fixed damage bonus auras
     int32 TakenAdvertisedBenefit = SpellBaseHealingBonusTaken(spellProto->GetSchoolMask());
 
     // Nourish cast
     if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID && spellProto->SpellFamilyFlags[1] & 0x2000000)
     {
         // Rejuvenation, Regrowth, Lifebloom, or Wild Growth
         if (GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, flag128(0x50, 0x4000010, 0)))
             // increase healing by 20%
             TakenTotalMod *= 1.2f;
     }
 
     // Check for table values
     float coeff = spellEffect->BonusCoefficient;
     float factorMod = 1.0f;
     if (coeff <= 0.0f)
     {
         // No bonus healing for SPELL_DAMAGE_CLASS_NONE class spells by default
         if (spellProto->DmgClass == SPELL_DAMAGE_CLASS_NONE)
         {
             healamount = uint32(std::max((float(healamount) * TakenTotalMod), 0.0f));
             return healamount;
         }
     }
 
     // Default calculation
     if (TakenAdvertisedBenefit)
     {
         factorMod *= CalculateLevelPenalty(spellProto) * int32(stack);
         if (Player* modOwner = GetSpellModOwner())
         {
             coeff *= 100.0f;
             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
             coeff /= 100.0f;
         }
 
         TakenTotal += int32(TakenAdvertisedBenefit * coeff * factorMod);
     }
 
     AuraEffectList const& mHealingGet= GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_RECEIVED);
     for (AuraEffectList::const_iterator i = mHealingGet.begin(); i != mHealingGet.end(); ++i)
         if (caster->GetGUID() == (*i)->GetCasterGUID() && (*i)->IsAffectingSpell(spellProto))
             AddPct(TakenTotalMod, (*i)->GetAmount());
 
     for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect)
             continue;
         switch (effect->ApplyAuraName)
         {
             // Bonus healing does not apply to these spells
         case SPELL_AURA_PERIODIC_LEECH:
         case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
             TakenTotal = 0;
             break;
         }
         if (effect->Effect == SPELL_EFFECT_HEALTH_LEECH)
             TakenTotal = 0;
     }
 
     float heal = float(int32(healamount) + TakenTotal) * TakenTotalMod;
 
     return uint32(std::max(heal, 0.0f));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Unit::SpellHealingPctDone	(	Unit *	victim,
		SpellInfo const *	spellProto
	)		const

 {
     // For totems pct done mods are calculated when its calculation is run on the player in SpellHealingBonusDone.
     if (GetTypeId() == TYPEID_UNIT && IsTotem())
         return 1.0f;
 
     // No bonus healing for potion spells
     if (spellProto->SpellFamilyName == SPELLFAMILY_POTION)
         return 1.0f;
 
     float DoneTotalMod = 1.0f;
 
     // Healing done percent
     AuraEffectList const& mHealingDonePct = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_DONE_PERCENT);
     for (AuraEffectList::const_iterator i = mHealingDonePct.begin(); i != mHealingDonePct.end(); ++i)
         AddPct(DoneTotalMod, (*i)->GetAmount());
 
     // done scripted mod (take it from owner)
     Unit const* owner = GetOwner() ? GetOwner() : this;
     AuraEffectList const& mOverrideClassScript= owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
     for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(spellProto))
             continue;
 
         switch ((*i)->GetMiscValue())
         {
             case   21: // Test of Faith
             case 6935:
             case 6918:
                 if (victim->HealthBelowPct(50))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             case 7798: // Glyph of Regrowth
             {
                 if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, flag128(0x40, 0, 0)))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             }
             case 8477: // Nourish Heal Boost
             {
                 int32 stepPercent = (*i)->GetAmount();
                 int32 modPercent = 0;
                 AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
                 for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
                 {
                     Aura const* aura = itr->second->GetBase();
                     if (aura->GetCasterGUID() != GetGUID())
                         continue;
                     SpellInfo const* m_spell = aura->GetSpellInfo();
                     if (m_spell->SpellFamilyName != SPELLFAMILY_DRUID ||
                         !(m_spell->SpellFamilyFlags[1] & 0x00000010 || m_spell->SpellFamilyFlags[0] & 0x50))
                         continue;
                     modPercent += stepPercent * aura->GetStackAmount();
                 }
                 AddPct(DoneTotalMod, modPercent);
                 break;
             }
             case 7871: // Glyph of Lesser Healing Wave
             {
                 if (victim->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, flag128(0, 0x00000400, 0), GetGUID()))
                     AddPct(DoneTotalMod, (*i)->GetAmount());
                 break;
             }
             default:
                 break;
         }
     }
 
     return DoneTotalMod;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellMissInfo Unit::SpellHitResult	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		bool	canReflect = `false`
	)

Todo:: client not show miss log for this spells - so need find info for this in dbc and use it!

 {
     // Check for immune
     if (victim->IsImmunedToSpell(spellInfo))
         return SPELL_MISS_IMMUNE;
 
     // All positive spells can`t miss
     if (spellInfo->IsPositive() && !IsHostileTo(victim)) // prevent from affecting enemy by "positive" spell
         return SPELL_MISS_NONE;
 
     // Check for immune
     if (victim->IsImmunedToDamage(spellInfo))
         return SPELL_MISS_IMMUNE;
 
     if (this == victim)
         return SPELL_MISS_NONE;
 
     // Return evade for units in evade mode
     if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsInEvadeMode())
         return SPELL_MISS_EVADE;
 
     // Try victim reflect spell
     if (CanReflect)
     {
         int32 reflectchance = victim->GetTotalAuraModifier(SPELL_AURA_REFLECT_SPELLS);
         Unit::AuraEffectList const& mReflectSpellsSchool = victim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
         for (Unit::AuraEffectList::const_iterator i = mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end(); ++i)
             if ((*i)->GetMiscValue() & spellInfo->GetSchoolMask())
                 reflectchance += (*i)->GetAmount();
         if (reflectchance > 0 && roll_chance_i(reflectchance))
         {
             // Start triggers for remove charges if need (trigger only for victim, and mark as active spell)
             ProcDamageAndSpell(victim, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, spellInfo);
             return SPELL_MISS_REFLECT;
         }
     }
 
     switch (spellInfo->DmgClass)
     {
         case SPELL_DAMAGE_CLASS_RANGED:
         case SPELL_DAMAGE_CLASS_MELEE:
             return MeleeSpellHitResult(victim, spellInfo);
         case SPELL_DAMAGE_CLASS_NONE:
             return SPELL_MISS_NONE;
         case SPELL_DAMAGE_CLASS_MAGIC:
             return MagicSpellHitResult(victim, spellInfo);
     }
     return SPELL_MISS_NONE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::StartReactiveTimer ( ReactiveType reactive )

inline

2134 { m_reactiveTimer[reactive] = REACTIVE_TIMER_START;}

Unit::m_reactiveTimer

uint32 m_reactiveTimer[MAX_REACTIVE]

Definition: Unit.h:2299

REACTIVE_TIMER_START

#define REACTIVE_TIMER_START

Definition: Unit.h:1270

Here is the caller graph for this function:

void Unit::StopAttackFaction ( uint32 faction_id )

 {
     if (Unit* victim = GetVictim())
     {
         if (victim->GetFactionTemplateEntry()->Faction == faction_id)
         {
             AttackStop();
             if (IsNonMeleeSpellCast(false))
                 InterruptNonMeleeSpells(false);
 
             // melee and ranged forced attack cancel
             if (GetTypeId() == TYPEID_PLAYER)
                 ToPlayer()->SendAttackSwingCancelAttack();
         }
     }
 
     AttackerSet const& attackers = getAttackers();
     for (AttackerSet::const_iterator itr = attackers.begin(); itr != attackers.end();)
     {
         if ((*itr)->GetFactionTemplateEntry()->Faction == faction_id)
         {
             (*itr)->AttackStop();
             itr = attackers.begin();
         }
         else
             ++itr;
     }
 
     getHostileRefManager().deleteReferencesForFaction(faction_id);
 
     for (ControlList::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
             (*itr)->StopAttackFaction(faction_id);
 }

Here is the call graph for this function:

void Unit::StopMoving ( )

-------—End of Pet responses methods-------—

 {
     ClearUnitState(UNIT_STATE_MOVING);
 
     // not need send any packets if not in world or not moving
     if (!IsInWorld() || movespline->Finalized())
         return;
 
     // Update position now since Stop does not start a new movement that can be updated later
     UpdateSplinePosition();
     Movement::MoveSplineInit init(this);
     init.Stop();
 }

Here is the call graph for this function:

void Unit::Talk	(	std::string const &	text,
		ChatMsg	msgType,
		Language	language,
		float	textRange,
		WorldObject const *	target
	)

virtual

 {
     Trinity::CustomChatTextBuilder builder(this, msgType, text, language, target);
     Trinity::LocalizedPacketDo<Trinity::CustomChatTextBuilder> localizer(builder);
     Trinity::PlayerDistWorker<Trinity::LocalizedPacketDo<Trinity::CustomChatTextBuilder> > worker(this, textRange, localizer);
     VisitNearbyWorldObject(textRange, worker);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::Talk	(	uint32	textId,
		ChatMsg	msgType,
		float	textRange,
		WorldObject const *	target
	)

 {
     if (!sBroadcastTextStore.LookupEntry(textId))
     {
         TC_LOG_ERROR("entities.unit", "WorldObject::MonsterText: `broadcast_text` was not %u found", textId);
         return;
     }
 
     Trinity::BroadcastTextBuilder builder(this, msgType, textId, target);
     Trinity::LocalizedPacketDo<Trinity::BroadcastTextBuilder> localizer(builder);
     Trinity::PlayerDistWorker<Trinity::LocalizedPacketDo<Trinity::BroadcastTextBuilder> > worker(this, textRange, localizer);
     VisitNearbyWorldObject(textRange, worker);
 }

Here is the call graph for this function:

void Unit::TauntApply ( Unit * victim )

 {
     ASSERT(GetTypeId() == TYPEID_UNIT);
 
     if (!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && taunter->ToPlayer()->IsGameMaster()))
         return;
 
     if (!CanHaveThreatList())
         return;
 
     Creature* creature = ToCreature();
 
     if (creature->HasReactState(REACT_PASSIVE))
         return;
 
     Unit* target = GetVictim();
     if (target && target == taunter)
         return;
 
     SetInFront(taunter);
     if (creature->IsAIEnabled)
         creature->AI()->AttackStart(taunter);
 
     //m_ThreatManager.tauntApply(taunter);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::TauntFadeOut ( Unit * taunter )

 {
     ASSERT(GetTypeId() == TYPEID_UNIT);
 
     if (!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && taunter->ToPlayer()->IsGameMaster()))
         return;
 
     if (!CanHaveThreatList())
         return;
 
     Creature* creature = ToCreature();
 
     if (creature->HasReactState(REACT_PASSIVE))
         return;
 
     Unit* target = GetVictim();
     if (!target || target != taunter)
         return;
 
     if (m_ThreatManager.isThreatListEmpty())
     {
         if (creature->IsAIEnabled)
             creature->AI()->EnterEvadeMode(CreatureAI::EVADE_REASON_NO_HOSTILES);
         return;
     }
 
     target = creature->SelectVictim();  // might have more taunt auras remaining
 
     if (target && target != taunter)
     {
         SetInFront(target);
         if (creature->IsAIEnabled)
             creature->AI()->AttackStart(target);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::TextEmote	(	std::string const &	text,
		WorldObject const *	target = `nullptr`,
		bool	isBossEmote = `false`
	)

virtual

 {
     Talk(text, isBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, LANG_UNIVERSAL, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Unit::TextEmote	(	uint32	textId,
		WorldObject const *	target = `nullptr`,
		bool	isBossEmote = `false`
	)

 {
     Talk(textId, isBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
 }

Here is the call graph for this function:

Pet* Unit::ToPet ( )

inline

2200 { if (IsPet()) return reinterpret_cast<Pet*>(this); else return NULL; }

arena_t NULL

Definition: jemalloc_internal.h:624

Unit::IsPet

bool IsPet() const

Definition: Unit.h:1403

Pet

Definition: Pet.h:46

Here is the caller graph for this function:

Pet const* Unit::ToPet ( ) const

inline

2201 { if (IsPet()) return reinterpret_cast<Pet const*>(this); else return NULL; }

arena_t NULL

Definition: jemalloc_internal.h:624

Unit::IsPet

bool IsPet() const

Definition: Unit.h:1403

const

#define const

Definition: zconf.h:217

Pet

Definition: Pet.h:46

TempSummon* Unit::ToTempSummon ( )

inline

2206 { if (IsSummon()) return reinterpret_cast<TempSummon*>(this); else return NULL; }

TempSummon

Definition: TemporarySummon.h:40

arena_t NULL

Definition: jemalloc_internal.h:624

Unit::IsSummon

bool IsSummon() const

Definition: Unit.h:1401

Here is the caller graph for this function:

TempSummon const* Unit::ToTempSummon ( ) const

inline

2207 { if (IsSummon()) return reinterpret_cast<TempSummon const*>(this); else return NULL; }

TempSummon

Definition: TemporarySummon.h:40

arena_t NULL

Definition: jemalloc_internal.h:624

const

#define const

Definition: zconf.h:217

Unit::IsSummon

bool IsSummon() const

Definition: Unit.h:1401

Totem* Unit::ToTotem ( )

inline

2203 { if (IsTotem()) return reinterpret_cast<Totem*>(this); else return NULL; }

arena_t NULL

Definition: jemalloc_internal.h:624

Totem

Definition: Totem.h:38

Unit::IsTotem

bool IsTotem() const

Definition: Unit.h:1405

Here is the caller graph for this function:

Totem const* Unit::ToTotem ( ) const

inline

2204 { if (IsTotem()) return reinterpret_cast<Totem const*>(this); else return NULL; }