TrinityCore: Creature Class Reference

uint16 m_LootMode

Definition: Creature.h:767

Here is the caller graph for this function:

void Creature::AddToWorld ( )

overridevirtual

Register the creature for guid lookup

Reimplemented from Object.

Reimplemented in Pet.

 {
     if (!IsInWorld())
     {
         if (GetZoneScript())
             GetZoneScript()->OnCreatureCreate(this);
 
         GetMap()->GetObjectsStore().Insert<Creature>(GetGUID(), this);
         if (m_spawnId)
             GetMap()->GetCreatureBySpawnIdStore().insert(std::make_pair(m_spawnId, this));
 
         Unit::AddToWorld();
         SearchFormation();
         AIM_Initialize();
         if (IsVehicle())
             GetVehicleKit()->Install();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

CreatureAI* Creature::AI ( ) const

inline

525 { return (CreatureAI*)i_AI; }

Unit::i_AI

UnitAI * i_AI

Definition: Unit.h:2242

CreatureAI

Definition: CreatureAI.h:68

bool Creature::AIM_Initialize ( CreatureAI * ai = NULL )

 {
     // make sure nothing can change the AI during AI update
     if (m_AI_locked)
     {
         TC_LOG_DEBUG("scripts", "AIM_Initialize: failed to init, locked.");
         return false;
     }
 
     UnitAI* oldAI = i_AI;
 
     Motion_Initialize();
 
     i_AI = ai ? ai : FactorySelector::selectAI(this);
     delete oldAI;
     IsAIEnabled = true;
     i_AI->InitializeAI();
     // Initialize vehicle
     if (GetVehicleKit())
         GetVehicleKit()->Reset();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::AllLootRemovedFromCorpse ( )

 {
     if (loot.loot_type != LOOT_SKINNING && !IsPet() && GetCreatureTemplate()->SkinLootId && hasLootRecipient())
         if (LootTemplates_Skinning.HaveLootFor(GetCreatureTemplate()->SkinLootId))
             SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
 
     time_t now = time(NULL);
     // Do not reset corpse remove time if corpse is already removed
     if (m_corpseRemoveTime <= now)
         return;
 
     float decayRate = sWorld->getRate(RATE_CORPSE_DECAY_LOOTED);
 
     // corpse skinnable, but without skinning flag, and then skinned, corpse will despawn next update
     if (loot.loot_type == LOOT_SKINNING)
         m_corpseRemoveTime = now;
     else
         m_corpseRemoveTime = now + uint32(m_corpseDelay * decayRate);
 
     m_respawnTime = m_corpseRemoveTime + m_respawnDelay;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Implements Unit.

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

Here is the call graph for this function:

void Creature::CallAssistance ( )

 {
     if (!m_AlreadyCallAssistance && GetVictim() && !IsPet() && !IsCharmed())
     {
         SetNoCallAssistance(true);
 
         float radius = sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS);
 
         if (radius > 0)
         {
             std::list<Creature*> assistList;
 
             {
                 CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
                 Cell cell(p);
                 cell.SetNoCreate();
 
                 Trinity::AnyAssistCreatureInRangeCheck u_check(this, GetVictim(), radius);
                 Trinity::CreatureListSearcher<Trinity::AnyAssistCreatureInRangeCheck> searcher(this, assistList, u_check);
 
                 TypeContainerVisitor<Trinity::CreatureListSearcher<Trinity::AnyAssistCreatureInRangeCheck>, GridTypeMapContainer >  grid_creature_searcher(searcher);
 
                 cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
             }
 
             if (!assistList.empty())
             {
                 AssistDelayEvent* e = new AssistDelayEvent(EnsureVictim()->GetGUID(), *this);
                 while (!assistList.empty())
                 {
                     // Pushing guids because in delay can happen some creature gets despawned => invalid pointer
                     e->AddAssistant((*assistList.begin())->GetGUID());
                     assistList.pop_front();
                 }
                 m_Events.AddEvent(e, m_Events.CalculateTime(sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY)));
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::CallForHelp ( float fRadius )

 {
     if (radius <= 0.0f || !GetVictim() || IsPet() || IsCharmed())
         return;
 
     CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
     Cell cell(p);
     cell.SetNoCreate();
 
     Trinity::CallOfHelpCreatureInRangeDo u_do(this, GetVictim(), radius);
     Trinity::CreatureWorker<Trinity::CallOfHelpCreatureInRangeDo> worker(this, u_do);
 
     TypeContainerVisitor<Trinity::CreatureWorker<Trinity::CallOfHelpCreatureInRangeDo>, GridTypeMapContainer >  grid_creature_searcher(worker);
 
     cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CanAlwaysSee ( WorldObject const * obj ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

 {
     if (IsAIEnabled && AI()->CanSeeAlways(obj))
         return true;
 
     return false;
 }

Here is the call graph for this function:

bool Creature::CanAssistTo	(	const Unit *	u,
		const Unit *	enemy,
		bool	checkfaction = `true`
	)		const

 {
     if (IsInEvadeMode())
         return false;
 
     // is it true?
     if (!HasReactState(REACT_AGGRESSIVE))
         return false;
 
     // we don't need help from zombies :)
     if (!IsAlive())
         return false;
 
     // we don't need help from non-combatant ;)
     if (IsCivilian())
         return false;
 
     if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_IMMUNE_TO_NPC))
         return false;
 
     // skip fighting creature
     if (IsInCombat())
         return false;
 
     // only free creature
     if (!GetCharmerOrOwnerGUID().IsEmpty())
         return false;
 
     // only from same creature faction
     if (checkfaction)
     {
         if (getFaction() != u->getFaction())
             return false;
     }
     else
     {
         if (!IsFriendlyTo(u))
             return false;
     }
 
     // skip non hostile to caster enemy creatures
     if (!IsHostileTo(enemy))
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CanCreatureAttack	(	Unit const *	victim,
		bool	force = `true`
	)		const

 {
     if (!victim->IsInMap(this))
         return false;
 
     if (!IsValidAttackTarget(victim))
         return false;
 
     if (!victim->isInAccessiblePlaceFor(this))
         return false;
 
     if (IsAIEnabled && !AI()->CanAIAttack(victim))
         return false;
 
     if (GetMap()->IsDungeon())
         return true;
 
     // if the mob is actively being damaged, do not reset due to distance unless it's a world boss
     if (!isWorldBoss())
         if (time(NULL) - GetLastDamagedTime() <= MAX_AGGRO_RESET_TIME)
             return true;
 
     //Use AttackDistance in distance check if threat radius is lower. This prevents creature bounce in and out of combat every update tick.
     float dist = std::max(GetAttackDistance(victim), sWorld->getFloatConfig(CONFIG_THREAT_RADIUS)) + m_CombatDistance;
 
     if (Unit* unit = GetCharmerOrOwner())
         return victim->IsWithinDist(unit, dist);
     else
         return victim->IsInDist(&m_homePosition, dist);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CanFly ( ) const

inlineoverridevirtual

Implements Unit.

500 { return (GetCreatureTemplate()->InhabitType & INHABIT_AIR) != 0; }

INHABIT_AIR

Definition: Creature.h:333

Creature::_pickpocketLootRestore

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

Here is the caller graph for this function:

bool Creature::CanGeneratePickPocketLoot ( ) const

inline

581 { return _pickpocketLootRestore <= time(NULL); }

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

time_t _pickpocketLootRestore

Timers.

Definition: Creature.h:732

bool Creature::CanStartAttack	(	Unit const *	u,
		bool	force
	)		const

Todo:: should switch to range attack

 {
     if (IsCivilian())
         return false;
 
     // This set of checks is should be done only for creatures
     if ((HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC) && who->GetTypeId() != TYPEID_PLAYER)                                   // flag is valid only for non player characters
         || (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC) && who->GetTypeId() == TYPEID_PLAYER)                                 // immune to PC and target is a player, return false
         || (who->GetOwner() && who->GetOwner()->GetTypeId() == TYPEID_PLAYER && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC))) // player pets are immune to pc as well
         return false;
 
     // Do not attack non-combat pets
     if (who->GetTypeId() == TYPEID_UNIT && who->GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET)
         return false;
 
     if (!CanFly() && (GetDistanceZ(who) > CREATURE_Z_ATTACK_RANGE + m_CombatDistance))
         //|| who->IsControlledByPlayer() && who->IsFlying()))
         // we cannot check flying for other creatures, too much map/vmap calculation
         return false;
 
     if (!force)
     {
         if (!_IsTargetAcceptable(who))
             return false;
 
         if (who->IsInCombat() && IsWithinDist(who, ATTACK_DISTANCE))
             if (Unit* victim = who->getAttackerForHelper())
                 if (IsWithinDistInMap(victim, sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS)))
                     force = true;
 
         if (!force && (IsNeutralToAll() || !IsWithinDistInMap(who, GetAttackDistance(who) + m_CombatDistance)))
             return false;
     }
 
     if (!CanCreatureAttack(who, force))
         return false;
 
     // No aggro from gray creatures
     if (CheckNoGrayAggroConfig(who->getLevelForTarget(this), getLevelForTarget(who)))
         return false;
 
     return IsWithinLOSInMap(who);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CanSwim ( ) const

inline

499 { return (GetCreatureTemplate()->InhabitType & INHABIT_WATER) != 0 || IsPet(); }

INHABIT_WATER

Definition: Creature.h:332

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

Unit::IsPet

bool IsPet() const

Definition: Unit.h:1403

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CanWalk ( ) const

inline

498 { return (GetCreatureTemplate()->InhabitType & INHABIT_GROUND) != 0; }

Creature::m_boundaryCheckTime

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

INHABIT_GROUND

Definition: Creature.h:331

Here is the caller graph for this function:

bool Creature::CheckNoGrayAggroConfig	(	uint32	playerLevel,
		uint32	creatureLevel
	)		const

private

 {
     if (Trinity::XP::GetColorCode(playerLevel, creatureLevel) != XP_GRAY)
         return false;
 
     uint32 notAbove = sWorld->getIntConfig(CONFIG_NO_GRAY_AGGRO_ABOVE);
     uint32 notBelow = sWorld->getIntConfig(CONFIG_NO_GRAY_AGGRO_BELOW);
     if (notAbove == 0 && notBelow == 0)
         return false;
 
     if (playerLevel <= notBelow || (playerLevel >= notAbove && notAbove > 0))
         return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::ClearTextRepeatGroup ( uint8 textGroup )

 {
     CreatureTextRepeatGroup::iterator groupItr = m_textRepeat.find(textGroup);
     if (groupItr != m_textRepeat.end())
         groupItr->second.clear();
 }

Here is the caller graph for this function:

bool Creature::Create	(	ObjectGuid::LowType	guidlow,
		Map *	map,
		uint32	phaseMask,
		uint32	entry,
		float	x,
		float	y,
		float	z,
		float	ang,
		CreatureData const *	data = `nullptr`,
		uint32	vehId = `0`
	)

Relocate before CreateFromProto, to initialize coords and allow returning correct zone id for selecting OutdoorPvP/Battlefield script

Need to be called after LoadCreaturesAddon - MOVEMENTFLAG_HOVER is set there

Relocate again with updated Z coord

Todo:: Replace with spell, handle from DB

 {
     ASSERT(map);
     SetMap(map);
 
     if (data && data->phaseid)
         SetInPhase(data->phaseid, false, true);
 
     if (data && data->phaseGroup)
         for (auto ph : sDB2Manager.GetPhasesForGroup(data->phaseGroup))
             SetInPhase(ph, false, true);
 
     CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
     if (!cinfo)
     {
         TC_LOG_ERROR("sql.sql", "Creature::Create(): creature template (guidlow: " UI64FMTD ", entry: %u) does not exist.", guidlow, entry);
         return false;
     }
 
     Relocate(x, y, z, ang);
 
     if (!CreateFromProto(guidlow, entry, data, vehId))
         return false;
 
     if (!IsPositionValid())
     {
         TC_LOG_ERROR("entities.unit", "Creature::Create(): given coordinates for creature (guidlow " UI64FMTD ", entry %d) are not valid (X: %f, Y: %f, Z: %f, O: %f)", guidlow, entry, x, y, z, ang);
         return false;
     }
 
     switch (GetCreatureTemplate()->rank)
     {
         case CREATURE_ELITE_RARE:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_RARE);
             break;
         case CREATURE_ELITE_ELITE:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_ELITE);
             break;
         case CREATURE_ELITE_RAREELITE:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_RAREELITE);
             break;
         case CREATURE_ELITE_WORLDBOSS:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_WORLDBOSS);
             break;
         default:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_NORMAL);
             break;
     }
 
     LoadCreaturesAddon();
 
     if (HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
     {
         z += GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
         Relocate(x, y, z, ang);
     }
 
     uint32 displayID = GetNativeDisplayId();
     CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
     if (minfo && !IsTotem())                               // Cancel load if no model defined or if totem
     {
         SetDisplayId(displayID);
         SetNativeDisplayId(displayID);
         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
     }
 
     LastUsedScriptID = GetCreatureTemplate()->ScriptID;
 
     if (IsSpiritHealer() || IsSpiritGuide())
     {
         m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
         m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
     }
 
     if (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_IGNORE_PATHFINDING)
         AddUnitState(UNIT_STATE_IGNORE_PATHFINDING);
 
     if (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_IMMUNITY_KNOCKBACK)
     {
         ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, true);
         ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK_DEST, true);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::CreateFromProto	(	ObjectGuid::LowType	guidlow,
		uint32	entry,
		CreatureData const *	data = `nullptr`,
		uint32	vehId = `0`
	)

protected

 {
     SetZoneScript();
     if (GetZoneScript() && data)
     {
         entry = GetZoneScript()->GetCreatureEntry(guidlow, data);
         if (!entry)
             return false;
     }
 
     CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
     if (!cinfo)
     {
         TC_LOG_ERROR("sql.sql", "Creature::CreateFromProto(): creature template (guidlow: " UI64FMTD ", entry: %u) does not exist.", guidlow, entry);
         return false;
     }
 
     SetOriginalEntry(entry);
 
     if (vehId || cinfo->VehicleId)
         Object::_Create(ObjectGuid::Create<HighGuid::Vehicle>(GetMapId(), entry, guidlow));
     else
         Object::_Create(ObjectGuid::Create<HighGuid::Creature>(GetMapId(), entry, guidlow));
 
     if (!UpdateEntry(entry, data))
         return false;
 
     if (!vehId)
     {
         if (GetCreatureTemplate()->VehicleId)
         {
             vehId = GetCreatureTemplate()->VehicleId;
             entry = GetCreatureTemplate()->Entry;
         }
         else
             vehId = cinfo->VehicleId;
     }
 
     if (vehId)
         CreateVehicleKit(vehId, entry, true);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::DeleteFromDB ( )

virtual

Reimplemented in Pet.

 {
     if (!m_spawnId)
     {
         TC_LOG_ERROR("entities.unit", "Trying to delete not saved %s!", GetGUID().ToString().c_str());
         return;
     }
 
     GetMap()->RemoveCreatureRespawnTime(m_spawnId);
     sObjectMgr->DeleteCreatureData(m_spawnId);
 
     SQLTransaction trans = WorldDatabase.BeginTransaction();
 
     PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE_ADDON);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAME_EVENT_CREATURE);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAME_EVENT_MODEL_EQUIP);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     WorldDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::DespawnOrUnsummon ( uint32 msTimeToDespawn = 0 )

 {
     if (TempSummon* summon = this->ToTempSummon())
         summon->UnSummon(msTimeToDespawn);
     else
         ForcedDespawn(msTimeToDespawn);
 }

Here is the call graph for this function:

void Creature::DisappearAndDie ( )

 {
     DestroyForNearbyPlayers();
     //SetVisibility(VISIBILITY_OFF);
     //ObjectAccessor::UpdateObjectVisibility(this);
     if (IsAlive())
         setDeathState(JUST_DIED);
     RemoveCorpse(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::DoFleeToGetAssistance ( )

Todo:: use 31365

 {
     if (!GetVictim())
         return;
 
     if (HasAuraType(SPELL_AURA_PREVENTS_FLEEING))
         return;
 
     float radius = sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS);
     if (radius >0)
     {
         Creature* creature = NULL;
 
         CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
         Cell cell(p);
         cell.SetNoCreate();
         Trinity::NearestAssistCreatureInCreatureRangeCheck u_check(this, GetVictim(), radius);
         Trinity::CreatureLastSearcher<Trinity::NearestAssistCreatureInCreatureRangeCheck> searcher(this, creature, u_check);
 
         TypeContainerVisitor<Trinity::CreatureLastSearcher<Trinity::NearestAssistCreatureInCreatureRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
 
         cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
 
         SetNoSearchAssistance(true);
         UpdateSpeed(MOVE_RUN, false);
 
         if (!creature)
             //SetFeared(true, EnsureVictim()->GetGUID(), 0, sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_FLEE_DELAY));
             SetControlled(true, UNIT_STATE_FLEEING);
         else
             GetMotionMaster()->MoveSeekAssistance(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::DoImmediateBoundaryCheck ( )

inline

643 { m_boundaryCheckTime = 0; }

uint32 m_boundaryCheckTime

Definition: Creature.h:738

Here is the caller graph for this function:

bool Creature::FocusTarget	(	Spell const *	focusSpell,
		WorldObject const *	target
	)

 {
     // already focused
     if (_focusSpell)
         return false;
 
     if ((!target || target == this) && !focusSpell->GetCastTime()) // instant cast, untargeted (or self-targeted) spell doesn't need any facing updates
         return false;
 
     _focusSpell = focusSpell;
 
     // "instant" creature casts that require re-targeting will be delayed by a short moment to prevent facing bugs
     bool shouldDelay = false;
 
     // set target, then force send update packet to players if it changed to provide appropriate facing
     ObjectGuid newTarget = target ? target->GetGUID() : ObjectGuid::Empty;
     if (GetGuidValue(UNIT_FIELD_TARGET) != newTarget)
     {
         SetGuidValue(UNIT_FIELD_TARGET, newTarget);
         if (target)
             SetFacingToObject(target);
 
         if ( // here we determine if the (relatively expensive) forced update is worth it, or whether we can afford to wait until the scheduled update tick
             ( // only require instant update for spells that actually have a visual
                 focusSpell->GetSpellInfo()->SpellVisual[0] ||
                 focusSpell->GetSpellInfo()->SpellVisual[1]
             ) && (
                 !focusSpell->GetCastTime() || // if the spell is instant cast
                 focusSpell->GetSpellInfo()->HasAttribute(SPELL_ATTR5_DONT_TURN_DURING_CAST) // client gets confused if we attempt to turn at the regularly scheduled update packet
             )
         )
         {
             std::list<Player*> playersNearby;
             GetPlayerListInGrid(playersNearby, GetVisibilityRange());
             for (Player* player : playersNearby)
             {
                 // only update players that are known to the client (have already been created)
                 if (player->HaveAtClient(this))
                 {
                     SendUpdateToPlayer(player);
                     shouldDelay = true;
                 }
             }
             if (shouldDelay)
                 shouldDelay = !(focusSpell->IsTriggered() || focusSpell->GetCastTime() || focusSpell->GetSpellInfo()->IsChanneled());
 
         }
     }
 
     // tell the creature that it should reacquire its current target after the cast is done (this is handled in ::Attack)
     MustReacquireTarget();
 
     bool canTurnDuringCast = !focusSpell->GetSpellInfo()->HasAttribute(SPELL_ATTR5_DONT_TURN_DURING_CAST);
     // Face the target - we need to do this before the unit state is modified for no-turn spells
     if (target)
         SetInFront(target);
     else if (!canTurnDuringCast)
         if(Unit* victim = GetVictim())
             SetInFront(victim); // ensure server-side orientation is correct at beginning of cast
 
     if (!canTurnDuringCast)
         AddUnitState(UNIT_STATE_CANNOT_TURN);
 
     return shouldDelay;
 }

Here is the call graph for this function:

void Creature::ForcedDespawn ( uint32 timeMSToDespawn = 0 )

private

 {
     if (timeMSToDespawn)
     {
         ForcedDespawnDelayEvent* pEvent = new ForcedDespawnDelayEvent(*this);
 
         m_Events.AddEvent(pEvent, m_Events.CalculateTime(timeMSToDespawn));
         return;
     }
 
     if (IsAlive())
         setDeathState(JUST_DIED);
 
     RemoveCorpse(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Creature::GetAggroRange ( Unit const * target ) const

 {
     // Determines the aggro range for creatures (usually pets), used mainly for aggressive pet target selection.
     // Based on data from wowwiki due to lack of 3.3.5a data
 
     if (target && this->IsPet())
     {
         uint32 targetLevel = 0;
 
         if (target->GetTypeId() == TYPEID_PLAYER)
             targetLevel = target->getLevelForTarget(this);
         else if (target->GetTypeId() == TYPEID_UNIT)
             targetLevel = target->ToCreature()->getLevelForTarget(this);
 
         uint32 myLevel = getLevelForTarget(target);
         int32 levelDiff = int32(targetLevel) - int32(myLevel);
 
         // The maximum Aggro Radius is capped at 45 yards (25 level difference)
         if (levelDiff < -25)
             levelDiff = -25;
 
         // The base aggro radius for mob of same level
         float aggroRadius = 20;
 
         // Aggro Radius varies with level difference at a rate of roughly 1 yard/level
         aggroRadius -= (float)levelDiff;
 
         // detect range auras
         aggroRadius += GetTotalAuraModifier(SPELL_AURA_MOD_DETECT_RANGE);
 
         // detected range auras
         aggroRadius += target->GetTotalAuraModifier(SPELL_AURA_MOD_DETECTED_RANGE);
 
         // Just in case, we don't want pets running all over the map
         if (aggroRadius > MAX_AGGRO_RADIUS)
             aggroRadius = MAX_AGGRO_RADIUS;
 
         // Minimum Aggro Radius for a mob seems to be combat range (5 yards)
         //  hunter pets seem to ignore minimum aggro radius so we'll default it a little higher
         if (aggroRadius < 10)
             aggroRadius = 10;
 
         return (aggroRadius);
     }
 
     // Default
     return 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Creature::GetAIName ( ) const

 {
     return sObjectMgr->GetCreatureTemplate(GetEntry())->AIName;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Creature::GetAttackDistance ( Unit const * player ) const

 {
     float aggroRate = sWorld->getRate(RATE_CREATURE_AGGRO);
     if (aggroRate == 0)
         return 0.0f;
 
     uint32 playerlevel   = player->getLevelForTarget(this);
     uint32 creaturelevel = getLevelForTarget(player);
 
     int32 leveldif       = int32(playerlevel) - int32(creaturelevel);
 
     // "The maximum Aggro Radius has a cap of 25 levels under. Example: A level 30 char has the same Aggro Radius of a level 5 char on a level 60 mob."
     if (leveldif < - 25)
         leveldif = -25;
 
     // "The aggro radius of a mob having the same level as the player is roughly 20 yards"
     float RetDistance = 20;
 
     // "Aggro Radius varies with level difference at a rate of roughly 1 yard/level"
     // radius grow if playlevel < creaturelevel
     RetDistance -= (float)leveldif;
 
     if (creaturelevel+5 <= sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
     {
         // detect range auras
         RetDistance += GetTotalAuraModifier(SPELL_AURA_MOD_DETECT_RANGE);
 
         // detected range auras
         RetDistance += player->GetTotalAuraModifier(SPELL_AURA_MOD_DETECTED_RANGE);
     }
 
     // "Minimum Aggro Radius for a mob seems to be combat range (5 yards)"
     if (RetDistance < 5)
         RetDistance = 5;
 
     return (RetDistance*aggroRate);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Creature::GetCombatPulseDelay ( ) const

inline

644 { return m_combatPulseDelay; }

Creature::m_combatPulseDelay

uint32 m_combatPulseDelay

Definition: Creature.h:740

uint32 Creature::GetCorpseDelay ( ) const

inline

493 { return m_corpseDelay; }

Creature::m_corpseDelay

uint32 m_corpseDelay

Definition: Creature.h:736

Here is the caller graph for this function:

CreatureAddon const * Creature::GetCreatureAddon ( ) const

 {
     if (m_spawnId)
     {
         if (CreatureAddon const* addon = sObjectMgr->GetCreatureAddon(m_spawnId))
             return addon;
     }
 
     // dependent from difficulty mode entry
     return sObjectMgr->GetCreatureTemplateAddon(GetCreatureTemplate()->Entry);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

CreatureData const* Creature::GetCreatureData ( ) const

inline

559 { return m_creatureData; }

Creature::m_creatureData

CreatureData const * m_creatureData

Definition: Creature.h:765

Here is the caller graph for this function:

CreatureTemplate const* Creature::GetCreatureTemplate ( ) const

inline

558 { return m_creatureInfo; }

Creature::m_creatureInfo

CreatureTemplate const * m_creatureInfo

Definition: Creature.h:764

uint8 Creature::GetCurrentEquipmentId ( ) const

inline

547 { return m_equipmentId; }

Creature::m_equipmentId

uint8 m_equipmentId

Definition: Creature.h:748

Here is the caller graph for this function:

uint32 Creature::GetCurrentWaypointID ( ) const

inline

683 { return m_waypointID; }

Creature::m_waypointID

uint32 m_waypointID

Definition: Creature.h:777

Here is the caller graph for this function:

MovementGeneratorType Creature::GetDefaultMovementType ( ) const

inline

624 { return m_defaultMovementType; }

Creature::m_defaultMovementType

MovementGeneratorType m_defaultMovementType

Definition: Creature.h:746

Here is the caller graph for this function:

CreatureGroup* Creature::GetFormation ( )

inline

687 { return m_formation; }

Creature::m_formation

CreatureGroup * m_formation

Definition: Creature.h:781

Here is the caller graph for this function:

void Creature::GetHomePosition	(	float &	x,
		float &	y,
		float &	z,
		float &	ori
	)		const

inline

672 { m_homePosition.GetPosition(x, y, z, ori); }

Position m_homePosition

Definition: Creature.h:759

G3D::int16 z

Definition: Vector3int16.h:46

Position::GetPosition

void GetPosition(float &x, float &y) const

Definition: Position.h:109

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

Here is the caller graph for this function:

Position const& Creature::GetHomePosition ( ) const

inline

673 { return m_homePosition; }

Position m_homePosition

Definition: Creature.h:759

uint8 Creature::getLevelForTarget ( WorldObject const * target ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (!isWorldBoss() || !target->ToUnit())
         return Unit::getLevelForTarget(target);
 
     uint16 level = target->ToUnit()->getLevel() + sWorld->getIntConfig(CONFIG_WORLD_BOSS_LEVEL_DIFF);
     if (level < 1)
         return 1;
     if (level > 255)
         return 255;
     return uint8(level);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Creature::GetLootMode ( ) const

inline

592 { return m_LootMode; }

Creature::m_meleeDamageSchoolMask

uint16 m_LootMode

Definition: Creature.h:767

Here is the caller graph for this function:

Player * Creature::GetLootRecipient ( ) const

 {
     if (!m_lootRecipient)
         return NULL;
 
     return ObjectAccessor::FindConnectedPlayer(m_lootRecipient);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Group * Creature::GetLootRecipientGroup ( ) const

 {
     if (m_lootRecipientGroup.IsEmpty())
         return NULL;
 
     return sGroupMgr->GetGroupByGUID(m_lootRecipientGroup);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellSchoolMask Creature::GetMeleeDamageSchoolMask ( ) const

inlineoverridevirtual

Reimplemented from Unit.

527 { return m_meleeDamageSchoolMask; }

SpellSchoolMask m_meleeDamageSchoolMask

Definition: Creature.h:756

Here is the caller graph for this function:

std::string const & Creature::GetNameForLocaleIdx ( LocaleConstant locale_idx ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (loc_idx != DEFAULT_LOCALE)
     {
         uint8 uloc_idx = uint8(loc_idx);
         CreatureLocale const* cl = sObjectMgr->GetCreatureLocale(GetEntry());
         if (cl)
         {
             if (cl->Name.size() > uloc_idx && !cl->Name[uloc_idx].empty())
                 return cl->Name[uloc_idx];
         }
     }
 
     return GetName();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Creature::GetOriginalEntry ( ) const

inline

699 { return m_originalEntry; }

Creature::m_originalEntry

uint32 m_originalEntry

Definition: Creature.h:757

Here is the caller graph for this function:

int8 Creature::GetOriginalEquipmentId ( ) const

inline

546 { return m_originalEquipmentId; }

Creature::m_originalEquipmentId

int8 m_originalEquipmentId

Definition: Creature.h:749

Here is the caller graph for this function:

uint32 Creature::GetPetAutoSpellOnPos ( uint8 pos ) const

virtual

Reimplemented in Pet.

 {
     if (pos >= MAX_SPELL_CHARM || m_charmInfo->GetCharmSpell(pos)->GetType() != ACT_ENABLED)
         return 0;
     else
         return m_charmInfo->GetCharmSpell(pos)->GetAction();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual uint8 Creature::GetPetAutoSpellSize ( ) const

inlinevirtual

Reimplemented in Pet.

664 { return MAX_SPELL_CHARM; }

MAX_SPELL_CHARM

#define MAX_SPELL_CHARM

Definition: Unit.h:325

Here is the caller graph for this function:

ReactStates Creature::GetReactState ( ) const

inline

503 { return m_reactState; }

Creature::m_reactState

ReactStates m_reactState

Definition: Creature.h:742

Here is the caller graph for this function:

uint32 Creature::GetRespawnDelay ( ) const

inline

637 { return m_respawnDelay; }

Creature::m_respawnDelay

uint32 m_respawnDelay

Definition: Creature.h:735

Here is the caller graph for this function:

void Creature::GetRespawnPosition	(	float &	x,
		float &	y,
		float &	z,
		float *	ori = `nullptr`,
		float *	dist = `nullptr`
	)		const

 {
     if (m_spawnId)
     {
         if (CreatureData const* data = sObjectMgr->GetCreatureData(GetSpawnId()))
         {
             x = data->posX;
             y = data->posY;
             z = data->posZ;
             if (ori)
                 *ori = data->orientation;
             if (dist)
                 *dist = data->spawndist;
 
             return;
         }
     }
 
     x = GetPositionX();
     y = GetPositionY();
     z = GetPositionZ();
     if (ori)
         *ori = GetOrientation();
     if (dist)
         *dist = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Creature::GetRespawnRadius ( ) const

inline

640 { return m_respawnradius; }

Creature::m_respawnradius

float m_respawnradius

Definition: Creature.h:737

Here is the caller graph for this function:

time_t const& Creature::GetRespawnTime ( ) const

inline

631 { return m_respawnTime; }

Creature::m_respawnTime

time_t m_respawnTime

Definition: Creature.h:734

Here is the caller graph for this function:

time_t Creature::GetRespawnTimeEx ( ) const

 {
     time_t now = time(NULL);
     if (m_respawnTime > now)
         return m_respawnTime;
     else
         return now;
 }

Here is the caller graph for this function:

uint32 Creature::GetScriptId ( ) const

 {
     return sObjectMgr->GetCreatureTemplate(GetEntry())->ScriptID;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Creature::GetScriptName ( ) const

 {
     return sObjectMgr->GetScriptName(GetScriptId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Creature::GetSkinner ( ) const

inline

583 { return _skinner; } // Returns the player who skinned this creature

Creature::_skinner

ObjectGuid _skinner

Definition: Creature.h:729

ObjectGuid::LowType Creature::GetSpawnId ( ) const

inline

487 { return m_spawnId; }

Creature::m_spawnId

ObjectGuid::LowType m_spawnId

For new or temporary creatures is 0 for saved it is lowguid.

Definition: Creature.h:747

Here is the caller graph for this function:

float Creature::GetSpellDamageMod ( int32 Rank ) const

 {
     switch (Rank)                                           // define rates for each elite rank
     {
         case CREATURE_ELITE_NORMAL:
             return sWorld->getRate(RATE_CREATURE_NORMAL_SPELLDAMAGE);
         case CREATURE_ELITE_ELITE:
             return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
         case CREATURE_ELITE_RAREELITE:
             return sWorld->getRate(RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE);
         case CREATURE_ELITE_WORLDBOSS:
             return sWorld->getRate(RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE);
         case CREATURE_ELITE_RARE:
             return sWorld->getRate(RATE_CREATURE_ELITE_RARE_SPELLDAMAGE);
         default:
             return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
     }
 }

Here is the caller graph for this function:

CreatureTextRepeatIds Creature::GetTextRepeatGroup ( uint8 textGroup )

 {
     CreatureTextRepeatIds ids;
 
     CreatureTextRepeatGroup::const_iterator groupItr = m_textRepeat.find(textGroup);
     if (groupItr != m_textRepeat.end())
         ids = groupItr->second;
 
     return ids;
 }

Here is the caller graph for this function:

TrainerSpellData const * Creature::GetTrainerSpells ( ) const

 {
     return sObjectMgr->GetNpcTrainerSpells(GetEntry());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::GetTransportHomePosition	(	float &	x,
		float &	y,
		float &	z,
		float &	ori
	)		const

inline

677 { m_transportHomePosition.GetPosition(x, y, z, ori); }

Position m_transportHomePosition

Definition: Creature.h:760

G3D::int16 z

Definition: Vector3int16.h:46

Position::GetPosition

void GetPosition(float &x, float &y) const

Definition: Position.h:109

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

Here is the caller graph for this function:

Position const& Creature::GetTransportHomePosition ( ) const

inline

678 { return m_transportHomePosition; }

Position m_transportHomePosition

Definition: Creature.h:760

uint32 Creature::GetVendorItemCurrentCount ( VendorItem const * vItem )

 {
     if (!vItem->maxcount)
         return vItem->maxcount;
 
     VendorItemCounts::iterator itr = m_vendorItemCounts.begin();
     for (; itr != m_vendorItemCounts.end(); ++itr)
         if (itr->itemId == vItem->item)
             break;
 
     if (itr == m_vendorItemCounts.end())
         return vItem->maxcount;
 
     VendorItemCount* vCount = &*itr;
 
     time_t ptime = time(NULL);
 
     if (time_t(vCount->lastIncrementTime + vItem->incrtime) <= ptime)
         if (ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(vItem->item))
         {
             uint32 diff = uint32((ptime - vCount->lastIncrementTime)/vItem->incrtime);
             if ((vCount->count + diff * pProto->GetBuyCount()) >= vItem->maxcount)
             {
                 m_vendorItemCounts.erase(itr);
                 return vItem->maxcount;
             }
 
             vCount->count += diff * pProto->GetBuyCount();
             vCount->lastIncrementTime = ptime;
         }
 
     return vCount->count;
 }

Here is the caller graph for this function:

VendorItemData const * Creature::GetVendorItems ( ) const

 {
     return sObjectMgr->GetNpcVendorItemList(GetEntry());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Creature::GetWaypointPath ( ) const

inline

680 { return m_path_id; }

Creature::m_path_id

uint32 m_path_id

Definition: Creature.h:778

Here is the caller graph for this function:

bool Creature::hasInvolvedQuest ( uint32 quest_id ) const

overridevirtual

Reimplemented from Object.

 {
     QuestRelationBounds qir = sObjectMgr->GetCreatureQuestInvolvedRelationBounds(GetEntry());
     for (QuestRelations::const_iterator itr = qir.first; itr != qir.second; ++itr)
     {
         if (itr->second == quest_id)
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool Creature::HasLootMode ( uint16 lootMode )

inline

593 { return (m_LootMode & lootMode) != 0; }

Creature::m_lootRecipient

uint16 m_LootMode

Definition: Creature.h:767

Here is the caller graph for this function:

bool Creature::hasLootRecipient ( ) const

inline

586 { return !m_lootRecipient.IsEmpty() || !m_lootRecipientGroup.IsEmpty(); }

ObjectGuid m_lootRecipient

Definition: Creature.h:727

Creature::m_lootRecipientGroup

ObjectGuid m_lootRecipientGroup

Definition: Creature.h:728

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the caller graph for this function:

bool Creature::hasQuest ( uint32 quest_id ) const

overridevirtual

Reimplemented from Object.

 {
     QuestRelationBounds qr = sObjectMgr->GetCreatureQuestRelationBounds(GetEntry());
     for (QuestRelations::const_iterator itr = qr.first; itr != qr.second; ++itr)
     {
         if (itr->second == quest_id)
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool Creature::HasReactState ( ReactStates state ) const

inline

504 { return (m_reactState == state); }

Creature::m_reactState

ReactStates m_reactState

Definition: Creature.h:742

Here is the caller graph for this function:

bool Creature::HasSearchedAssistance ( ) const

inline

620 { return m_AlreadySearchedAssistance; }

Creature::m_AlreadySearchedAssistance

bool m_AlreadySearchedAssistance

Definition: Creature.h:752

Here is the caller graph for this function:

bool Creature::HasSpell ( uint32 spellID ) const

overridevirtual

Reimplemented from Unit.

Reimplemented in Pet.

 {
     uint8 i;
     for (i = 0; i < CREATURE_MAX_SPELLS; ++i)
         if (spellID == m_spells[i])
             break;
     return i < CREATURE_MAX_SPELLS;                         //broke before end of iteration of known spells
 }

Here is the caller graph for this function:

bool Creature::InitEntry	(	uint32	entry,
		CreatureData const *	data = `nullptr`
	)

protected

change the entry of creature until respawn

 {
     CreatureTemplate const* normalInfo = sObjectMgr->GetCreatureTemplate(entry);
     if (!normalInfo)
     {
         TC_LOG_ERROR("sql.sql", "Creature::InitEntry creature entry %u does not exist.", entry);
         return false;
     }
 
     // get difficulty 1 mode entry
     CreatureTemplate const* cinfo = nullptr;
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(GetMap()->GetSpawnMode());
     while (!cinfo && difficultyEntry)
     {
         int32 idx = CreatureTemplate::DifficultyIDToDifficultyEntryIndex(difficultyEntry->ID);
         if (idx == -1)
             break;
 
         if (normalInfo->DifficultyEntry[idx])
         {
             cinfo = sObjectMgr->GetCreatureTemplate(normalInfo->DifficultyEntry[idx]);
             break;
         }
 
         if (!difficultyEntry->FallbackDifficultyID)
             break;
 
         difficultyEntry = sDifficultyStore.LookupEntry(difficultyEntry->FallbackDifficultyID);
     }
 
     if (!cinfo)
         cinfo = normalInfo;
 
     // Initialize loot duplicate count depending on raid difficulty
     if (GetMap()->Is25ManRaid())
         loot.maxDuplicates = 3;
 
     SetEntry(entry);                                        // normal entry always
     m_creatureInfo = cinfo;                                 // map mode related always
 
     // equal to player Race field, but creature does not have race
     SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_RACE, 0);
 
     // known valid are: CLASS_WARRIOR, CLASS_PALADIN, CLASS_ROGUE, CLASS_MAGE
     SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_CLASS, uint8(cinfo->unit_class));
 
     // Cancel load if no model defined
     if (!(cinfo->GetFirstValidModelId()))
     {
         TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has no model defined in table `creature_template`, can't load. ", entry);
         return false;
     }
 
     uint32 displayID = ObjectMgr::ChooseDisplayId(GetCreatureTemplate(), data);
     CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
     if (!minfo)                                             // Cancel load if no model defined
     {
         TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has invalid model %u defined in table `creature_template`, can't load.", entry, displayID);
         return false;
     }
 
     SetDisplayId(displayID);
     SetNativeDisplayId(displayID);
     SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
 
     // Load creature equipment
     if (data && data->equipmentId != 0)
     {
         m_originalEquipmentId = data->equipmentId;
         LoadEquipment(data->equipmentId);
     }
     else
         LoadEquipment(0, true);
 
     SetName(normalInfo->Name);                              // at normal entry always
 
     SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f);
     SetFloatValue(UNIT_MOD_CAST_HASTE, 1.0f);
 
     SetSpeed(MOVE_WALK,   cinfo->speed_walk);
     SetSpeed(MOVE_RUN,    cinfo->speed_run);
     SetSpeed(MOVE_SWIM,   1.0f); // using 1.0 rate
     SetSpeed(MOVE_FLIGHT, 1.0f); // using 1.0 rate
 
     // Will set UNIT_FIELD_BOUNDINGRADIUS and UNIT_FIELD_COMBATREACH
     SetObjectScale(cinfo->scale);
 
     SetFloatValue(UNIT_FIELD_HOVERHEIGHT, cinfo->HoverHeight);
 
     // checked at loading
     m_defaultMovementType = MovementGeneratorType(cinfo->MovementType);
     if (!m_respawnradius && m_defaultMovementType == RANDOM_MOTION_TYPE)
         m_defaultMovementType = IDLE_MOTION_TYPE;
 
     for (uint8 i=0; i < CREATURE_MAX_SPELLS; ++i)
         m_spells[i] = GetCreatureTemplate()->spells[i];
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::InitializeReactState ( )

 {
     if (IsTotem() || IsTrigger() || IsCritter() || IsSpiritService())
         SetReactState(REACT_PASSIVE);
     /*
     else if (IsCivilian())
         SetReactState(REACT_DEFENSIVE);
     */
     else
         SetReactState(REACT_AGGRESSIVE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::isCanInteractWithBattleMaster	(	Player *	player,
		bool	msg
	)		const

Todo:: Rename these properly

 {
     if (!IsBattleMaster())
         return false;
 
     BattlegroundTypeId bgTypeId = sBattlegroundMgr->GetBattleMasterBG(GetEntry());
     if (!msg)
         return player->GetBGAccessByLevel(bgTypeId);
 
     if (!player->GetBGAccessByLevel(bgTypeId))
     {
         player->PlayerTalkClass->ClearMenus();
         switch (bgTypeId)
         {
             case BATTLEGROUND_AV:  player->PlayerTalkClass->SendGossipMenu(7616, GetGUID()); break;
             case BATTLEGROUND_WS:  player->PlayerTalkClass->SendGossipMenu(7599, GetGUID()); break;
             case BATTLEGROUND_AB:  player->PlayerTalkClass->SendGossipMenu(7642, GetGUID()); break;
             case BATTLEGROUND_EY:
             case BATTLEGROUND_NA:
             case BATTLEGROUND_BE:
             case BATTLEGROUND_AA:
             case BATTLEGROUND_RL:
             case BATTLEGROUND_SA:
             case BATTLEGROUND_DS:
             case BATTLEGROUND_RV: player->PlayerTalkClass->SendGossipMenu(10024, GetGUID()); break;
             default: break;
         }
         return false;
     }
     return true;
 }

Here is the call graph for this function:

bool Creature::isCanTrainingAndResetTalentsOf ( Player * player ) const

 {
     return player->getLevel() >= 10
         && GetCreatureTemplate()->trainer_type == TRAINER_TYPE_CLASS
         && player->getClass() == GetCreatureTemplate()->trainer_class;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsCivilian ( ) const

inline

495 { return (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_CIVILIAN) != 0; }

CREATURE_FLAG_EXTRA_CIVILIAN

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

Definition: Creature.h:43

Here is the caller graph for this function:

bool Creature::IsDamageEnoughForLootingAndReward ( ) const

inline

694 { return (m_creatureInfo->flags_extra & CREATURE_FLAG_EXTRA_NO_PLAYER_DAMAGE_REQ) || (m_PlayerDamageReq == 0); }

Creature::m_creatureInfo

CreatureTemplate const * m_creatureInfo

Definition: Creature.h:764

CREATURE_FLAG_EXTRA_NO_PLAYER_DAMAGE_REQ

Definition: Creature.h:57

CreatureTemplate::flags_extra

uint32 flags_extra

Definition: Creature.h:142

Creature::m_PlayerDamageReq

uint32 m_PlayerDamageReq

Definition: Creature.h:697

Here is the caller graph for this function:

bool Creature::IsDungeonBoss ( ) const

 {
     CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(GetEntry());
     return cinfo && (cinfo->flags_extra & CREATURE_FLAG_EXTRA_DUNGEON_BOSS);
 }

Here is the call graph for this function:

bool Creature::isElite ( ) const

 {
     if (IsPet())
         return false;
 
     uint32 rank = GetCreatureTemplate()->rank;
     return rank != CREATURE_ELITE_NORMAL && rank != CREATURE_ELITE_RARE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsFocusing	(	Spell const *	focusSpell = `nullptr`,
		bool	withDelay = `false`
	)

 {
     if (!IsAlive()) // dead creatures cannot focus
     {
         ReleaseFocus(nullptr, false);
         return false;
     }
 
     if (focusSpell && (focusSpell != _focusSpell))
         return false;
 
     if (!_focusSpell)
     {
         if (!withDelay || !_focusDelay)
             return false;
         if (GetMSTimeDiffToNow(_focusDelay) > 1000) // @todo figure out if we can get rid of this magic number somehow
         {
             _focusDelay = 0; // save checks in the future
             return false;
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsGuard ( ) const

inline

497 { return (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_GUARD) != 0; }

CREATURE_FLAG_EXTRA_GUARD

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

Definition: Creature.h:52

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Unit.

 {
     if (!spellInfo)
         return false;
 
     // Creature is immune to main mechanic of the spell
     if (GetCreatureTemplate()->MechanicImmuneMask & (1 << (spellInfo->Mechanic - 1)))
         return true;
 
     // This check must be done instead of 'if (GetCreatureTemplate()->MechanicImmuneMask & (1 << (spellInfo->Mechanic - 1)))' for not break
     // the check of mechanic immunity on DB (tested) because GetCreatureTemplate()->MechanicImmuneMask and m_spellImmune[IMMUNITY_MECHANIC] don't have same data.
     bool immunedToAllEffects = true;
     for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (!effect || !effect->IsEffect())
             continue;
         if (!IsImmunedToSpellEffect(spellInfo, effect->EffectIndex))
         {
             immunedToAllEffects = false;
             break;
         }
     }
     if (immunedToAllEffects)
         return true;
 
     return Unit::IsImmunedToSpell(spellInfo);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Unit.

Reimplemented in Totem.

 {
     SpellEffectInfo const* effect = spellInfo->GetEffect(this, index);
     if (!effect)
         return true;
     if (GetCreatureTemplate()->MechanicImmuneMask & (1 << (effect->Mechanic - 1)))
         return true;
 
     if (GetCreatureTemplate()->type == CREATURE_TYPE_MECHANICAL && effect->Effect == SPELL_EFFECT_HEAL)
         return true;
 
     return Unit::IsImmunedToSpellEffect(spellInfo, index);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsInEvadeMode ( ) const

inline

520 { return HasUnitState(UNIT_STATE_EVADE); }

UNIT_STATE_EVADE

Definition: Unit.h:571

Unit::HasUnitState

bool HasUnitState(const uint32 f) const

Definition: Unit.h:1395

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsInvisibleDueToDespawn ( ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

 {
     if (Unit::IsInvisibleDueToDespawn())
         return true;
 
     if (IsAlive() || isDying() || m_corpseRemoveTime > time(NULL))
         return false;
 
     return true;
 }

Here is the call graph for this function:

bool Creature::IsRacialLeader ( ) const

inline

494 { return GetCreatureTemplate()->RacialLeader; }

CreatureTemplate::RacialLeader

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

bool RacialLeader

Definition: Creature.h:138

bool Creature::isRegeneratingHealth ( )

inline

662 { return m_regenHealth; }

Creature::m_regenHealth

bool m_regenHealth

Definition: Creature.h:753

Here is the caller graph for this function:

bool Creature::IsReputationGainDisabled ( ) const

inline

693 { return DisableReputationGain; }

Creature::DisableReputationGain

bool DisableReputationGain

Definition: Creature.h:762

bool Creature::isTappedBy ( Player const * player ) const

 {
     if (player->GetGUID() == m_lootRecipient)
         return true;
 
     Group const* playerGroup = player->GetGroup();
     if (!playerGroup || playerGroup != GetLootRecipientGroup()) // if we dont have a group we arent the recipient
         return false;                                           // if creature doesnt have group bound it means it was solo killed by someone else
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::IsTrigger ( ) const

inline

496 { return (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER) != 0; }

CREATURE_FLAG_EXTRA_TRIGGER

CreatureTemplate const * GetCreatureTemplate() const

Definition: Creature.h:558

Definition: Creature.h:49

Here is the caller graph for this function:

bool Creature::isWorldBoss ( ) const

 {
     if (IsPet())
         return false;
 
     return (GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_BOSS) != 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::LoadCreatureFromDB	(	ObjectGuid::LowType	spawnId,
		Map *	map,
		bool	addToMap = `true`,
		bool	allowDuplicate = `false`
	)

 {
     if (!allowDuplicate)
     {
         // If an alive instance of this spawnId is already found, skip creation
         // If only dead instance(s) exist, despawn them and spawn a new (maybe also dead) version
         const auto creatureBounds = map->GetCreatureBySpawnIdStore().equal_range(spawnId);
         std::vector <Creature*> despawnList;
 
         if (creatureBounds.first != creatureBounds.second)
         {
             for (auto itr = creatureBounds.first; itr != creatureBounds.second; ++itr)
             {
                 if (itr->second->IsAlive())
                 {
                     TC_LOG_DEBUG("maps", "Would have spawned " UI64FMTD " but %s already exists", spawnId, creatureBounds.first->second->GetGUID().ToString().c_str());
                     return false;
                 }
                 else
                 {
                     despawnList.push_back(itr->second);
                     TC_LOG_DEBUG("maps", "Despawned dead instance of spawn " UI64FMTD " (%s)", spawnId, itr->second->GetGUID().ToString().c_str());
                 }
             }
 
             for (Creature* despawnCreature : despawnList)
             {
                 despawnCreature->AddObjectToRemoveList();
             }
         }
     }
 
     CreatureData const* data = sObjectMgr->GetCreatureData(spawnId);
     if (!data)
     {
         TC_LOG_ERROR("sql.sql", "Creature (GUID: " UI64FMTD ") not found in table `creature`, can't load. ", spawnId);
         return false;
     }
 
     m_spawnId = spawnId;
     if (!Create(map->GenerateLowGuid<HighGuid::Creature>(), map, data->phaseMask, data->id, data->posX, data->posY, data->posZ, data->orientation, data))
         return false;
 
     //We should set first home position, because then AI calls home movement
     SetHomePosition(data->posX, data->posY, data->posZ, data->orientation);
 
     m_respawnradius = data->spawndist;
 
     m_respawnDelay = data->spawntimesecs;
     m_deathState = ALIVE;
 
     m_respawnTime  = GetMap()->GetCreatureRespawnTime(m_spawnId);
     if (m_respawnTime)                          // respawn on Update
     {
         m_deathState = DEAD;
         if (CanFly())
         {
             float tz = map->GetHeight(GetPhaseMask(), data->posX, data->posY, data->posZ, false);
             if (data->posZ - tz > 0.1f)
                 Relocate(data->posX, data->posY, tz);
         }
     }
 
     uint32 curhealth;
 
     if (!m_regenHealth)
     {
         curhealth = data->curhealth;
         if (curhealth)
         {
             curhealth = uint32(curhealth*_GetHealthMod(GetCreatureTemplate()->rank));
             if (curhealth < 1)
                 curhealth = 1;
         }
         SetPower(POWER_MANA, data->curmana);
     }
     else
     {
         curhealth = GetMaxHealth();
         SetPower(POWER_MANA, GetMaxPower(POWER_MANA));
     }
 
     SetHealth(m_deathState == ALIVE ? curhealth : 0);
 
     // checked at creature_template loading
     m_defaultMovementType = MovementGeneratorType(data->movementType);
 
     m_creatureData = data;
 
     loot.SetGUID(ObjectGuid::Create<HighGuid::LootObject>(data->mapid, data->id, GetMap()->GenerateLowGuid<HighGuid::LootObject>()));
 
     if (addToMap && !GetMap()->AddToMap(this))
         return false;
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::LoadCreaturesAddon ( )

Suspected correlation between UNIT_FIELD_BYTES_1, offset 3, value 0x2: If no inhabittype_fly (if no MovementFlag_DisableGravity or MovementFlag_CanFly flag found in sniffs) Check using InhabitType as movement flags are assigned dynamically basing on whether the creature is in air or not Set MovementFlag_Hover. Otherwise do nothing.

 {
     CreatureAddon const* cainfo = GetCreatureAddon();
     if (!cainfo)
         return false;
 
     if (cainfo->mount != 0)
         Mount(cainfo->mount);
 
     if (cainfo->bytes1 != 0)
     {
         // 0 StandState
         // 1 FreeTalentPoints   Pet only, so always 0 for default creature
         // 2 StandFlags
         // 3 StandMiscFlags
 
         SetByteValue(UNIT_FIELD_BYTES_1, 0, uint8(cainfo->bytes1 & 0xFF));
         //SetByteValue(UNIT_FIELD_BYTES_1, 1, uint8((cainfo->bytes1 >> 8) & 0xFF));
         SetByteValue(UNIT_FIELD_BYTES_1, 1, 0);
         SetByteValue(UNIT_FIELD_BYTES_1, 2, uint8((cainfo->bytes1 >> 16) & 0xFF));
         SetByteValue(UNIT_FIELD_BYTES_1, 3, uint8((cainfo->bytes1 >> 24) & 0xFF));
 
         if (GetByteValue(UNIT_FIELD_BYTES_1, 3) & UNIT_BYTE1_FLAG_HOVER && !(GetCreatureTemplate()->InhabitType & INHABIT_AIR))
             AddUnitMovementFlag(MOVEMENTFLAG_HOVER);
     }
 
     if (cainfo->bytes2 != 0)
     {
         // 0 SheathState
         // 1 Bytes2Flags
         // 2 UnitRename         Pet only, so always 0 for default creature
         // 3 ShapeshiftForm     Must be determined/set by shapeshift spell/aura
 
         SetByteValue(UNIT_FIELD_BYTES_2, 0, uint8(cainfo->bytes2 & 0xFF));
         //SetByteValue(UNIT_FIELD_BYTES_2, 1, uint8((cainfo->bytes2 >> 8) & 0xFF));
         //SetByteValue(UNIT_FIELD_BYTES_2, 2, uint8((cainfo->bytes2 >> 16) & 0xFF));
         SetByteValue(UNIT_FIELD_BYTES_2, 2, 0);
         //SetByteValue(UNIT_FIELD_BYTES_2, 3, uint8((cainfo->bytes2 >> 24) & 0xFF));
         SetByteValue(UNIT_FIELD_BYTES_2, 3, 0);
     }
 
     if (cainfo->emote != 0)
         SetUInt32Value(UNIT_NPC_EMOTESTATE, cainfo->emote);
 
     //Load Path
     if (cainfo->path_id != 0)
         m_path_id = cainfo->path_id;
 
     if (!cainfo->auras.empty())
     {
         for (std::vector<uint32>::const_iterator itr = cainfo->auras.begin(); itr != cainfo->auras.end(); ++itr)
         {
             SpellInfo const* AdditionalSpellInfo = sSpellMgr->GetSpellInfo(*itr);
             if (!AdditionalSpellInfo)
             {
                 TC_LOG_ERROR("sql.sql", "Creature (%s) has wrong spell %u defined in `auras` field.", GetGUID().ToString().c_str(), *itr);
                 continue;
             }
 
             // skip already applied aura
             if (HasAura(*itr))
                 continue;
 
             AddAura(*itr, this);
             TC_LOG_DEBUG("entities.unit", "Spell: %u added to creature (%s)", *itr, GetGUID().ToString().c_str());
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::LoadEquipment	(	int8	id = `1`,
		bool	force = `false`
	)

 {
     if (id == 0)
     {
         if (force)
         {
             for (uint8 i = 0; i < MAX_EQUIPMENT_ITEMS; ++i)
                 SetVirtualItem(i, 0);
             m_equipmentId = 0;
         }
 
         return;
     }
 
     EquipmentInfo const* einfo = sObjectMgr->GetEquipmentInfo(GetEntry(), id);
     if (!einfo)
         return;
 
     m_equipmentId = id;
     for (uint8 i = 0; i < MAX_EQUIPMENT_ITEMS; ++i)
         SetVirtualItem(i, einfo->ItemEntry[i]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Creature::LoadFromDB	(	ObjectGuid::LowType	spawnId,
		Map *	map
	)

inline

571 { return LoadCreatureFromDB(spawnId, map, false); }

Creature::LoadCreatureFromDB

bool LoadCreatureFromDB(ObjectGuid::LowType spawnId, Map *map, bool addToMap=true, bool allowDuplicate=false)

Definition: Creature.cpp:1327

void Creature::LoadPath ( uint32 pathid )

inline

681 { m_path_id = pathid; }

Creature::m_path_id

uint32 m_path_id

Definition: Creature.h:778

Here is the caller graph for this function:

void Creature::LowerPlayerDamageReq ( uint32 unDamage )

 {
     if (m_PlayerDamageReq)
         m_PlayerDamageReq > unDamage ? m_PlayerDamageReq -= unDamage : m_PlayerDamageReq = 0;
 }

Here is the caller graph for this function:

void Creature::Motion_Initialize ( )

 {
     if (!m_formation)
         GetMotionMaster()->Initialize();
     else if (m_formation->getLeader() == this)
     {
         m_formation->FormationReset(false);
         GetMotionMaster()->Initialize();
     }
     else if (m_formation->isFormed())
         GetMotionMaster()->MoveIdle(); //wait the order of leader
     else
         GetMotionMaster()->Initialize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellInfo const * Creature::reachWithSpellAttack ( Unit * victim )

 {
     if (!victim)
         return NULL;
 
     for (uint32 i=0; i < CREATURE_MAX_SPELLS; ++i)
     {
         if (!m_spells[i])
             continue;
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(m_spells[i]);
         if (!spellInfo)
         {
             TC_LOG_ERROR("entities.unit", "WORLD: unknown spell id %i", m_spells[i]);
             continue;
         }
 
         bool bcontinue = true;
         for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
         {
             if (effect && ((effect->Effect == SPELL_EFFECT_SCHOOL_DAMAGE)       ||
                 (effect->Effect == SPELL_EFFECT_INSTAKILL)            ||
                 (effect->Effect == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE) ||
                 (effect->Effect == SPELL_EFFECT_HEALTH_LEECH)
                 ))
             {
                 bcontinue = false;
                 break;
             }
         }
         if (bcontinue)
             continue;
 
         std::vector<SpellInfo::CostData> costs = spellInfo->CalcPowerCost(this, SpellSchoolMask(spellInfo->SchoolMask));
         auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_MANA; });
         if (m != costs.end())
             if (m->Amount > GetPower(POWER_MANA))
                 continue;
 
         float range = spellInfo->GetMaxRange(false);
         float minrange = spellInfo->GetMinRange(false);
         float dist = GetDistance(victim);
         if (dist > range || dist < minrange)
             continue;
         if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
             continue;
         if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
             continue;
         return spellInfo;
     }
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellInfo const * Creature::reachWithSpellCure ( Unit * victim )

 {
     if (!victim)
         return NULL;
 
     for (uint32 i=0; i < CREATURE_MAX_SPELLS; ++i)
     {
         if (!m_spells[i])
             continue;
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(m_spells[i]);
         if (!spellInfo)
         {
             TC_LOG_ERROR("entities.unit", "WORLD: unknown spell id %i", m_spells[i]);
             continue;
         }
 
         bool bcontinue = true;
         for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
         {
             if (effect && (effect->Effect == SPELL_EFFECT_HEAL))
             {
                 bcontinue = false;
                 break;
             }
         }
         if (bcontinue)
             continue;
 
         std::vector<SpellInfo::CostData> costs = spellInfo->CalcPowerCost(this, SpellSchoolMask(spellInfo->SchoolMask));
         auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_MANA; });
         if (m != costs.end())
             if (m->Amount > GetPower(POWER_MANA))
                 continue;
 
         float range = spellInfo->GetMaxRange(true);
         float minrange = spellInfo->GetMinRange(true);
         float dist = GetDistance(victim);
         //if (!isInFront(victim, range) && spellInfo->AttributesEx)
         //    continue;
         if (dist > range || dist < minrange)
             continue;
         if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
             continue;
         if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
             continue;
         return spellInfo;
     }
     return NULL;
 }

Here is the call graph for this function:

void Creature::Regenerate ( Powers power )

protected

 {
     uint32 curValue = GetPower(power);
     uint32 maxValue = GetMaxPower(power);
 
     if (curValue >= maxValue)
         return;
 
     float addvalue = 0.0f;
 
     switch (power)
     {
         case POWER_FOCUS:
         {
             // For hunter pets.
             addvalue = 24 * sWorld->getRate(RATE_POWER_FOCUS);
             break;
         }
         case POWER_ENERGY:
         {
             // For deathknight's ghoul.
             addvalue = 20;
             break;
         }
         default:
             return;
     }
 
     // Apply modifiers (if any).
     AuraEffectList const& ModPowerRegenPCTAuras = GetAuraEffectsByType(SPELL_AURA_MOD_POWER_REGEN_PERCENT);
     for (AuraEffectList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i)
         if (Powers((*i)->GetMiscValue()) == power)
             AddPct(addvalue, (*i)->GetAmount());
 
     addvalue += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, power) * (IsHunterPet()? PET_FOCUS_REGEN_INTERVAL : CREATURE_REGEN_INTERVAL) / (5 * IN_MILLISECONDS);
 
     ModifyPower(power, int32(addvalue));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::RegenerateHealth ( )

protected

 {
     if (!isRegeneratingHealth())
         return;
 
     uint32 curValue = GetHealth();
     uint32 maxValue = GetMaxHealth();
 
     if (curValue >= maxValue)
         return;
 
     uint32 addvalue = 0;
 
     // Not only pet, but any controlled creature
     if (!GetCharmerOrOwnerGUID().IsEmpty())
     {
         float HealthIncreaseRate = sWorld->getRate(RATE_HEALTH);
         float Spirit = GetStat(STAT_SPIRIT);
 
         if (GetPower(POWER_MANA) > 0)
             addvalue = uint32(Spirit * 0.25 * HealthIncreaseRate);
         else
             addvalue = uint32(Spirit * 0.80 * HealthIncreaseRate);
     }
     else
         addvalue = maxValue/3;
 
     // Apply modifiers (if any).
     AuraEffectList const& ModPowerRegenPCTAuras = GetAuraEffectsByType(SPELL_AURA_MOD_HEALTH_REGEN_PERCENT);
     for (AuraEffectList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i)
         AddPct(addvalue, (*i)->GetAmount());
 
     addvalue += GetTotalAuraModifier(SPELL_AURA_MOD_REGEN) * CREATURE_REGEN_INTERVAL  / (5 * IN_MILLISECONDS);
 
     ModifyHealth(addvalue);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::RegenerateMana ( )

protected

 {
     uint32 curValue = GetPower(POWER_MANA);
     uint32 maxValue = GetMaxPower(POWER_MANA);
 
     if (curValue >= maxValue)
         return;
 
     uint32 addvalue = 0;
 
     // Combat and any controlled creature
     if (IsInCombat() || !GetCharmerOrOwnerGUID().IsEmpty())
     {
         float ManaIncreaseRate = sWorld->getRate(RATE_POWER_MANA);
         float Spirit = GetStat(STAT_SPIRIT);
 
         addvalue = uint32((Spirit / 5.0f + 17.0f) * ManaIncreaseRate);
     }
     else
         addvalue = maxValue / 3;
 
     // Apply modifiers (if any).
     AuraEffectList const& ModPowerRegenPCTAuras = GetAuraEffectsByType(SPELL_AURA_MOD_POWER_REGEN_PERCENT);
     for (AuraEffectList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i)
         if ((*i)->GetMiscValue() == POWER_MANA)
             AddPct(addvalue, (*i)->GetAmount());
 
     addvalue += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) * CREATURE_REGEN_INTERVAL / (5 * IN_MILLISECONDS);
 
     ModifyPower(POWER_MANA, addvalue);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::ReleaseFocus	(	Spell const *	focusSpell = `nullptr`,
		bool	withDelay = `true`
	)

 {
     if (!_focusSpell)
         return;
 
     // focused to something else
     if (focusSpell && focusSpell != _focusSpell)
         return;
 
     SetGuidValue(UNIT_FIELD_TARGET, ObjectGuid::Empty);
 
     if (_focusSpell->GetSpellInfo()->HasAttribute(SPELL_ATTR5_DONT_TURN_DURING_CAST))
         ClearUnitState(UNIT_STATE_CANNOT_TURN);
 
     _focusSpell = nullptr;
     _focusDelay = withDelay ? getMSTime() : 0; // don't allow re-target right away to prevent visual bugs
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::RemoveCorpse ( bool setSpawnTime = true )

 {
     if (getDeathState() != CORPSE)
         return;
 
     m_corpseRemoveTime = time(NULL);
     setDeathState(DEAD);
     RemoveAllAuras();
     UpdateObjectVisibility();
     loot.clear();
     uint32 respawnDelay = m_respawnDelay;
     if (IsAIEnabled)
         AI()->CorpseRemoved(respawnDelay);
 
     // Should get removed later, just keep "compatibility" with scripts
     if (setSpawnTime)
         m_respawnTime = time(NULL) + respawnDelay;
 
     float x, y, z, o;
     GetRespawnPosition(x, y, z, &o);
     SetHomePosition(x, y, z, o);
     GetMap()->CreatureRelocation(this, x, y, z, o);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::RemoveFromWorld ( )

overridevirtual

Reimplemented from WorldObject.

Reimplemented in Puppet, Minion, Pet, and TempSummon.

 {
     if (IsInWorld())
     {
         if (GetZoneScript())
             GetZoneScript()->OnCreatureRemove(this);
 
         if (m_formation)
             sFormationMgr->RemoveCreatureFromGroup(m_formation, this);
 
         Unit::RemoveFromWorld();
 
         if (m_spawnId)
             Trinity::Containers::MultimapErasePair(GetMap()->GetCreatureBySpawnIdStore(), m_spawnId, this);
         GetMap()->GetObjectsStore().Remove<Creature>(GetGUID());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::RemoveLootMode ( uint16 lootMode )

inline

596 { m_LootMode &= ~lootMode; }

uint16 m_LootMode

Definition: Creature.h:767

Here is the caller graph for this function:

void Creature::ResetLootMode ( )

inline

597 { m_LootMode = LOOT_MODE_DEFAULT; }

Creature::_pickpocketLootRestore

uint16 m_LootMode

Definition: Creature.h:767

LOOT_MODE_DEFAULT

Definition: SharedDefines.h:69

Here is the caller graph for this function:

void Creature::ResetPickPocketRefillTimer ( )

inline

580 { _pickpocketLootRestore = 0; }

time_t _pickpocketLootRestore

Timers.

Definition: Creature.h:732

Here is the caller graph for this function:

void Creature::ResetPlayerDamageReq ( )

inline

696 { m_PlayerDamageReq = GetHealth() / 2; }

Creature::m_PlayerDamageReq

uint32 m_PlayerDamageReq

Definition: Creature.h:697

Unit::GetHealth

uint32 GetHealth() const

Definition: Unit.h:1426

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::Respawn ( bool force = false )

 {
     DestroyForNearbyPlayers();
 
     if (force)
     {
         if (IsAlive())
             setDeathState(JUST_DIED);
         else if (getDeathState() != CORPSE)
             setDeathState(CORPSE);
     }
 
     RemoveCorpse(false);
 
     if (getDeathState() == DEAD)
     {
         if (m_spawnId)
             GetMap()->RemoveCreatureRespawnTime(m_spawnId);
 
         TC_LOG_DEBUG("entities.unit", "Respawning creature %s (%s)",
             GetName().c_str(), GetGUID().ToString().c_str());
         m_respawnTime = 0;
         ResetPickPocketRefillTimer();
         loot.clear();
         if (m_originalEntry != GetEntry())
             UpdateEntry(m_originalEntry);
 
         SelectLevel();
 
         setDeathState(JUST_RESPAWNED);
 
         uint32 displayID = GetNativeDisplayId();
         CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
         if (minfo)                                             // Cancel load if no model defined
         {
             SetDisplayId(displayID);
             SetNativeDisplayId(displayID);
             SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
         }
 
         GetMotionMaster()->InitDefault();
 
         //Call AI respawn virtual function
         if (IsAIEnabled)
         {
             //reset the AI to be sure no dirty or uninitialized values will be used till next tick
             AI()->Reset();
             TriggerJustRespawned = true;//delay event to next tick so all creatures are created on the map before processing
         }
 
         uint32 poolid = GetSpawnId() ? sPoolMgr->IsPartOfAPool<Creature>(GetSpawnId()) : 0;
         if (poolid)
             sPoolMgr->UpdatePool<Creature>(poolid, GetSpawnId());
 
         //Re-initialize reactstate that could be altered by movementgenerators
         InitializeReactState();
     }
 
     UpdateObjectVisibility();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SaveRespawnTime ( )

overridevirtual

Reimplemented from WorldObject.

 {
     if (IsSummon() || !m_spawnId || (m_creatureData && !m_creatureData->dbData))
         return;
 
     GetMap()->SaveCreatureRespawnTime(m_spawnId, m_respawnTime);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SaveToDB ( )

 {
     // this should only be used when the creature has already been loaded
     // preferably after adding to map, because mapid may not be valid otherwise
     CreatureData const* data = sObjectMgr->GetCreatureData(m_spawnId);
     if (!data)
     {
         TC_LOG_ERROR("entities.unit", "Creature::SaveToDB failed, cannot get creature data!");
         return;
     }
 
     uint32 mapId = GetTransport() ? GetTransport()->GetGOInfo()->moTransport.mapID : GetMapId();
     SaveToDB(mapId, data->spawnMask, GetPhaseMask());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SaveToDB	(	uint32	mapid,
		uint32	spawnMask,
		uint32	phaseMask
	)

virtual

Reimplemented in Pet, and TempSummon.

 {
     // update in loaded data
     if (!m_spawnId)
         m_spawnId = sObjectMgr->GenerateCreatureSpawnId();
 
     CreatureData& data = sObjectMgr->NewOrExistCreatureData(m_spawnId);
 
     uint32 displayId = GetNativeDisplayId();
     uint64 npcflag = GetUInt64Value(UNIT_NPC_FLAGS);
     uint32 unit_flags = GetUInt32Value(UNIT_FIELD_FLAGS);
     uint32 dynamicflags = GetUInt32Value(OBJECT_DYNAMIC_FLAGS);
 
     // check if it's a custom model and if not, use 0 for displayId
     CreatureTemplate const* cinfo = GetCreatureTemplate();
     if (cinfo)
     {
         if (displayId == cinfo->Modelid1 || displayId == cinfo->Modelid2 ||
             displayId == cinfo->Modelid3 || displayId == cinfo->Modelid4)
             displayId = 0;
 
         if (npcflag == cinfo->npcflag)
             npcflag = 0;
 
         if (unit_flags == cinfo->unit_flags)
             unit_flags = 0;
 
         if (dynamicflags == cinfo->dynamicflags)
             dynamicflags = 0;
     }
 
     // data->guid = guid must not be updated at save
     data.id = GetEntry();
     data.mapid = mapid;
     data.phaseMask = phaseMask;
     data.displayid = displayId;
     data.equipmentId = GetCurrentEquipmentId();
     if (!GetTransport())
     {
         data.posX = GetPositionX();
         data.posY = GetPositionY();
         data.posZ = GetPositionZMinusOffset();
         data.orientation = GetOrientation();
     }
     else
     {
         data.posX = GetTransOffsetX();
         data.posY = GetTransOffsetY();
         data.posZ = GetTransOffsetZ();
         data.orientation = GetTransOffsetO();
     }
 
     data.spawntimesecs = m_respawnDelay;
     // prevent add data integrity problems
     data.spawndist = GetDefaultMovementType() == IDLE_MOTION_TYPE ? 0.0f : m_respawnradius;
     data.currentwaypoint = 0;
     data.curhealth = GetHealth();
     data.curmana = GetPower(POWER_MANA);
     // prevent add data integrity problems
     data.movementType = !m_respawnradius && GetDefaultMovementType() == RANDOM_MOTION_TYPE
         ? IDLE_MOTION_TYPE : GetDefaultMovementType();
     data.spawnMask = spawnMask;
     data.npcflag = npcflag;
     data.unit_flags = unit_flags;
     data.dynamicflags = dynamicflags;
 
     data.phaseid = GetDBPhase() > 0 ? GetDBPhase() : 0;
     data.phaseGroup = GetDBPhase() < 0 ? abs(GetDBPhase()) : 0;
 
     // update in DB
     SQLTransaction trans = WorldDatabase.BeginTransaction();
 
     PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     uint8 index = 0;
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_CREATURE);
     stmt->setUInt64(index++, m_spawnId);
     stmt->setUInt32(index++, GetEntry());
     stmt->setUInt16(index++, uint16(mapid));
     stmt->setUInt32(index++, spawnMask);
     stmt->setUInt32(index++, data.phaseid);
     stmt->setUInt32(index++, data.phaseGroup);
     stmt->setUInt32(index++, displayId);
     stmt->setUInt8(index++, GetCurrentEquipmentId());
     stmt->setFloat(index++, GetPositionX());
     stmt->setFloat(index++, GetPositionY());
     stmt->setFloat(index++, GetPositionZ());
     stmt->setFloat(index++, GetOrientation());
     stmt->setUInt32(index++, m_respawnDelay);
     stmt->setFloat(index++, m_respawnradius);
     stmt->setUInt32(index++, 0);
     stmt->setUInt32(index++, GetHealth());
     stmt->setUInt32(index++, GetPower(POWER_MANA));
     stmt->setUInt8(index++, uint8(GetDefaultMovementType()));
     stmt->setUInt64(index++, npcflag);
     stmt->setUInt32(index++, unit_flags);
     stmt->setUInt32(index++, dynamicflags);
     trans->Append(stmt);
 
     WorldDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

void Creature::SearchFormation ( )

 {
     if (IsSummon())
         return;
 
     ObjectGuid::LowType lowguid = GetSpawnId();
     if (!lowguid)
         return;
 
     CreatureGroupInfoType::iterator frmdata = sFormationMgr->CreatureGroupMap.find(lowguid);
     if (frmdata != sFormationMgr->CreatureGroupMap.end())
         sFormationMgr->AddCreatureToGroup(frmdata->second->leaderGUID, this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SelectLevel ( )

 {
     CreatureTemplate const* cInfo = GetCreatureTemplate();
 
     uint32 rank = IsPet() ? 0 : cInfo->rank;
 
     // level
     uint8 minlevel = std::min(cInfo->maxlevel, cInfo->minlevel);
     uint8 maxlevel = std::max(cInfo->maxlevel, cInfo->minlevel);
     uint8 level = minlevel == maxlevel ? minlevel : urand(minlevel, maxlevel);
     SetLevel(level);
 
     CreatureBaseStats const* stats = sObjectMgr->GetCreatureBaseStats(level, cInfo->unit_class);
 
     // health
     float healthmod = _GetHealthMod(rank);
 
     uint32 basehp = stats->GenerateHealth(cInfo);
     uint32 health = uint32(basehp * healthmod);
 
     SetCreateHealth(health);
     SetMaxHealth(health);
     SetHealth(health);
     ResetPlayerDamageReq();
 
     // mana
     uint32 mana = stats->GenerateMana(cInfo);
     SetCreateMana(mana);
 
     switch (getClass())
     {
         case CLASS_WARRIOR:
             setPowerType(POWER_RAGE);
             break;
         case CLASS_ROGUE:
             setPowerType(POWER_ENERGY);
             break;
         default:
             SetMaxPower(POWER_MANA, mana); // MAX Mana
             SetPower(POWER_MANA, mana);
             break;
     }
 
     SetModifierValue(UNIT_MOD_HEALTH, BASE_VALUE, (float)health);
     SetModifierValue(UNIT_MOD_MANA, BASE_VALUE, (float)mana);
 
     // damage
 
     float basedamage = stats->GenerateBaseDamage(cInfo);
 
     float weaponBaseMinDamage = basedamage;
     float weaponBaseMaxDamage = basedamage * 1.5f;
 
     SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, weaponBaseMinDamage);
     SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, weaponBaseMaxDamage);
 
     SetBaseWeaponDamage(OFF_ATTACK, MINDAMAGE, weaponBaseMinDamage);
     SetBaseWeaponDamage(OFF_ATTACK, MAXDAMAGE, weaponBaseMaxDamage);
 
     SetBaseWeaponDamage(RANGED_ATTACK, MINDAMAGE, weaponBaseMinDamage);
     SetBaseWeaponDamage(RANGED_ATTACK, MAXDAMAGE, weaponBaseMaxDamage);
 
     SetModifierValue(UNIT_MOD_ATTACK_POWER, BASE_VALUE, stats->AttackPower);
     SetModifierValue(UNIT_MOD_ATTACK_POWER_RANGED, BASE_VALUE, stats->RangedAttackPower);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Creature::SelectNearestHostileUnitInAggroRange ( bool useLOS = false ) const

 {
     // Selects nearest hostile target within creature's aggro range. Used primarily by
     //  pets set to aggressive. Will not return neutral or friendly targets.
 
     Unit* target = NULL;
 
     {
         Trinity::NearestHostileUnitInAggroRangeCheck u_check(this, useLOS);
         Trinity::UnitSearcher<Trinity::NearestHostileUnitInAggroRangeCheck> searcher(this, target, u_check);
 
         VisitNearbyGridObject(MAX_AGGRO_RADIUS, searcher);
     }
 
     return target;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Player * Creature::SelectNearestPlayer ( float distance = 0 ) const

 {
     Player* target = NULL;
 
     Trinity::NearestPlayerInObjectRangeCheck checker(this, distance);
     Trinity::PlayerLastSearcher<Trinity::NearestPlayerInObjectRangeCheck> searcher(this, target, checker);
     VisitNearbyObject(distance, searcher);
 
     return target;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Creature::SelectNearestTarget	(	float	dist = `0`,
		bool	playerOnly = `false`
	)		const

 {
     CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
     Cell cell(p);
     cell.SetNoCreate();
 
     Unit* target = NULL;
 
     {
         if (dist == 0.0f)
             dist = MAX_VISIBILITY_DISTANCE;
 
         Trinity::NearestHostileUnitCheck u_check(this, dist, playerOnly);
         Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck> searcher(this, target, u_check);
 
         TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
         TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck>, GridTypeMapContainer >  grid_unit_searcher(searcher);
 
         cell.Visit(p, world_unit_searcher, *GetMap(), *this, dist);
         cell.Visit(p, grid_unit_searcher, *GetMap(), *this, dist);
     }
 
     return target;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Creature::SelectNearestTargetInAttackDistance ( float dist = 0 ) const

 {
     CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
     Cell cell(p);
     cell.SetNoCreate();
 
     Unit* target = NULL;
 
     if (dist > MAX_VISIBILITY_DISTANCE)
     {
         TC_LOG_ERROR("entities.unit", "Creature (%s) SelectNearestTargetInAttackDistance called with dist > MAX_VISIBILITY_DISTANCE. Distance set to ATTACK_DISTANCE.", GetGUID().ToString().c_str());
         dist = ATTACK_DISTANCE;
     }
 
     {
         Trinity::NearestHostileUnitInAttackDistanceCheck u_check(this, dist);
         Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck> searcher(this, target, u_check);
 
         TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
         TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck>, GridTypeMapContainer >  grid_unit_searcher(searcher);
 
         cell.Visit(p, world_unit_searcher, *GetMap(), *this, ATTACK_DISTANCE > dist ? ATTACK_DISTANCE : dist);
         cell.Visit(p, grid_unit_searcher, *GetMap(), *this, ATTACK_DISTANCE > dist ? ATTACK_DISTANCE : dist);
     }
 
     return target;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * Creature::SelectVictim ( )

Todo:: a vehicle may eat some mob, so mob should not evade

 {
     // function provides main threat functionality
     // next-victim-selection algorithm and evade mode are called
     // threat list sorting etc.
 
     Unit* target = nullptr;
     // First checking if we have some taunt on us
     AuraEffectList const& tauntAuras = GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
     if (!tauntAuras.empty())
     {
         Unit* caster = tauntAuras.back()->GetCaster();
 
         // The last taunt aura caster is alive an we are happy to attack him
         if (caster && caster->IsAlive())
             return GetVictim();
         else if (tauntAuras.size() > 1)
         {
             // We do not have last taunt aura caster but we have more taunt auras,
             // so find first available target
 
             // Auras are pushed_back, last caster will be on the end
             AuraEffectList::const_iterator aura = --tauntAuras.end();
             do
             {
                 --aura;
                 caster = (*aura)->GetCaster();
                 if (caster && CanSeeOrDetect(caster, true) && IsValidAttackTarget(caster) && caster->isInAccessiblePlaceFor(ToCreature()))
                 {
                     target = caster;
                     break;
                 }
             } while (aura != tauntAuras.begin());
         }
         else
             target = GetVictim();
     }
 
     if (CanHaveThreatList())
     {
         if (!target && !m_ThreatManager.isThreatListEmpty())
             // No taunt aura or taunt aura caster is dead standard target selection
             target = m_ThreatManager.getHostilTarget();
     }
     else if (!HasReactState(REACT_PASSIVE))
     {
         // We have player pet probably
         target = getAttackerForHelper();
         if (!target && IsSummon())
         {
             if (Unit* owner = ToTempSummon()->GetOwner())
             {
                 if (owner->IsInCombat())
                     target = owner->getAttackerForHelper();
                 if (!target)
                 {
                     for (ControlList::const_iterator itr = owner->m_Controlled.begin(); itr != owner->m_Controlled.end(); ++itr)
                     {
                         if ((*itr)->IsInCombat())
                         {
                             target = (*itr)->getAttackerForHelper();
                             if (target)
                                 break;
                         }
                     }
                 }
             }
         }
     }
     else
         return nullptr;
 
     if (target && _IsTargetAcceptable(target) && CanCreatureAttack(target))
     {
         if(!IsFocusing())
             SetInFront(target);
         return target;
     }
 
     // last case when creature must not go to evade mode:
     // it in combat but attacker not make any damage and not enter to aggro radius to have record in threat list
     // for example at owner command to pet attack some far away creature
     // Note: creature does not have targeted movement generator but has attacker in this case
     for (AttackerSet::const_iterator itr = m_attackers.begin(); itr != m_attackers.end(); ++itr)
     {
         if ((*itr) && !CanCreatureAttack(*itr) && (*itr)->GetTypeId() != TYPEID_PLAYER
         && !(*itr)->ToCreature()->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
             return nullptr;
     }
 
     if (GetVehicle())
         return nullptr;
 
     // search nearby enemy before enter evade mode
     if (HasReactState(REACT_AGGRESSIVE))
     {
         target = SelectNearestTargetInAttackDistance(m_CombatDistance ? m_CombatDistance : ATTACK_DISTANCE);
 
         if (target && _IsTargetAcceptable(target) && CanCreatureAttack(target))
             return target;
     }
 
     Unit::AuraEffectList const& iAuras = GetAuraEffectsByType(SPELL_AURA_MOD_INVISIBILITY);
     if (!iAuras.empty())
     {
         for (Unit::AuraEffectList::const_iterator itr = iAuras.begin(); itr != iAuras.end(); ++itr)
         {
             if ((*itr)->GetBase()->IsPermanent())
             {
                 AI()->EnterEvadeMode(CreatureAI::EVADE_REASON_OTHER);
                 break;
             }
         }
         return nullptr;
     }
 
     // enter in evade mode in other case
     AI()->EnterEvadeMode(CreatureAI::EVADE_REASON_NO_HOSTILES);
 
     return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SendAIReaction ( AiReaction reactionType )

 {
     WorldPackets::Combat::AIReaction packet;
 
     packet.UnitGUID = GetGUID();
     packet.Reaction = reactionType;
 
     SendMessageToSet(packet.Write(), true);
 
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_AI_REACTION, type %u.", reactionType);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SendZoneUnderAttackMessage ( Player * attacker )

Send a message to LocalDefense channel for players opposition team in the zone.

 {
     uint32 enemy_team = attacker->GetTeam();
     WorldPackets::Misc::ZoneUnderAttack packet;
     packet.AreaID = GetAreaId();
     sWorld->SendGlobalMessage(packet.Write(), NULL, (enemy_team == ALLIANCE ? HORDE : ALLIANCE));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetCanDualWield ( bool value )

overridevirtual

Reimplemented from Unit.

 {
     Unit::SetCanDualWield(value);
     UpdateDamagePhysical(OFF_ATTACK);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetCombatPulseDelay ( uint32 delay )

inline

         {
             m_combatPulseDelay = delay;
             if (m_combatPulseTime == 0 || m_combatPulseTime > delay)
                 m_combatPulseTime = delay;
         }

Here is the caller graph for this function:

void Creature::SetCorpseDelay ( uint32 delay )

inline

492 { m_corpseDelay = delay; }

Creature::m_corpseDelay

uint32 m_corpseDelay

Definition: Creature.h:736

Here is the caller graph for this function:

void Creature::SetCurrentEquipmentId ( uint8 id )

inline

548 { m_equipmentId = id; }

Creature::m_equipmentId

uint8 m_equipmentId

Definition: Creature.h:748

Here is the caller graph for this function:

void Creature::setDeathState ( DeathState s )

overridevirtual

Reimplemented from Unit.

Reimplemented in Pet.

 {
     Unit::setDeathState(s);
 
     if (s == JUST_DIED)
     {
         m_corpseRemoveTime = time(NULL) + m_corpseDelay;
         m_respawnTime = time(NULL) + m_respawnDelay + m_corpseDelay;
 
         // always save boss respawn time at death to prevent crash cheating
         if (sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY) || isWorldBoss())
             SaveRespawnTime();
 
         ReleaseFocus();               // remove spellcast focus (this also clears unit target)
         SetTarget(ObjectGuid::Empty); // drop target - dead mobs shouldn't ever target things
 
         SetUInt64Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
 
         SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 0); // if creature is mounted on a virtual mount, remove it at death
 
         setActive(false);
 
         if (HasSearchedAssistance())
         {
             SetNoSearchAssistance(false);
             UpdateSpeed(MOVE_RUN, false);
         }
 
         //Dismiss group if is leader
         if (m_formation && m_formation->getLeader() == this)
             m_formation->FormationReset(true);
 
         if ((CanFly() || IsFlying()))
             GetMotionMaster()->MoveFall();
 
         Unit::setDeathState(CORPSE);
     }
     else if (s == JUST_RESPAWNED)
     {
         //if (IsPet())
         //    setActive(true);
         SetFullHealth();
         SetLootRecipient(NULL);
         ResetPlayerDamageReq();
 
         UpdateMovementFlags();
 
         ClearUnitState(uint32(UNIT_STATE_ALL_STATE & ~UNIT_STATE_IGNORE_PATHFINDING));
 
         if (!IsPet())
         {
             CreatureData const* creatureData = GetCreatureData();
             CreatureTemplate const* cinfo = GetCreatureTemplate();
 
             uint64 npcflag;
             uint32 unit_flags, dynamicflags;
             ObjectMgr::ChooseCreatureFlags(cinfo, npcflag, unit_flags, dynamicflags, creatureData);
 
             SetUInt64Value(UNIT_NPC_FLAGS, npcflag);
             SetUInt32Value(UNIT_FIELD_FLAGS, unit_flags);
             SetUInt32Value(OBJECT_DYNAMIC_FLAGS, dynamicflags);
 
             RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
 
             SetMeleeDamageSchool(SpellSchools(cinfo->dmgschool));
         }
 
         Motion_Initialize();
         Unit::setDeathState(ALIVE);
         LoadCreaturesAddon();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetDefaultMovementType ( MovementGeneratorType mgt )

inline

625 { m_defaultMovementType = mgt; }

Creature::m_defaultMovementType

MovementGeneratorType m_defaultMovementType

Definition: Creature.h:746

Here is the caller graph for this function:

void Creature::SetDisableReputationGain ( bool disable )

inline

692 { DisableReputationGain = disable; }

Creature::DisableReputationGain

bool DisableReputationGain

Definition: Creature.h:762

Here is the caller graph for this function:

void Creature::SetDisplayId ( uint32 modelId )

overridevirtual

Reimplemented from Unit.

Reimplemented in Pet.

 {
     Unit::SetDisplayId(modelId);
 
     if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(modelId))
     {
         SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, minfo->bounding_radius * GetObjectScale());
         SetFloatValue(UNIT_FIELD_COMBATREACH, minfo->combat_reach * GetObjectScale());
     }
 }

Here is the call graph for this function:

void Creature::SetFormation ( CreatureGroup * formation )

inline

688 { m_formation = formation; }

Creature::m_formation

CreatureGroup * m_formation

Definition: Creature.h:781

Here is the caller graph for this function:

void Creature::SetHomePosition	(	float	x,
		float	y,
		float	z,
		float	o
	)

inline

670 { m_homePosition.Relocate(x, y, z, o); }

Position m_homePosition

Definition: Creature.h:759

void Relocate(float x, float y)

Definition: Position.h:67

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

void Creature::SetHomePosition ( const Position & pos )

inline

671 { m_homePosition.Relocate(pos); }

Position m_homePosition

Definition: Creature.h:759

void Relocate(float x, float y)

Definition: Position.h:67

void Creature::SetInCombatWithZone ( )

 {
     if (!CanHaveThreatList())
     {
         TC_LOG_ERROR("entities.unit", "Creature entry %u call SetInCombatWithZone but creature cannot have threat list.", GetEntry());
         return;
     }
 
     Map* map = GetMap();
 
     if (!map->IsDungeon())
     {
         TC_LOG_ERROR("entities.unit", "Creature entry %u call SetInCombatWithZone for map (id: %u) that isn't an instance.", GetEntry(), map->GetId());
         return;
     }
 
     Map::PlayerList const &PlList = map->GetPlayers();
 
     if (PlList.isEmpty())
         return;
 
     for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
     {
         if (Player* player = i->GetSource())
         {
             if (player->IsGameMaster())
                 continue;
 
             if (player->IsAlive())
             {
                 this->SetInCombatWith(player);
                 player->SetInCombatWith(this);
                 AddThreat(player, 0.0f);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetLootMode ( uint16 lootMode )

inline

594 { m_LootMode = lootMode; }

Creature::m_meleeDamageSchoolMask

uint16 m_LootMode

Definition: Creature.h:767

Here is the caller graph for this function:

void Creature::SetLootRecipient ( Unit * unit )

 {
     // set the player whose group should receive the right
     // to loot the creature after it dies
     // should be set to NULL after the loot disappears
 
     if (!unit)
     {
         m_lootRecipient.Clear();
         m_lootRecipientGroup.Clear();
         RemoveFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE | UNIT_DYNFLAG_TAPPED);
         return;
     }
 
     if (unit->GetTypeId() != TYPEID_PLAYER && !unit->IsVehicle())
         return;
 
     Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself();
     if (!player)                                             // normal creature, no player involved
         return;
 
     m_lootRecipient = player->GetGUID();
     if (Group* group = player->GetGroup())
         m_lootRecipientGroup = group->GetGUID();
 
     SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetMeleeDamageSchool ( SpellSchools school )

inline

528 { m_meleeDamageSchoolMask = SpellSchoolMask(1 << school); }

SpellSchoolMask

Definition: SharedDefines.h:285

SpellSchoolMask m_meleeDamageSchoolMask

Definition: Creature.h:756

Here is the caller graph for this function:

void Creature::SetNoCallAssistance ( bool val )

inline

618 { m_AlreadyCallAssistance = val; }

Creature::m_AlreadyCallAssistance

bool m_AlreadyCallAssistance

Definition: Creature.h:751

Here is the caller graph for this function:

void Creature::SetNoSearchAssistance ( bool val )

inline

619 { m_AlreadySearchedAssistance = val; }

Creature::m_AlreadySearchedAssistance

bool m_AlreadySearchedAssistance

Definition: Creature.h:752

Here is the caller graph for this function:

void Creature::SetObjectScale ( float scale )

overridevirtual

Reimplemented from Object.

 {
     Unit::SetObjectScale(scale);
 
     if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(GetDisplayId()))
     {
         SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, minfo->bounding_radius * scale);
         SetFloatValue(UNIT_FIELD_COMBATREACH, minfo->combat_reach * scale);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetOriginalEntry ( uint32 entry )

inline

700 { m_originalEntry = entry; }

Creature::m_originalEntry

uint32 m_originalEntry

Definition: Creature.h:757

Here is the caller graph for this function:

void Creature::SetPosition	(	float	x,
		float	y,
		float	z,
		float	o
	)

 {
     // prevent crash when a bad coord is sent by the client
     if (!Trinity::IsValidMapCoord(x, y, z, o))
     {
         TC_LOG_DEBUG("entities.unit", "Creature::SetPosition(%f, %f, %f) .. bad coordinates!", x, y, z);
         return;
     }
 
     GetMap()->CreatureRelocation(this, x, y, z, o);
     if (IsVehicle())
         GetVehicleKit()->RelocatePassengers();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetPosition ( const Position & pos )

inline

668 { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }

Creature::SetPosition

void SetPosition(float x, float y, float z, float o)

Definition: Creature.cpp:2537

Position::GetOrientation

float GetOrientation() const

Definition: Position.h:107

Position::GetPositionY

float GetPositionY() const

Definition: Position.h:105

Position::GetPositionZ

float GetPositionZ() const

Definition: Position.h:106

Position::GetPositionX

float GetPositionX() const

Definition: Position.h:104

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetReactState ( ReactStates st )

inline

502 { m_reactState = st; }

Creature::m_reactState

ReactStates m_reactState

Definition: Creature.h:742

void Creature::setRegeneratingHealth ( bool regenHealth )

inline

663 { m_regenHealth = regenHealth; }

Creature::m_regenHealth

bool m_regenHealth

Definition: Creature.h:753

Here is the caller graph for this function:

void Creature::SetRespawnDelay ( uint32 delay )

inline

638 { m_respawnDelay = delay; }

Creature::m_respawnDelay

uint32 m_respawnDelay

Definition: Creature.h:735

Here is the caller graph for this function:

void Creature::SetRespawnRadius ( float dist )

inline

641 { m_respawnradius = dist; }

Creature::m_respawnradius

float m_respawnradius

Definition: Creature.h:737

Here is the caller graph for this function:

void Creature::SetRespawnTime ( uint32 respawn )

inline

633 { m_respawnTime = respawn ? time(NULL) + respawn : 0; }

Creature::m_respawnTime

time_t m_respawnTime

Definition: Creature.h:734

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Here is the caller graph for this function:

void Creature::SetSkinner ( ObjectGuid guid )

inline

582 { _skinner = guid; }

Creature::_skinner

ObjectGuid _skinner

Definition: Creature.h:729

void Creature::SetTarget ( ObjectGuid const & guid )

overridevirtual

Implements Unit.

 {
     if (!IsFocusing())
         SetGuidValue(UNIT_FIELD_TARGET, guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetTextRepeatId	(	uint8	textGroup,
		uint8	id
	)

 {
     CreatureTextRepeatIds& repeats = m_textRepeat[textGroup];
     if (std::find(repeats.begin(), repeats.end(), id) == repeats.end())
         repeats.push_back(id);
     else
         TC_LOG_ERROR("sql.sql", "CreatureTextMgr: TextGroup %u for Creature (%s) %s, id %u already added", uint32(textGroup), GetName().c_str(), GetGUID().ToString().c_str(), uint32(id));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Creature::SetTransportHomePosition	(	float	x,
		float	y,
		float	z,
		float	o
	)

inline

675 { m_transportHomePosition.Relocate(x, y, z, o); }

Position m_transportHomePosition

Definition: Creature.h:760

void Relocate(float x, float y)

Definition: Position.h:67

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

Here is the caller graph for this function:

void Creature::SetTransportHomePosition ( const Position & pos )

inline

676 { m_transportHomePosition.Relocate(pos); }

Position m_transportHomePosition

Definition: Creature.h:760