TrinityCore: WorldObject Class Reference

WorldObject::m_InstanceId

uint16 m_notifyflags

Definition: Object.h:654

Here is the caller graph for this function:

void WorldObject::AddToObjectUpdate ( )

overridevirtual

Implements Object.

 {
  GetMap()->AddUpdateObject(this);
 }

Here is the call graph for this function:

void WorldObject::BuildUpdate ( UpdateDataMapType & data_map )

overridevirtual

Reimplemented from Object.

Reimplemented in Transport.

 {
  CellCoord p = Trinity::ComputeCellCoord(GetPositionX(), GetPositionY());
  Cell cell(p);
  cell.SetNoCreate();
  WorldObjectChangeAccumulator notifier(*this, data_map);
  TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
  Map& map = *GetMap();
  //we must build packets for all visible players
  cell.Visit(p, player_notifier, map, *this, GetVisibilityRange());
 
  ClearUpdateMask(false);
 }

Here is the call graph for this function:

virtual bool WorldObject::CanAlwaysSee ( WorldObject const * ) const

inlineprivatevirtual

Reimplemented in Creature.

659 { return false; }

Here is the caller graph for this function:

bool WorldObject::CanDetect	(	WorldObject const *	obj,
		bool	ignoreStealth,
		bool	checkAlert = `false`
	)		const

private

 {
  const WorldObject* seer = this;
 
  // Pets don't have detection, they use the detection of their masters
  if (Unit const* thisUnit = ToUnit())
  if (Unit* controller = thisUnit->GetCharmerOrOwner())
  seer = controller;
 
  if (obj->IsAlwaysDetectableFor(seer))
  return true;
 
  if (!ignoreStealth && !seer->CanDetectInvisibilityOf(obj))
  return false;
 
  if (!ignoreStealth && !seer->CanDetectStealthOf(obj, checkAlert))
  return false;
 
  return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::CanDetectInvisibilityOf ( WorldObject const * obj ) const

private

 {
  uint32 mask = obj->m_invisibility.GetFlags() & m_invisibilityDetect.GetFlags();
 
  // Check for not detected types
  if (mask != obj->m_invisibility.GetFlags())
  return false;
 
  for (uint32 i = 0; i < TOTAL_INVISIBILITY_TYPES; ++i)
  {
  if (!(mask & (1 << i)))
  continue;
 
  int32 objInvisibilityValue = obj->m_invisibility.GetValue(InvisibilityType(i));
  int32 ownInvisibilityDetectValue = m_invisibilityDetect.GetValue(InvisibilityType(i));
 
  // Too low value to detect
         if (ownInvisibilityDetectValue < objInvisibilityValue)
             return false;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::CanDetectStealthOf	(	WorldObject const *	obj,
		bool	checkAlert = `false`
	)		const

private

 {
     // Combat reach is the minimal distance (both in front and behind),
     //   and it is also used in the range calculation.
     // One stealth point increases the visibility range by 0.3 yard.
 
     if (!obj->m_stealth.GetFlags())
         return true;
 
     float distance = GetExactDist(obj);
     float combatReach = 0.0f;
 
     Unit const* unit = ToUnit();
     if (unit)
         combatReach = unit->GetCombatReach();
 
     if (distance < combatReach)
         return true;
 
     if (!HasInArc(float(M_PI), obj))
         return false;
 
     GameObject const* go = ToGameObject();
     for (uint32 i = 0; i < TOTAL_STEALTH_TYPES; ++i)
     {
         if (!(obj->m_stealth.GetFlags() & (1 << i)))
             continue;
 
         if (unit && unit->HasAuraTypeWithMiscvalue(SPELL_AURA_DETECT_STEALTH, i))
             return true;
 
         // Starting points
         int32 detectionValue = 30;
 
         // Level difference: 5 point / level, starting from level 1.
         // There may be spells for this and the starting points too, but
         // not in the DBCs of the client.
         detectionValue += int32(getLevelForTarget(obj) - 1) * 5;
 
         // Apply modifiers
         detectionValue += m_stealthDetect.GetValue(StealthType(i));
         if (go)
             if (Unit* owner = go->GetOwner())
                 detectionValue -= int32(owner->getLevelForTarget(this) - 1) * 5;
 
         detectionValue -= obj->m_stealth.GetValue(StealthType(i));
 
         // Calculate max distance
         float visibilityRange = float(detectionValue) * 0.3f + combatReach;
 
         // If this unit is an NPC then player detect range doesn't apply
         if (unit && unit->GetTypeId() == TYPEID_PLAYER && visibilityRange > MAX_PLAYER_STEALTH_DETECT_RANGE)
             visibilityRange = MAX_PLAYER_STEALTH_DETECT_RANGE;
 
         // When checking for alert state, look 8% further, and then 1.5 yards more than that.
         if (checkAlert)
             visibilityRange += (visibilityRange * 0.08f) + 1.5f;
 
         // If checking for alert, and creature's visibility range is greater than aggro distance, No alert
         Unit const* tunit = obj->ToUnit();
         if (checkAlert && unit && unit->ToCreature() && visibilityRange >= unit->ToCreature()->GetAttackDistance(tunit) + unit->ToCreature()->m_CombatDistance)
             return false;
 
         if (distance > visibilityRange)
             return false;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::CanNeverSee ( WorldObject const * obj ) const

private

 {
     return GetMap() != obj->GetMap() || !IsInPhase(obj);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::CanSeeOrDetect	(	WorldObject const *	obj,
		bool	ignoreStealth = `false`,
		bool	distanceCheck = `false`,
		bool	checkAlert = `false`
	)		const

 {
     if (this == obj)
         return true;
 
     if (obj->IsNeverVisible() || CanNeverSee(obj))
         return false;
 
     if (obj->IsAlwaysVisibleFor(this) || CanAlwaysSee(obj))
         return true;
 
     bool corpseVisibility = false;
     if (distanceCheck)
     {
         bool corpseCheck = false;
         if (Player const* thisPlayer = ToPlayer())
         {
             if (thisPlayer->isDead() && thisPlayer->GetHealth() > 0 && // Cheap way to check for ghost state
                 !(obj->m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GHOST) & m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GHOST) & GHOST_VISIBILITY_GHOST))
             {
                 if (Corpse* corpse = thisPlayer->GetCorpse())
                 {
                     corpseCheck = true;
                     if (corpse->IsWithinDist(thisPlayer, GetSightRange(obj), false))
                         if (corpse->IsWithinDist(obj, GetSightRange(obj), false))
                             corpseVisibility = true;
                 }
             }
         }
 
         WorldObject const* viewpoint = this;
         if (Player const* player = this->ToPlayer())
             viewpoint = player->GetViewpoint();
 
         if (!viewpoint)
             viewpoint = this;
 
         if (!corpseCheck && !viewpoint->IsWithinDist(obj, GetSightRange(obj), false))
             return false;
     }
 
     // GM visibility off or hidden NPC
     if (!obj->m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GM))
     {
         // Stop checking other things for GMs
         if (m_serverSideVisibilityDetect.GetValue(SERVERSIDE_VISIBILITY_GM))
             return true;
     }
     else
         return m_serverSideVisibilityDetect.GetValue(SERVERSIDE_VISIBILITY_GM) >= obj->m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GM);
 
     // Ghost players, Spirit Healers, and some other NPCs
     if (!corpseVisibility && !(obj->m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GHOST) & m_serverSideVisibilityDetect.GetValue(SERVERSIDE_VISIBILITY_GHOST)))
     {
         // Alive players can see dead players in some cases, but other objects can't do that
         if (Player const* thisPlayer = ToPlayer())
         {
             if (Player const* objPlayer = obj->ToPlayer())
             {
                 if (thisPlayer->GetTeam() != objPlayer->GetTeam() || !thisPlayer->IsGroupVisibleFor(objPlayer))
                     return false;
             }
             else
                 return false;
         }
         else
             return false;
     }
 
     if (obj->IsInvisibleDueToDespawn())
         return false;
 
     if (!CanDetect(obj, ignoreStealth, checkAlert))
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::CleanupsBeforeDelete ( bool finalCleanup = true )

virtual

Reimplemented in Unit, GameObject, and Transport.

 {
     if (IsInWorld())
         RemoveFromWorld();
 
     if (Transport* transport = GetTransport())
         transport->RemovePassenger(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::ClearPhases ( bool update = false )

 {
     _phases.clear();
 
     RebuildTerrainSwaps();
 
     if (update && IsInWorld())
         UpdateObjectVisibility();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::CopyPhaseFrom	(	WorldObject *	obj,
		bool	update = `false`
	)

 {
     if (!obj)
         return;
 
     for (uint32 phase : obj->GetPhases())
         SetInPhase(phase, false, true);
 
     if (update && IsInWorld())
         UpdateObjectVisibility();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::DestroyForNearbyPlayers ( )

Todo:: this is for puppet

 {
     if (!IsInWorld())
         return;
 
     std::list<Player*> targets;
     Trinity::AnyPlayerInObjectRangeCheck check(this, GetVisibilityRange(), false);
     Trinity::PlayerListSearcher<Trinity::AnyPlayerInObjectRangeCheck> searcher(this, targets, check);
     VisitNearbyWorldObject(GetVisibilityRange(), searcher);
     for (std::list<Player*>::const_iterator iter = targets.begin(); iter != targets.end(); ++iter)
     {
         Player* player = (*iter);
 
         if (player == this)
             continue;
 
         if (!player->HaveAtClient(this))
             continue;
 
         if (isType(TYPEMASK_UNIT) && ToUnit()->GetCharmerGUID() == player->GetGUID()) 
             continue;
 
         DestroyForPlayer(player);
         player->m_clientGUIDs.erase(GetGUID());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Map* WorldObject::FindMap ( ) const

inline

544 { return m_currMap; }

WorldObject::m_currMap

Map * m_currMap

Definition: Object.h:644

Here is the caller graph for this function:

Creature * WorldObject::FindNearestCreature	(	uint32	entry,
		float	range,
		bool	alive = `true`
	)		const

 {
     Creature* creature = NULL;
     Trinity::NearestCreatureEntryWithLiveStateInObjectRangeCheck checker(*this, entry, alive, range);
     Trinity::CreatureLastSearcher<Trinity::NearestCreatureEntryWithLiveStateInObjectRangeCheck> searcher(this, creature, checker);
     VisitNearbyObject(range, searcher);
     return creature;
 }

Here is the call graph for this function:

GameObject * WorldObject::FindNearestGameObject	(	uint32	entry,
		float	range
	)		const

 {
     GameObject* go = NULL;
     Trinity::NearestGameObjectEntryInObjectRangeCheck checker(*this, entry, range);
     Trinity::GameObjectLastSearcher<Trinity::NearestGameObjectEntryInObjectRangeCheck> searcher(this, go, checker);
     VisitNearbyGridObject(range, searcher);
     return go;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObject * WorldObject::FindNearestGameObjectOfType	(	GameobjectTypes	type,
		float	range
	)		const

 {
     GameObject* go = NULL;
     Trinity::NearestGameObjectTypeInObjectRangeCheck checker(*this, type, range);
     Trinity::GameObjectLastSearcher<Trinity::NearestGameObjectTypeInObjectRangeCheck> searcher(this, go, checker);
     VisitNearbyGridObject(range, searcher);
     return go;
 }

Here is the call graph for this function:

virtual uint16 WorldObject::GetAIAnimKitId ( ) const

inlinevirtual

Reimplemented in Unit, and GameObject.

619 { return 0; }

uint32 WorldObject::GetAreaId ( ) const

 {
     return GetBaseMap()->GetAreaId(m_positionX, m_positionY, m_positionZ);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Map const * WorldObject::GetBaseMap ( ) const

 {
     ASSERT(m_currMap);
     return m_currMap->GetParent();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetClosePoint	(	float &	x,
		float &	y,
		float &	z,
		float	size,
		float	distance2d = `0`,
		float	angle = `0`
	)		const

 {
     // angle calculated from current orientation
     GetNearPoint(NULL, x, y, z, size, distance2d, GetOrientation() + angle);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetContactPoint	(	WorldObject const *	obj,
		float &	x,
		float &	y,
		float &	z,
		float	distance2d = `CONTACT_DISTANCE`
	)		const

 {
     // angle to face `obj` to `this` using distance includes size of `obj`
     GetNearPoint(obj, x, y, z, obj->GetObjectSize(), distance2d, GetAngle(obj));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetCreatureListWithEntryInGrid	(	std::list< Creature * > &	lList,
		uint32	uiEntry,
		float	fMaxSearchRange
	)		const

 {
     CellCoord pair(Trinity::ComputeCellCoord(this->GetPositionX(), this->GetPositionY()));
     Cell cell(pair);
     cell.SetNoCreate();
 
     Trinity::AllCreaturesOfEntryInRange check(this, entry, maxSearchRange);
     Trinity::CreatureListSearcher<Trinity::AllCreaturesOfEntryInRange> searcher(this, creatureList, check);
     TypeContainerVisitor<Trinity::CreatureListSearcher<Trinity::AllCreaturesOfEntryInRange>, GridTypeMapContainer> visitor(searcher);
 
     cell.Visit(pair, visitor, *(this->GetMap()), *this, maxSearchRange);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 WorldObject::GetDBPhase ( ) const

inline

468 { return _dbPhase; }

WorldObject::_dbPhase

int32 _dbPhase

Definition: Object.h:652

Here is the caller graph for this function:

float WorldObject::GetDistance ( WorldObject const * obj ) const

 {
     float d = GetExactDist(obj) - GetObjectSize() - obj->GetObjectSize();
     return d > 0.0f ? d : 0.0f;
 }

Here is the call graph for this function:

float WorldObject::GetDistance ( Position const & pos ) const

 {
     float d = GetExactDist(&pos) - GetObjectSize();
     return d > 0.0f ? d : 0.0f;
 }

Here is the call graph for this function:

float WorldObject::GetDistance	(	float	x,
		float	y,
		float	z
	)		const

 {
     float d = GetExactDist(x, y, z) - GetObjectSize();
     return d > 0.0f ? d : 0.0f;
 }

Here is the call graph for this function:

float WorldObject::GetDistance2d ( WorldObject const * obj ) const

 {
     float d = GetExactDist2d(obj) - GetObjectSize() - obj->GetObjectSize();
     return d > 0.0f ? d : 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float WorldObject::GetDistance2d	(	float	x,
		float	y
	)		const

 {
     float d = GetExactDist2d(x, y) - GetObjectSize();
     return d > 0.0f ? d : 0.0f;
 }

Here is the call graph for this function:

bool WorldObject::GetDistanceOrder	(	WorldObject const *	obj1,
		WorldObject const *	obj2,
		bool	is3D = `true`
	)		const

 {
     float dx1 = GetPositionX() - obj1->GetPositionX();
     float dy1 = GetPositionY() - obj1->GetPositionY();
     float distsq1 = dx1*dx1 + dy1*dy1;
     if (is3D)
     {
         float dz1 = GetPositionZ() - obj1->GetPositionZ();
         distsq1 += dz1*dz1;
     }
 
     float dx2 = GetPositionX() - obj2->GetPositionX();
     float dy2 = GetPositionY() - obj2->GetPositionY();
     float distsq2 = dx2*dx2 + dy2*dy2;
     if (is3D)
     {
         float dz2 = GetPositionZ() - obj2->GetPositionZ();
         distsq2 += dz2*dz2;
     }
 
     return distsq1 < distsq2;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float WorldObject::GetDistanceZ ( WorldObject const * obj ) const

 {
     float dz = std::fabs(GetPositionZ() - obj->GetPositionZ());
     float sizefactor = GetObjectSize() + obj->GetObjectSize();
     float dist = dz - sizefactor;
     return (dist > 0 ? dist : 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Position WorldObject::GetFirstCollisionPosition	(	float	dist,
		float	angle
	)

 {
     Position pos = GetPosition();
     MovePositionToFirstCollision(pos, dist, angle);
     return pos;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetGameObjectListWithEntryInGrid	(	std::list< GameObject * > &	lList,
		uint32	uiEntry,
		float	fMaxSearchRange
	)		const

 {
     CellCoord pair(Trinity::ComputeCellCoord(this->GetPositionX(), this->GetPositionY()));
     Cell cell(pair);
     cell.SetNoCreate();
 
     Trinity::AllGameObjectsWithEntryInRange check(this, entry, maxSearchRange);
     Trinity::GameObjectListSearcher<Trinity::AllGameObjectsWithEntryInRange> searcher(this, gameobjectList, check);
     TypeContainerVisitor<Trinity::GameObjectListSearcher<Trinity::AllGameObjectsWithEntryInRange>, GridTypeMapContainer> visitor(searcher);
 
     cell.Visit(pair, visitor, *(this->GetMap()), *this, maxSearchRange);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float WorldObject::GetGridActivationRange ( ) const

 {
     if (ToPlayer())
         return GetMap()->GetVisibilityRange();
     else if (ToCreature())
         return ToCreature()->m_SightDistance;
     else
         return 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 WorldObject::GetInstanceId ( ) const

inline

451 { return m_InstanceId; }

uint32 m_InstanceId

Definition: Object.h:647

Here is the caller graph for this function:

InstanceScript * WorldObject::GetInstanceScript ( )

 {
     Map* map = GetMap();
     return map->IsDungeon() ? ((InstanceMap*)map)->GetInstanceScript() : NULL;
 }

Here is the call graph for this function:

virtual uint8 WorldObject::getLevelForTarget ( WorldObject const * ) const

inlinevirtual

Reimplemented in Unit, GameObject, and Creature.

517 { return 1; }

Here is the caller graph for this function:

Map* WorldObject::GetMap ( ) const

inline

543 { ASSERT(m_currMap); return m_currMap; }

WorldObject::m_currMap

Map * m_currMap

Definition: Object.h:644

ASSERT

#define ASSERT

Definition: Errors.h:55

virtual uint16 WorldObject::GetMeleeAnimKitId ( ) const

inlinevirtual

Reimplemented in Unit.

621 { return 0; }

virtual uint16 WorldObject::GetMovementAnimKitId ( ) const

inlinevirtual

Reimplemented in Unit.

620 { return 0; }

std::string const& WorldObject::GetName ( ) const

inline

479 { return m_name; }

WorldObject::m_name

std::string m_name

Definition: Object.h:624

Here is the caller graph for this function:

virtual std::string const& WorldObject::GetNameForLocaleIdx ( LocaleConstant ) const

inlinevirtual

Reimplemented in GameObject, and Creature.

482 { return m_name; }

WorldObject::m_name

std::string m_name

Definition: Object.h:624

void WorldObject::GetNearPoint	(	WorldObject const *	searcher,
		float &	x,
		float &	y,
		float &	z,
		float	searcher_size,
		float	distance2d,
		float	absAngle
	)		const

 {
     GetNearPoint2D(x, y, distance2d+searcher_size, absAngle);
     z = GetPositionZ();
     // Should "searcher" be used instead of "this" when updating z coordinate ?
     UpdateAllowedPositionZ(x, y, z);
 
     // if detection disabled, return first point
     if (!sWorld->getBoolConfig(CONFIG_DETECT_POS_COLLISION))
         return;
 
     // return if the point is already in LoS
     if (IsWithinLOS(x, y, z))
         return;
 
     // remember first point
     float first_x = x;
     float first_y = y;
     float first_z = z;
 
     // loop in a circle to look for a point in LoS using small steps
     for (float angle = float(M_PI) / 8; angle < float(M_PI) * 2; angle += float(M_PI) / 8)
     {
         GetNearPoint2D(x, y, distance2d + searcher_size, absAngle + angle);
         z = GetPositionZ();
         UpdateAllowedPositionZ(x, y, z);
         if (IsWithinLOS(x, y, z))
             return;
     }
 
     // still not in LoS, give up and return first position found
     x = first_x;
     y = first_y;
     z = first_z;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetNearPoint2D	(	float &	x,
		float &	y,
		float	distance,
		float	absAngle
	)		const

 {
     x = GetPositionX() + (GetObjectSize() + distance2d) * std::cos(absAngle);
     y = GetPositionY() + (GetObjectSize() + distance2d) * std::sin(absAngle);
 
     Trinity::NormalizeMapCoord(x);
     Trinity::NormalizeMapCoord(y);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Position WorldObject::GetNearPosition	(	float	dist,
		float	angle
	)

 {
     Position pos = GetPosition();
     MovePosition(pos, dist, angle);
     return pos;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 WorldObject::GetNotifyFlags ( ) const

inline

576 { return m_notifyflags; }

WorldObject::_terrainSwaps

uint16 m_notifyflags

Definition: Object.h:654

float WorldObject::GetObjectSize ( ) const

 {
     return (m_valuesCount > UNIT_FIELD_COMBATREACH) ? m_floatValues[UNIT_FIELD_COMBATREACH] : DEFAULT_WORLD_OBJECT_SIZE;
 }

Here is the caller graph for this function:

uint32 WorldObject::GetPhaseMask ( ) const

inline

461 { return m_phaseMask; }

WorldObject::m_phaseMask

uint32 m_phaseMask

Definition: Object.h:648

Here is the caller graph for this function:

std::set<uint32> const& WorldObject::GetPhases ( ) const

inline

465 { return _phases; }

WorldObject::_phases

std::set< uint32 > _phases

Definition: Object.h:649

Here is the caller graph for this function:

void WorldObject::GetPlayerListInGrid	(	std::list< Player * > &	lList,
		float	fMaxSearchRange
	)		const

 {
     Trinity::AnyPlayerInObjectRangeCheck checker(this, maxSearchRange);
     Trinity::PlayerListSearcher<Trinity::AnyPlayerInObjectRangeCheck> searcher(this, playerList, checker);
     this->VisitNearbyWorldObject(maxSearchRange, searcher);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Position WorldObject::GetRandomNearPosition ( float radius )

 {
     Position pos = GetPosition();
     MovePosition(pos, radius * (float)rand_norm(), (float)rand_norm() * static_cast<float>(2 * M_PI));
     return pos;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::GetRandomPoint	(	Position const &	srcPos,
		float	distance,
		float &	rand_x,
		float &	rand_y,
		float &	rand_z
	)		const

 {
     if (!distance)
     {
         pos.GetPosition(rand_x, rand_y, rand_z);
         return;
     }
 
     // angle to face `obj` to `this`
     float angle = (float)rand_norm()*static_cast<float>(2*M_PI);
     float new_dist = (float)rand_norm()*static_cast<float>(distance);
 
     rand_x = pos.m_positionX + new_dist * std::cos(angle);
     rand_y = pos.m_positionY + new_dist * std::sin(angle);
     rand_z = pos.m_positionZ;
 
     Trinity::NormalizeMapCoord(rand_x);
     Trinity::NormalizeMapCoord(rand_y);
     UpdateGroundPositionZ(rand_x, rand_y, rand_z);            // update to LOS height if available
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Position WorldObject::GetRandomPoint	(	Position const &	srcPos,
		float	distance
	)		const

 {
     float x, y, z;
     GetRandomPoint(srcPos, distance, x, y, z);
     return Position(x, y, z, GetOrientation());
 }

Here is the call graph for this function:

float WorldObject::GetSightRange ( WorldObject const * target = NULL ) const

 {
     if (ToUnit())
     {
         if (ToPlayer())
         {
             if (target && target->isActiveObject() && !target->ToPlayer())
                 return MAX_VISIBILITY_DISTANCE;
             else
                 return GetMap()->GetVisibilityRange();
         }
         else if (ToCreature())
             return ToCreature()->m_SightDistance;
         else
             return SIGHT_RANGE_UNIT;
     }
 
     return 0.0f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual float WorldObject::GetStationaryO ( ) const

inlinevirtual

Reimplemented in GameObject.

617 { return GetOrientation(); }

Position::GetOrientation

float GetOrientation() const

Definition: Position.h:107

Here is the call graph for this function:

virtual float WorldObject::GetStationaryX ( ) const

inlinevirtual

Reimplemented in GameObject.

614 { return GetPositionX(); }

Position::GetPositionX

float GetPositionX() const

Definition: Position.h:104

Here is the call graph for this function:

virtual float WorldObject::GetStationaryY ( ) const

inlinevirtual

Reimplemented in GameObject.

615 { return GetPositionY(); }

Position::GetPositionY

float GetPositionY() const

Definition: Position.h:105

Here is the call graph for this function:

virtual float WorldObject::GetStationaryZ ( ) const

inlinevirtual

Reimplemented in GameObject.

616 { return GetPositionZ(); }

Position::GetPositionZ

float GetPositionZ() const

Definition: Position.h:106

Here is the call graph for this function:

std::set<uint32> const& WorldObject::GetTerrainSwaps ( ) const

inline

466 { return _terrainSwaps; }

std::set< uint32 > _terrainSwaps

Definition: Object.h:650

Here is the caller graph for this function:

ObjectGuid WorldObject::GetTransGUID ( ) const

virtual

Reimplemented in Unit.

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

Here is the call graph for this function:

Here is the caller graph for this function:

float WorldObject::GetTransOffsetO ( ) const

inline

606 { return m_movementInfo.transport.pos.GetOrientation(); }

MovementInfo m_movementInfo

Definition: Object.h:612

struct MovementInfo::TransportInfo transport

Position::GetOrientation

float GetOrientation() const

Definition: Position.h:107

Position pos

Definition: Object.h:290

Here is the caller graph for this function:

float WorldObject::GetTransOffsetX ( ) const

inline

603 { return m_movementInfo.transport.pos.GetPositionX(); }

MovementInfo m_movementInfo

Definition: Object.h:612

struct MovementInfo::TransportInfo transport

Position pos

Definition: Object.h:290

Position::GetPositionX

float GetPositionX() const

Definition: Position.h:104

Here is the caller graph for this function:

float WorldObject::GetTransOffsetY ( ) const

inline

604 { return m_movementInfo.transport.pos.GetPositionY(); }

MovementInfo m_movementInfo

Definition: Object.h:612

struct MovementInfo::TransportInfo transport

Position::GetPositionY

float GetPositionY() const

Definition: Position.h:105

Position pos

Definition: Object.h:290

Here is the caller graph for this function:

float WorldObject::GetTransOffsetZ ( ) const

inline

605 { return m_movementInfo.transport.pos.GetPositionZ(); }

MovementInfo m_movementInfo

Definition: Object.h:612

struct MovementInfo::TransportInfo transport

Position::GetPositionZ

float GetPositionZ() const

Definition: Position.h:106

Position pos

Definition: Object.h:290

Here is the caller graph for this function:

Transport* WorldObject::GetTransport ( ) const

inline

602 { return m_transport; }

WorldObject::m_transport

Transport * m_transport

Definition: Object.h:630

Here is the caller graph for this function:

int8 WorldObject::GetTransSeat ( ) const

inline

608 { return m_movementInfo.transport.seat; }

MovementInfo m_movementInfo

Definition: Object.h:612

MovementInfo::TransportInfo::seat

struct MovementInfo::TransportInfo transport

int8 seat

Definition: Object.h:291

Here is the caller graph for this function:

uint32 WorldObject::GetTransTime ( ) const

inline

607 { return m_movementInfo.transport.time; }

MovementInfo m_movementInfo

Definition: Object.h:612

MovementInfo::TransportInfo::time

struct MovementInfo::TransportInfo transport

uint32 time

Definition: Object.h:292

float WorldObject::GetVisibilityRange ( ) const

 {
     if (isActiveObject() && !ToPlayer())
         return MAX_VISIBILITY_DISTANCE;
     else
         return GetMap()->GetVisibilityRange();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::set<uint32> const& WorldObject::GetWorldMapAreaSwaps ( ) const

inline

467 { return _worldMapAreaSwaps; }

WorldObject::_worldMapAreaSwaps

std::set< uint32 > _worldMapAreaSwaps

Definition: Object.h:651

Here is the caller graph for this function:

void WorldObject::GetZoneAndAreaId	(	uint32 &	zoneid,
		uint32 &	areaid
	)		const

 {
     GetBaseMap()->GetZoneAndAreaId(zoneid, areaid, m_positionX, m_positionY, m_positionZ);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 WorldObject::GetZoneId ( ) const

 {
     return GetBaseMap()->GetZoneId(m_positionX, m_positionY, m_positionZ);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ZoneScript* WorldObject::GetZoneScript ( ) const

inline

551 { return m_zoneScript; }

WorldObject::m_zoneScript

ZoneScript * m_zoneScript

Definition: Object.h:627

Here is the caller graph for this function:

bool WorldObject::HasInPhaseList ( uint32 phase )

 {
     return _phases.find(phase) != _phases.end();
 }

Here is the caller graph for this function:

bool WorldObject::isActiveObject ( ) const

inline

581 { return m_isActive; }

WorldObject::m_isActive

bool m_isActive

Definition: Object.h:625

Here is the caller graph for this function:

virtual bool WorldObject::IsAlwaysDetectableFor ( WorldObject const * ) const

inlineprotectedvirtual

Reimplemented in Unit.

642 { return false; }

Here is the caller graph for this function:

virtual bool WorldObject::IsAlwaysVisibleFor ( WorldObject const * ) const

inlineprotectedvirtual

Reimplemented in Unit, and GameObject.

639 { return false; }

Here is the caller graph for this function:

bool WorldObject::isInBack	(	WorldObject const *	target,
		float	arc = `float(M_PI)`
	)		const

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsInBetween	(	WorldObject const *	obj1,
		WorldObject const *	obj2,
		float	size = `0`
	)		const

 {
     if (!obj1 || !obj2)
         return false;
 
     float dist = GetExactDist2d(obj1->GetPositionX(), obj1->GetPositionY());
 
     // not using sqrt() for performance
     if ((dist * dist) >= obj1->GetExactDist2dSq(obj2->GetPositionX(), obj2->GetPositionY()))
         return false;
 
     if (!size)
         size = GetObjectSize() / 2;
 
     float angle = obj1->GetAngle(obj2);
 
     // not using sqrt() for performance
     return (size * size) >= GetExactDist2dSq(obj1->GetPositionX() + std::cos(angle) * dist, obj1->GetPositionY() + std::sin(angle) * dist);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::isInFront	(	WorldObject const *	target,
		float	arc = `float(M_PI)`
	)		const

 {
     return HasInArc(arc, target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsInMap ( WorldObject const * obj ) const

 {
     if (obj)
         return IsInWorld() && obj->IsInWorld() && (GetMap() == obj->GetMap());
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsInPhase ( uint32 phase ) const

inline

462 { return _phases.find(phase) != _phases.end(); }

WorldObject::_phases

std::set< uint32 > _phases

Definition: Object.h:649

Here is the caller graph for this function:

bool WorldObject::IsInPhase ( WorldObject const * obj ) const

 {
     // PhaseId 169 is the default fallback phase
     if (_phases.empty() && obj->GetPhases().empty())
         return true;
 
     if (_phases.empty() && obj->IsInPhase(DEFAULT_PHASE))
         return true;
 
     if (obj->GetPhases().empty() && IsInPhase(DEFAULT_PHASE))
         return true;
 
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->IsGameMaster())
         return true;
 
     return Trinity::Containers::Intersects(_phases.begin(), _phases.end(), obj->GetPhases().begin(), obj->GetPhases().end());
 }

Here is the call graph for this function:

bool WorldObject::IsInRange	(	WorldObject const *	obj,
		float	minRange,
		float	maxRange,
		bool	is3D = `true`
	)		const

 {
     float dx = GetPositionX() - obj->GetPositionX();
     float dy = GetPositionY() - obj->GetPositionY();
     float distsq = dx*dx + dy*dy;
     if (is3D)
     {
         float dz = GetPositionZ() - obj->GetPositionZ();
         distsq += dz*dz;
     }
 
     float sizefactor = GetObjectSize() + obj->GetObjectSize();
 
     // check only for real range
     if (minRange > 0.0f)
     {
         float mindist = minRange + sizefactor;
         if (distsq < mindist * mindist)
             return false;
     }
 
     float maxdist = maxRange + sizefactor;
     return distsq < maxdist * maxdist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsInRange2d	(	float	x,
		float	y,
		float	minRange,
		float	maxRange
	)		const

 {
     float dx = GetPositionX() - x;
     float dy = GetPositionY() - y;
     float distsq = dx*dx + dy*dy;
 
     float sizefactor = GetObjectSize();
 
     // check only for real range
     if (minRange > 0.0f)
     {
         float mindist = minRange + sizefactor;
         if (distsq < mindist * mindist)
             return false;
     }
 
     float maxdist = maxRange + sizefactor;
     return distsq < maxdist * maxdist;
 }

Here is the call graph for this function:

bool WorldObject::IsInRange3d	(	float	x,
		float	y,
		float	z,
		float	minRange,
		float	maxRange
	)		const

 {
     float dx = GetPositionX() - x;
     float dy = GetPositionY() - y;
     float dz = GetPositionZ() - z;
     float distsq = dx*dx + dy*dy + dz*dz;
 
     float sizefactor = GetObjectSize();
 
     // check only for real range
     if (minRange > 0.0f)
     {
         float mindist = minRange + sizefactor;
         if (distsq < mindist * mindist)
             return false;
     }
 
     float maxdist = maxRange + sizefactor;
     return distsq < maxdist * maxdist;
 }

Here is the call graph for this function:

bool WorldObject::IsInTerrainSwap ( uint32 terrainSwap ) const

inline

464 { return _terrainSwaps.find(terrainSwap) != _terrainSwaps.end(); }

WorldObject::_terrainSwaps

std::set< uint32 > _terrainSwaps

Definition: Object.h:650

virtual bool WorldObject::IsInvisibleDueToDespawn ( ) const

inlineprotectedvirtual

Reimplemented in GameObject, and Creature.

640 { return false; }

Here is the caller graph for this function:

bool WorldObject::isNeedNotify ( uint16 f ) const

inline

575 { return (m_notifyflags & f) != 0; }

WorldObject::m_isWorldObject

uint16 m_notifyflags

Definition: Object.h:654

Here is the caller graph for this function:

virtual bool WorldObject::IsNeverVisible ( ) const

inlineprotectedvirtual

Reimplemented in GameObject.

638 { return !IsInWorld(); }

Object::IsInWorld

bool IsInWorld() const

Definition: Object.h:100

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsPermanentWorldObject ( ) const

inline

584 { return m_isWorldObject; }

const bool m_isWorldObject

Definition: Object.h:626

Here is the caller graph for this function:

bool WorldObject::IsSelfOrInSameMap ( WorldObject const * obj ) const

 {
     if (this == obj)
         return true;
     return IsInMap(obj);
 }

Here is the call graph for this function:

bool WorldObject::IsWithinDist	(	WorldObject const *	obj,
		float	dist2compare,
		bool	is3D = `true`
	)		const

 {
     return obj && _IsWithinDist(obj, dist2compare, is3D);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsWithinDist2d	(	float	x,
		float	y,
		float	dist
	)		const

 {
     return IsInDist2d(x, y, dist + GetObjectSize());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsWithinDist2d	(	Position const *	pos,
		float	dist
	)		const

 {
     return IsInDist2d(pos, dist + GetObjectSize());
 }

Here is the call graph for this function:

bool WorldObject::IsWithinDist3d	(	float	x,
		float	y,
		float	z,
		float	dist
	)		const

 {
     return IsInDist(x, y, z, dist + GetObjectSize());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsWithinDist3d	(	Position const *	pos,
		float	dist
	)		const

 {
     return IsInDist(pos, dist + GetObjectSize());
 }

Here is the call graph for this function:

bool WorldObject::IsWithinDistInMap	(	WorldObject const *	obj,
		float	dist2compare,
		bool	is3D = `true`
	)		const

 {
     return obj && IsInMap(obj) && IsInPhase(obj) && _IsWithinDist(obj, dist2compare, is3D);
 }

Here is the call graph for this function:

bool WorldObject::IsWithinLOS	(	float	x,
		float	y,
		float	z
	)		const

 {
     /*float x, y, z;
     GetPosition(x, y, z);
     VMAP::IVMapManager* vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
     return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);*/
     if (IsInWorld())
         return GetMap()->isInLineOfSight(GetPositionX(), GetPositionY(), GetPositionZ()+2.f, ox, oy, oz+2.f, GetPhaseMask());
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsWithinLOSInMap ( WorldObject const * obj ) const

 {
     if (!IsInMap(obj))
         return false;
 
     float ox, oy, oz;
     obj->GetPosition(ox, oy, oz);
     return IsWithinLOS(ox, oy, oz);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::IsWorldObject ( ) const

 {
     if (m_isWorldObject)
         return true;
 
     if (ToCreature() && ToCreature()->m_isTempWorldObject)
         return true;
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::MovePosition	(	Position &	pos,
		float	dist,
		float	angle
	)

 {
     angle += GetOrientation();
     float destx, desty, destz, ground, floor;
     destx = pos.m_positionX + dist * std::cos(angle);
     desty = pos.m_positionY + dist * std::sin(angle);
 
     // Prevent invalid coordinates here, position is unchanged
     if (!Trinity::IsValidMapCoord(destx, desty, pos.m_positionZ))
     {
         TC_LOG_FATAL("misc", "WorldObject::MovePosition: Object (Entry: %u %s) has invalid coordinates X: %f and Y: %f were passed!",
             GetEntry(), GetGUID().ToString().c_str(), destx, desty);
         return;
     }
 
     ground = GetMap()->GetHeight(GetPhaseMask(), destx, desty, MAX_HEIGHT, true);
     floor = GetMap()->GetHeight(GetPhaseMask(), destx, desty, pos.m_positionZ, true);
     destz = std::fabs(ground - pos.m_positionZ) <= std::fabs(floor - pos.m_positionZ) ? ground : floor;
 
     float step = dist/10.0f;
 
     for (uint8 j = 0; j < 10; ++j)
     {
         // do not allow too big z changes
         if (std::fabs(pos.m_positionZ - destz) > 6)
         {
             destx -= step * std::cos(angle);
             desty -= step * std::sin(angle);
             ground = GetMap()->GetHeight(GetPhaseMask(), destx, desty, MAX_HEIGHT, true);
             floor = GetMap()->GetHeight(GetPhaseMask(), destx, desty, pos.m_positionZ, true);
             destz = std::fabs(ground - pos.m_positionZ) <= std::fabs(floor - pos.m_positionZ) ? ground : floor;
         }
         // we have correct destz now
         else
         {
             pos.Relocate(destx, desty, destz);
             break;
         }
     }
 
     Trinity::NormalizeMapCoord(pos.m_positionX);
     Trinity::NormalizeMapCoord(pos.m_positionY);
     UpdateGroundPositionZ(pos.m_positionX, pos.m_positionY, pos.m_positionZ);
     pos.SetOrientation(GetOrientation());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::MovePositionToFirstCollision	(	Position &	pos,
		float	dist,
		float	angle
	)

 {
     angle += GetOrientation();
     float destx, desty, destz;
     destx = pos.m_positionX + dist * std::cos(angle);
     desty = pos.m_positionY + dist * std::sin(angle);
 
     // Prevent invalid coordinates here, position is unchanged
     if (!Trinity::IsValidMapCoord(destx, desty))
     {
         TC_LOG_FATAL("misc", "WorldObject::MovePositionToFirstCollision invalid coordinates X: %f and Y: %f were passed!", destx, desty);
         return;
     }
 
     destz = NormalizeZforCollision(this, destx, desty, pos.GetPositionZ());
     bool col = VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(GetMapId(), pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
 
     // collision occured
     if (col)
     {
         // move back a bit
         destx -= CONTACT_DISTANCE * std::cos(angle);
         desty -= CONTACT_DISTANCE * std::sin(angle);
         dist = std::sqrt((pos.m_positionX - destx)*(pos.m_positionX - destx) + (pos.m_positionY - desty)*(pos.m_positionY - desty));
     }
 
     // check dynamic collision
     col = GetMap()->getObjectHitPos(GetPhaseMask(), pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
 
     // Collided with a gameobject
     if (col)
     {
         destx -= CONTACT_DISTANCE * std::cos(angle);
         desty -= CONTACT_DISTANCE * std::sin(angle);
         dist = std::sqrt((pos.m_positionX - destx)*(pos.m_positionX - destx) + (pos.m_positionY - desty)*(pos.m_positionY - desty));
     }
 
     float step = dist / 10.0f;
 
     for (uint8 j = 0; j < 10; ++j)
     {
         // do not allow too big z changes
         if (std::fabs(pos.m_positionZ - destz) > 6.0f)
         {
             destx -= step * std::cos(angle);
             desty -= step * std::sin(angle);
             destz = NormalizeZforCollision(this, destx, desty, pos.GetPositionZ());
         }
         // we have correct destz now
         else
         {
             pos.Relocate(destx, desty, destz);
             break;
         }
     }
 
     Trinity::NormalizeMapCoord(pos.m_positionX);
     Trinity::NormalizeMapCoord(pos.m_positionY);
     pos.m_positionZ = NormalizeZforCollision(this, destx, desty, pos.GetPositionZ());
     pos.SetOrientation(GetOrientation());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldObject::NotifyExecuted ( uint16 f ) const

inline

577 { return (m_executed_notifies & f) != 0; }

WorldObject::m_executed_notifies

uint16 m_executed_notifies

Definition: Object.h:655

void WorldObject::PlayDirectSound	(	uint32	sound_id,
		Player *	target = `NULL`
	)

 {
     if (target)
         target->SendDirectMessage(WorldPackets::Misc::PlaySound(GetGUID(), sound_id).Write());
     else
         SendMessageToSet(WorldPackets::Misc::PlaySound(GetGUID(), sound_id).Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::PlayDistanceSound	(	uint32	sound_id,
		Player *	target = `NULL`
	)

 {
     WorldPacket data(SMSG_PLAY_SPEAKERBOT_SOUND, 4 + 8);
     data << uint32(sound_id);
     data << GetGUID();
     if (target)
         target->SendDirectMessage(&data);
     else
         SendMessageToSet(&data, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::RebuildTerrainSwaps ( )

 {
     // Clear all terrain swaps, will be rebuilt below
     // Reason for this is, multiple phases can have the same terrain swap, we should not remove the swap if another phase still use it
     _terrainSwaps.clear();
 
     // Check all applied phases for terrain swap and add it only once
     for (uint32 phaseId : _phases)
     {
         if (std::vector<uint32> const* swaps = sObjectMgr->GetPhaseTerrainSwaps(phaseId))
         {
             for (uint32 const& swap : *swaps)
             {
                 // only add terrain swaps for current map
                 MapEntry const* mapEntry = sMapStore.LookupEntry(swap);
                 if (!mapEntry || mapEntry->ParentMapID != int32(GetMapId()))
                     continue;
 
                 if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, swap, this))
                     _terrainSwaps.insert(swap);
             }
         }
     }
 
     // get default terrain swaps, only for current map always
     if (std::vector<uint32> const* mapSwaps = sObjectMgr->GetDefaultTerrainSwaps(GetMapId()))
         for (uint32 const& swap : *mapSwaps)
             if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, swap, this))
                 _terrainSwaps.insert(swap);
 
     // online players have a game client with world map display
     if (GetTypeId() == TYPEID_PLAYER)
         RebuildWorldMapAreaSwaps();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::RebuildWorldMapAreaSwaps ( )

 {
     // Clear all world map area swaps, will be rebuilt below
     _worldMapAreaSwaps.clear();
 
     // get ALL default terrain swaps, if we are using it (condition is true)
     // send the worldmaparea for it, to see swapped worldmaparea in client from other maps too, not just from our current
     TerrainPhaseInfo const& defaults = sObjectMgr->GetDefaultTerrainSwapStore();
     for (TerrainPhaseInfo::const_iterator itr = defaults.begin(); itr != defaults.end(); ++itr)
         for (uint32 const& swap : itr->second)
             if (std::vector<uint32> const* uiMapSwaps = sObjectMgr->GetTerrainWorldMaps(swap))
                 if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, swap, this))
                     for (uint32 worldMapAreaId : *uiMapSwaps)
                         _worldMapAreaSwaps.insert(worldMapAreaId);
 
     // Check all applied phases for world map area swaps
     for (uint32 phaseId : _phases)
         if (std::vector<uint32> const* swaps = sObjectMgr->GetPhaseTerrainSwaps(phaseId))
             for (uint32 const& swap : *swaps)
                 if (std::vector<uint32> const* uiMapSwaps = sObjectMgr->GetTerrainWorldMaps(swap))
                     if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, swap, this))
                         for (uint32 worldMapAreaId : *uiMapSwaps)
                             _worldMapAreaSwaps.insert(worldMapAreaId);
 }

Here is the caller graph for this function:

void WorldObject::RemoveFromObjectUpdate ( )

overridevirtual

Implements Object.

 {
     GetMap()->RemoveUpdateObject(this);
 }

Here is the call graph for this function:

void WorldObject::RemoveFromWorld ( )

overridevirtual

Reimplemented from Object.

Reimplemented in Unit, GameObject, Creature, Puppet, Minion, Corpse, Pet, TempSummon, DynamicObject, and AreaTrigger.

 {
     if (!IsInWorld())
         return;
 
     DestroyForNearbyPlayers();
 
     Object::RemoveFromWorld();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldObject::ResetAllNotifies ( )

inline

579 { m_notifyflags = 0; m_executed_notifies = 0; }