#include "Map.h"

Inheritance diagram for Map:

Public Types
enum	EnterState { CAN_ENTER = 0 , CANNOT_ENTER_ALREADY_IN_MAP = 1 , CANNOT_ENTER_NO_ENTRY , CANNOT_ENTER_UNINSTANCED_DUNGEON , CANNOT_ENTER_DIFFICULTY_UNAVAILABLE , CANNOT_ENTER_NOT_IN_RAID , CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE , CANNOT_ENTER_INSTANCE_BIND_MISMATCH , CANNOT_ENTER_TOO_MANY_INSTANCES , CANNOT_ENTER_MAX_PLAYERS , CANNOT_ENTER_ZONE_IN_COMBAT , CANNOT_ENTER_UNSPECIFIED_REASON }

typedef MapRefMgr	PlayerList

typedef std::unordered_multimap< ObjectGuid::LowType, Creature * >	CreatureBySpawnIdContainer

typedef std::unordered_multimap< ObjectGuid::LowType, GameObject * >	GameObjectBySpawnIdContainer

typedef std::vector< WorldObject * >	UpdatableObjectList

typedef std::unordered_set< WorldObject * >	PendingAddUpdatableObjectList

Public Types inherited from GridRefMgr< MapGridType >
typedef LinkedListHead::Iterator< GridReference< MapGridType > >	iterator

Public Types inherited from RefMgr< TO, FROM >
typedef LinkedListHead::Iterator< Reference< TO, FROM > >	iterator

Public Types inherited from LinkedListHead
typedef Iterator< LinkedListElement >	iterator

Public Member Functions
	Map (uint32 id, uint32 InstanceId, uint8 SpawnMode, Map *_parent=nullptr)

	~Map () override

MapEntry const *	GetEntry () const

bool	CanUnload (uint32 diff)

virtual bool	AddPlayerToMap (Player *)

virtual void	RemovePlayerFromMap (Player *, bool)

virtual void	AfterPlayerUnlinkFromMap ()

template<class T >
bool	AddToMap (T *, bool checkTransport=false)

template<class T >
void	RemoveFromMap (T *, bool)

void	MarkNearbyCellsOf (WorldObject *obj)

virtual void	Update (const uint32, const uint32, bool thread=true)

float	GetVisibilityRange () const

void	SetVisibilityRange (float range)

void	OnCreateMap ()

virtual void	InitVisibilityDistance ()

void	PlayerRelocation (Player *, float x, float y, float z, float o)

void	CreatureRelocation (Creature *creature, float x, float y, float z, float o)

void	GameObjectRelocation (GameObject *go, float x, float y, float z, float o)

void	DynamicObjectRelocation (DynamicObject *go, float x, float y, float z, float o)

template<class T , class CONTAINER >
void	Visit (const Cell &cell, TypeContainerVisitor< T, CONTAINER > &visitor)

bool	IsGridLoaded (GridCoord const &gridCoord) const

bool	IsGridLoaded (float x, float y) const

bool	IsGridCreated (GridCoord const &gridCoord) const

bool	IsGridCreated (float x, float y) const

void	LoadGrid (float x, float y)

void	LoadAllGrids ()

void	LoadGridsInRange (Position const &center, float radius)

bool	UnloadGrid (MapGridType &grid)

virtual void	UnloadAll ()

std::shared_ptr< GridTerrainData >	GetGridTerrainDataSharedPtr (GridCoord const &gridCoord)

GridTerrainData *	GetGridTerrainData (GridCoord const &gridCoord)

GridTerrainData *	GetGridTerrainData (float x, float y)

uint32	GetId () const

Map const *	GetParent () const

std::shared_mutex &	GetMMapLock () const

void	HandleDelayedVisibility ()

float	GetHeight (float x, float y, float z, bool checkVMap=true, float maxSearchDist=DEFAULT_HEIGHT_SEARCH) const

float	GetGridHeight (float x, float y) const

float	GetMinHeight (float x, float y) const

Transport *	GetTransportForPos (uint32 phase, float x, float y, float z, WorldObject *worldobject=nullptr)

void	GetFullTerrainStatusForPosition (uint32 phaseMask, float x, float y, float z, float collisionHeight, PositionFullTerrainStatus &data, uint8 reqLiquidType=MAP_ALL_LIQUIDS)

LiquidData const	GetLiquidData (uint32 phaseMask, float x, float y, float z, float collisionHeight, uint8 ReqLiquidType)

bool	GetAreaInfo (uint32 phaseMask, float x, float y, float z, uint32 &mogpflags, int32 &adtId, int32 &rootId, int32 &groupId) const

uint32	GetAreaId (uint32 phaseMask, float x, float y, float z) const

uint32	GetZoneId (uint32 phaseMask, float x, float y, float z) const

void	GetZoneAndAreaId (uint32 phaseMask, uint32 &zoneid, uint32 &areaid, float x, float y, float z) const

float	GetWaterLevel (float x, float y) const

bool	IsInWater (uint32 phaseMask, float x, float y, float z, float collisionHeight) const

bool	IsUnderWater (uint32 phaseMask, float x, float y, float z, float collisionHeight) const

bool	HasEnoughWater (WorldObject const *searcher, float x, float y, float z) const

bool	HasEnoughWater (WorldObject const *searcher, LiquidData const &liquidData) const

void	MoveAllCreaturesInMoveList ()

void	MoveAllGameObjectsInMoveList ()

void	MoveAllDynamicObjectsInMoveList ()

void	RemoveAllObjectsInRemoveList ()

virtual void	RemoveAllPlayers ()

uint32	GetInstanceId () const

uint8	GetSpawnMode () const

virtual EnterState	CannotEnter (Player *, bool)

const char *	GetMapName () const

Difficulty	GetDifficulty () const

bool	IsRegularDifficulty () const

MapDifficulty const *	GetMapDifficulty () const

bool	Instanceable () const

bool	IsDungeon () const

bool	IsNonRaidDungeon () const

bool	IsRaid () const

bool	IsRaidOrHeroicDungeon () const

bool	IsHeroic () const

bool	Is25ManRaid () const

bool	IsBattleground () const

bool	IsBattleArena () const

bool	IsBattlegroundOrArena () const

bool	IsWorldMap () const

bool	GetEntrancePos (int32 &mapid, float &x, float &y)

void	AddObjectToRemoveList (WorldObject *obj)

virtual void	DelayedUpdate (const uint32 diff)

void	resetMarkedCells ()

bool	isCellMarked (uint32 pCellId)

void	markCell (uint32 pCellId)

bool	HavePlayers () const

uint32	GetPlayersCountExceptGMs () const

void	AddWorldObject (WorldObject *obj)

void	RemoveWorldObject (WorldObject *obj)

void	SendToPlayers (WorldPacket const *data) const

PlayerList const &	GetPlayers () const

void	ScriptsStart (std::map< uint32, std::multimap< uint32, ScriptInfo > > const &scripts, uint32 id, Object source, Object target)
	Put scripts in the execution queue.

void	ScriptCommandStart (ScriptInfo const &script, uint32 delay, Object source, Object target)

template<class T >
void	AddToActive (T *obj)

template<class T >
void	RemoveFromActive (T *obj)

void	UpdateIteratorBack (Player *player)

TempSummon *	SummonCreature (uint32 entry, Position const &pos, SummonPropertiesEntry const properties=nullptr, uint32 duration=0, WorldObject summoner=nullptr, uint32 spellId=0, uint32 vehId=0, bool visibleBySummonerOnly=false)

GameObject *	SummonGameObject (uint32 entry, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime, bool checkTransport=true)

GameObject *	SummonGameObject (uint32 entry, Position const &pos, float rotation0=0.0f, float rotation1=0.0f, float rotation2=0.0f, float rotation3=0.0f, uint32 respawnTime=100, bool checkTransport=true)

void	SummonCreatureGroup (uint8 group, std::list< TempSummon * > *list=nullptr)

Corpse *	GetCorpse (ObjectGuid const guid)

Creature *	GetCreature (ObjectGuid const guid)

GameObject *	GetGameObject (ObjectGuid const guid)

Transport *	GetTransport (ObjectGuid const guid)

DynamicObject *	GetDynamicObject (ObjectGuid const guid)

Pet *	GetPet (ObjectGuid const guid)

MapStoredObjectTypesContainer &	GetObjectsStore ()

CreatureBySpawnIdContainer &	GetCreatureBySpawnIdStore ()

GameObjectBySpawnIdContainer &	GetGameObjectBySpawnIdStore ()

std::unordered_set< Corpse * > const *	GetCorpsesInGrid (uint32 gridId) const

Corpse *	GetCorpseByPlayer (ObjectGuid const &ownerGuid) const

MapInstanced *	ToMapInstanced ()

MapInstanced const *	ToMapInstanced () const

InstanceMap *	ToInstanceMap ()

InstanceMap const *	ToInstanceMap () const

BattlegroundMap *	ToBattlegroundMap ()

BattlegroundMap const *	ToBattlegroundMap () const

float	GetWaterOrGroundLevel (uint32 phasemask, float x, float y, float z, float *ground=nullptr, bool swim=false, float collisionHeight=DEFAULT_COLLISION_HEIGHT) const

float	GetHeight (uint32 phasemask, float x, float y, float z, bool vmap=true, float maxSearchDist=DEFAULT_HEIGHT_SEARCH) const

bool	isInLineOfSight (float x1, float y1, float z1, float x2, float y2, float z2, uint32 phasemask, LineOfSightChecks checks, VMAP::ModelIgnoreFlags ignoreFlags) const

bool	CanReachPositionAndGetValidCoords (WorldObject const source, PathGenerator path, float &destX, float &destY, float &destZ, bool failOnCollision=true, bool failOnSlopes=true) const
	Check if a given source can reach a specific point following a path and normalize the coords. Use this method for long paths, otherwise use the overloaded method with the start coords when you need to do a quick check on small segments.

bool	CanReachPositionAndGetValidCoords (WorldObject const *source, float &destX, float &destY, float &destZ, bool failOnCollision=true, bool failOnSlopes=true) const
	validate the new destination and set reachable coords Check if a given unit can reach a specific point on a segment and set the correct dest coords NOTE: use this method with small segments.

bool	CanReachPositionAndGetValidCoords (WorldObject const *source, float startX, float startY, float startZ, float &destX, float &destY, float &destZ, bool failOnCollision=true, bool failOnSlopes=true) const

bool	CheckCollisionAndGetValidCoords (WorldObject const *source, float startX, float startY, float startZ, float &destX, float &destY, float &destZ, bool failOnCollision=true) const
	validate the new destination and set coords Check if a given unit can face collisions in a specific segment

void	Balance ()

void	RemoveGameObjectModel (const GameObjectModel &model)

void	InsertGameObjectModel (const GameObjectModel &model)

bool	ContainsGameObjectModel (const GameObjectModel &model) const

DynamicMapTree const &	GetDynamicMapTree () const

bool	GetObjectHitPos (uint32 phasemask, float x1, float y1, float z1, float x2, float y2, float z2, float &rx, float &ry, float &rz, float modifyDist)

float	GetGameObjectFloor (uint32 phasemask, float x, float y, float z, float maxSearchDist=DEFAULT_HEIGHT_SEARCH) const

time_t	GetLinkedRespawnTime (ObjectGuid guid) const

time_t	GetCreatureRespawnTime (ObjectGuid::LowType dbGuid) const

time_t	GetGORespawnTime (ObjectGuid::LowType dbGuid) const

void	SaveCreatureRespawnTime (ObjectGuid::LowType dbGuid, time_t &respawnTime)

void	RemoveCreatureRespawnTime (ObjectGuid::LowType dbGuid)

void	SaveGORespawnTime (ObjectGuid::LowType dbGuid, time_t &respawnTime)

void	RemoveGORespawnTime (ObjectGuid::LowType dbGuid)

void	LoadRespawnTimes ()

void	DeleteRespawnTimes ()

time_t	GetInstanceResetPeriod () const

void	UpdatePlayerZoneStats (uint32 oldZone, uint32 newZone)

uint32	ApplyDynamicModeRespawnScaling (WorldObject const *obj, uint32 respawnDelay) const

void	ScheduleCreatureRespawn (ObjectGuid, Milliseconds, Position pos=Position())

void	LoadCorpseData ()

void	DeleteCorpseData ()

void	AddCorpse (Corpse *corpse)

void	RemoveCorpse (Corpse *corpse)

Corpse *	ConvertCorpseToBones (ObjectGuid const ownerGuid, bool insignia=false)

void	RemoveOldCorpses ()

void	SendInitTransports (Player *player)

void	SendRemoveTransports (Player *player)

void	SendZoneDynamicInfo (Player *player)

void	SendInitSelf (Player *player)

void	PlayDirectSoundToMap (uint32 soundId, uint32 zoneId=0)

void	SetZoneMusic (uint32 zoneId, uint32 musicId)

void	SetZoneWeather (uint32 zoneId, WeatherState weatherId, float weatherGrade)

void	SetZoneOverrideLight (uint32 zoneId, uint32 lightId, Milliseconds fadeInTime)

void	UpdateEncounterState (EncounterCreditType type, uint32 creditEntry, Unit *source)

void	LogEncounterFinished (EncounterCreditType type, uint32 creditEntry)

void	DoForAllPlayers (std::function< void(Player *)> exec)

void	EnsureGridCreated (GridCoord const &gridCoord)

bool	AllTransportsEmpty () const

void	AllTransportsRemovePassengers ()

TransportsContainer const &	GetAllTransports () const

template<HighGuid high>
ObjectGuid::LowType	GenerateLowGuid ()

void	AddUpdateObject (Object *obj)

void	RemoveUpdateObject (Object *obj)

std::size_t	GetActiveNonPlayersCount () const

virtual std::string	GetDebugInfo () const

uint32	GetCreatedGridsCount ()

uint32	GetLoadedGridsCount ()

uint32	GetCreatedCellsInGridCount (uint16 const x, uint16 const y)

uint32	GetCreatedCellsInMapCount ()

void	AddObjectToPendingUpdateList (WorldObject *obj)

void	RemoveObjectFromMapUpdateList (WorldObject *obj)

template<>
void	AddToGrid (Creature *obj, Cell const &cell)

template<>
void	AddToGrid (GameObject *obj, Cell const &cell)

template<>
void	AddToGrid (DynamicObject *obj, Cell const &cell)

template<>
void	AddToGrid (Corpse *obj, Cell const &cell)

template<>
void	DeleteFromWorld (Player *player)

template<>
void	InitializeObject (Creature *)

template<>
void	InitializeObject (GameObject *)

template<>
bool	AddToMap (MotionTransport *obj, bool)

template<>
void	RemoveFromMap (MotionTransport *obj, bool remove)

template<>
void	AddToActive (Creature *c)

template<>
void	AddToActive (DynamicObject *d)

template<>
void	AddToActive (GameObject *d)

template<>
void	AddToActive (Corpse *)

template<>
void	RemoveFromActive (Creature *c)

template<>
void	RemoveFromActive (DynamicObject *obj)

template<>
void	RemoveFromActive (GameObject *obj)

Public Member Functions inherited from GridRefMgr< MapGridType >
GridReference< MapGridType > *	getFirst ()

GridReference< MapGridType > *	getLast ()

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

Public Member Functions inherited from RefMgr< TO, FROM >
	RefMgr ()=default

virtual	~RefMgr ()

Reference< TO, FROM > *	getFirst ()

Reference< TO, FROM > const *	getFirst () const

Reference< TO, FROM > *	getLast ()

Reference< TO, FROM > const *	getLast () const

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

void	clearReferences ()

Public Member Functions inherited from LinkedListHead
	LinkedListHead ()

bool	IsEmpty () const

LinkedListElement *	getFirst ()

LinkedListElement const *	getFirst () const

LinkedListElement *	getLast ()

LinkedListElement const *	getLast () const

void	insertFirst (LinkedListElement *pElem)

void	insertLast (LinkedListElement *pElem)

uint32	getSize () const

void	incSize ()

void	decSize ()

Static Public Member Functions
static void	DeleteRespawnTimesInDB (uint16 mapId, uint32 instanceId)

Public Attributes
std::unordered_set< Unit * >	i_objectsForDelayedVisibility

CreatureGroupHolderType	CreatureGroupHolder

TaskScheduler	_creatureRespawnScheduler

DataMap	CustomData

Protected Types
typedef std::set< WorldObject * >	ActiveNonPlayers

Protected Member Functions
template<class T >
void	AddToGrid (T *object, Cell const &cell)

Protected Attributes
std::mutex	Lock

std::shared_mutex	MMapLock

MapGridManager	_mapGridManager

MapEntry const *	i_mapEntry

uint8	i_spawnMode

uint32	i_InstanceId

uint32	m_unloadTimer

float	m_VisibleDistance

DynamicMapTree	_dynamicTree

time_t	_instanceResetPeriod

MapRefMgr	m_mapRefMgr

MapRefMgr::iterator	m_mapRefIter

ActiveNonPlayers	m_activeNonPlayers

ActiveNonPlayers::iterator	m_activeNonPlayersIter

TransportsContainer	_transports

TransportsContainer::iterator	_transportsUpdateIter

Private Types
typedef std::multimap< time_t, ScriptAction >	ScriptScheduleMap

Private Member Functions
template<class T >
void	InitializeObject (T *obj)

void	AddCreatureToMoveList (Creature *c)

void	RemoveCreatureFromMoveList (Creature *c)

void	AddGameObjectToMoveList (GameObject *go)

void	RemoveGameObjectFromMoveList (GameObject *go)

void	AddDynamicObjectToMoveList (DynamicObject *go)

void	RemoveDynamicObjectFromMoveList (DynamicObject *go)

bool	EnsureGridLoaded (Cell const &cell)

MapGridType *	GetMapGrid (uint16 const x, uint16 const y)

void	ScriptsProcess ()
	Process queued scripts.

void	SendObjectUpdates ()

Player *	_GetScriptPlayerSourceOrTarget (Object source, Object target, const ScriptInfo *scriptInfo) const

Creature *	_GetScriptCreatureSourceOrTarget (Object source, Object target, const ScriptInfo *scriptInfo, bool bReverse=false) const

Unit *	_GetScriptUnit (Object obj, bool isSource, const ScriptInfo scriptInfo) const

Player *	_GetScriptPlayer (Object obj, bool isSource, const ScriptInfo scriptInfo) const

Creature *	_GetScriptCreature (Object obj, bool isSource, const ScriptInfo scriptInfo) const

WorldObject *	_GetScriptWorldObject (Object obj, bool isSource, const ScriptInfo scriptInfo) const

void	_ScriptProcessDoor (Object source, Object target, const ScriptInfo *scriptInfo) const

GameObject *	_FindGameObject (WorldObject *pWorldObject, ObjectGuid::LowType guid) const

template<class T >
void	DeleteFromWorld (T *)

void	AddToActiveHelper (WorldObject *obj)

void	RemoveFromActiveHelper (WorldObject *obj)

void	UpdateNonPlayerObjects (uint32 const diff)

void	_AddObjectToUpdateList (WorldObject *obj)

void	_RemoveObjectFromUpdateList (WorldObject *obj)

template<HighGuid high>
ObjectGuidGeneratorBase &	GetGuidSequenceGenerator ()

Private Attributes
std::vector< Creature * >	_creaturesToMove

std::vector< GameObject * >	_gameObjectsToMove

std::vector< DynamicObject * >	_dynamicObjectsToMove

Map *	m_parentMap

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP >	marked_cells

bool	i_scriptLock

std::unordered_set< WorldObject * >	i_objectsToRemove

std::unordered_set< WorldObject * >	i_worldObjects

ScriptScheduleMap	m_scriptSchedule

std::unordered_map< ObjectGuid::LowType, time_t >	_creatureRespawnTimes

std::unordered_map< ObjectGuid::LowType, time_t >	_goRespawnTimes

std::unordered_map< uint32, uint32 >	_zonePlayerCountMap

ZoneDynamicInfoMap	_zoneDynamicInfo

uint32	_defaultLight

std::map< HighGuid, std::unique_ptr< ObjectGuidGeneratorBase > >	_guidGenerators

MapStoredObjectTypesContainer	_objectsStore

CreatureBySpawnIdContainer	_creatureBySpawnIdStore

GameObjectBySpawnIdContainer	_gameobjectBySpawnIdStore

std::unordered_map< uint32, std::unordered_set< Corpse * > >	_corpsesByGrid

std::unordered_map< ObjectGuid, Corpse * >	_corpsesByPlayer

std::unordered_set< Corpse * >	_corpseBones

std::unordered_set< Object * >	_updateObjects

UpdatableObjectList	_updatableObjectList

PendingAddUpdatableObjectList	_pendingAddUpdatableObjectList

IntervalTimer	_updatableObjectListRecheckTimer

Friends
class	MapReference

class	GridObjectLoader

Detailed Description

Member Typedef Documentation

◆ ActiveNonPlayers

typedef std::set<WorldObject*> Map::ActiveNonPlayers

protected

◆ CreatureBySpawnIdContainer

typedef std::unordered_multimap<ObjectGuid::LowType, Creature*> Map::CreatureBySpawnIdContainer

◆ GameObjectBySpawnIdContainer

typedef std::unordered_multimap<ObjectGuid::LowType, GameObject*> Map::GameObjectBySpawnIdContainer

◆ PendingAddUpdatableObjectList

typedef std::unordered_set<WorldObject*> Map::PendingAddUpdatableObjectList

◆ PlayerList

typedef MapRefMgr Map::PlayerList

◆ ScriptScheduleMap

typedef std::multimap<time_t, ScriptAction> Map::ScriptScheduleMap

private

◆ UpdatableObjectList

typedef std::vector<WorldObject*> Map::UpdatableObjectList

Member Enumeration Documentation

◆ EnterState

enum Map::EnterState

Enumerator
CAN_ENTER
CANNOT_ENTER_ALREADY_IN_MAP
CANNOT_ENTER_NO_ENTRY
CANNOT_ENTER_UNINSTANCED_DUNGEON
CANNOT_ENTER_DIFFICULTY_UNAVAILABLE
CANNOT_ENTER_NOT_IN_RAID
CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE
CANNOT_ENTER_INSTANCE_BIND_MISMATCH
CANNOT_ENTER_TOO_MANY_INSTANCES
CANNOT_ENTER_MAX_PLAYERS
CANNOT_ENTER_ZONE_IN_COMBAT
CANNOT_ENTER_UNSPECIFIED_REASON

    {
        CAN_ENTER = 0,
        CANNOT_ENTER_ALREADY_IN_MAP = 1, // Player is already in the map
        CANNOT_ENTER_NO_ENTRY, // No map entry was found for the target map ID
        CANNOT_ENTER_UNINSTANCED_DUNGEON, // No instance template was found for dungeon map
        CANNOT_ENTER_DIFFICULTY_UNAVAILABLE, // Requested instance difficulty is not available for target map
        CANNOT_ENTER_NOT_IN_RAID, // Target instance is a raid instance and the player is not in a raid group
        CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE, // Player is dead and their corpse is not in target instance
        CANNOT_ENTER_INSTANCE_BIND_MISMATCH, // Player's permanent instance save is not compatible with their group's current instance bind
        CANNOT_ENTER_TOO_MANY_INSTANCES, // Player has entered too many instances recently
        CANNOT_ENTER_MAX_PLAYERS, // Target map already has the maximum number of players allowed
        CANNOT_ENTER_ZONE_IN_COMBAT, // A boss encounter is currently in progress on the target map
        CANNOT_ENTER_UNSPECIFIED_REASON
    };

Constructor & Destructor Documentation

◆ Map()

Map::Map	(	uint32	id,
		uint32	InstanceId,
		uint8	SpawnMode,
		Map *	_parent = `nullptr`
	)

                                                                    :
    _mapGridManager(this), i_mapEntry(sMapStore.LookupEntry(id)), i_spawnMode(SpawnMode), i_InstanceId(InstanceId),
    m_unloadTimer(0), m_VisibleDistance(DEFAULT_VISIBILITY_DISTANCE),
    _instanceResetPeriod(0), m_activeNonPlayersIter(m_activeNonPlayers.end()),
    _transportsUpdateIter(_transports.end()), i_scriptLock(false), _defaultLight(GetDefaultMapLight(id))
{
    m_parentMap = (_parent ? _parent : this);
 
    _zonePlayerCountMap.clear();
    _updatableObjectListRecheckTimer.SetInterval(UPDATABLE_OBJECT_LIST_RECHECK_TIMER);
 
    //lets initialize visibility distance for map
    Map::InitVisibilityDistance();
}

References _updatableObjectListRecheckTimer, _zonePlayerCountMap, InitVisibilityDistance(), m_parentMap, IntervalTimer::SetInterval(), and UPDATABLE_OBJECT_LIST_RECHECK_TIMER.

◆ ~Map()

Map::~Map ( )

override

{
    // UnloadAll must be called before deleting the map
 
    sScriptMgr->OnDestroyMap(this);
 
    while (!i_worldObjects.empty())
    {
        WorldObject* obj = *i_worldObjects.begin();
        ASSERT(obj->IsWorldObject());
        LOG_DEBUG("maps", "Map::~Map: WorldObject TypeId is not a corpse! ({})", static_cast<uint8>(obj->GetTypeId()));
        //ASSERT(obj->IsCorpse());
        obj->RemoveFromWorld();
        obj->ResetMap();
    }
 
    if (!m_scriptSchedule.empty())
        sScriptMgr->DecreaseScheduledScriptCount(m_scriptSchedule.size());
 
    MMAP::MMapFactory::createOrGetMMapMgr()->unloadMapInstance(GetId(), i_InstanceId);
}

References ASSERT, MMAP::MMapFactory::createOrGetMMapMgr(), GetId(), Object::GetTypeId(), i_InstanceId, i_worldObjects, WorldObject::IsWorldObject(), LOG_DEBUG, m_scriptSchedule, WorldObject::RemoveFromWorld(), WorldObject::ResetMap(), sScriptMgr, and MMAP::MMapMgr::unloadMapInstance().

Member Function Documentation

◆ _AddObjectToUpdateList()

void Map::_AddObjectToUpdateList ( WorldObject * obj )

private

{
    UpdatableMapObject* mapUpdatableObject = dynamic_cast<UpdatableMapObject*>(obj);
    ASSERT(mapUpdatableObject && mapUpdatableObject->GetUpdateState() == UpdatableMapObject::UpdateState::PendingAdd);
 
    mapUpdatableObject->SetUpdateState(UpdatableMapObject::UpdateState::Updating);
    mapUpdatableObject->SetMapUpdateListOffset(_updatableObjectList.size());
    _updatableObjectList.push_back(obj);
}

References _updatableObjectList, ASSERT, UpdatableMapObject::GetUpdateState(), UpdatableMapObject::PendingAdd, UpdatableMapObject::SetMapUpdateListOffset(), UpdatableMapObject::SetUpdateState(), and UpdatableMapObject::Updating.

Referenced by UpdateNonPlayerObjects().

◆ _FindGameObject()

GameObject * Map::_FindGameObject	(	WorldObject *	pWorldObject,
		ObjectGuid::LowType	guid
	)		const

inlineprivate

{
    auto bounds = searchObject->GetMap()->GetGameObjectBySpawnIdStore().equal_range(guid);
    if (bounds.first == bounds.second)
        return nullptr;
 
    return bounds.first->second;
}

References GetGameObjectBySpawnIdStore(), and WorldObject::GetMap().

Referenced by _ScriptProcessDoor(), and ScriptsProcess().

◆ _GetScriptCreature()

Creature * Map::_GetScriptCreature	(	Object *	obj,
		bool	isSource,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    Creature* creature = nullptr;
    if (!obj)
        LOG_ERROR("maps.script", "{} {} object is nullptr.", scriptInfo->GetDebugInfo(), isSource ? "source" : "target");
    else
    {
        creature = obj->ToCreature();
        if (!creature)
            LOG_ERROR("maps.script", "{} {} object is not a creature ({}).", scriptInfo->GetDebugInfo(),
                           isSource ? "source" : "target", obj->GetGUID().ToString());
    }
    return creature;
}

References ScriptInfo::GetDebugInfo(), Object::GetGUID(), LOG_ERROR, Object::ToCreature(), and ObjectGuid::ToString().

Referenced by ScriptsProcess().

◆ _GetScriptCreatureSourceOrTarget()

Creature * Map::_GetScriptCreatureSourceOrTarget	(	Object *	source,
		Object *	target,
		const ScriptInfo *	scriptInfo,
		bool	bReverse = `false`
	)		const

inlineprivate

{
    Creature* creature = nullptr;
    if (!source && !target)
        LOG_ERROR("maps.script", "{} source and target objects are nullptr.", scriptInfo->GetDebugInfo());
    else
    {
        if (bReverse)
        {
            // Check target first, then source.
            if (target)
                creature = target->ToCreature();
            if (!creature && source)
                creature = source->ToCreature();
        }
        else
        {
            // Check source first, then target.
            if (source)
                creature = source->ToCreature();
            if (!creature && target)
                creature = target->ToCreature();
        }
 
        if (!creature)
            LOG_ERROR("maps.script", "{} neither source nor target are creatures (source: TypeId: {}, Entry: {}, GUID: {}; target: TypeId: {}, Entry: {}, GUID: {}), skipping.",
                           scriptInfo->GetDebugInfo(),
                           source ? source->GetTypeId() : 0, source ? source->GetEntry() : 0, source ? source->GetGUID().ToString() : "",
                           target ? target->GetTypeId() : 0, target ? target->GetEntry() : 0, target ? target->GetGUID().ToString() : "");
    }
    return creature;
}

References ScriptInfo::GetDebugInfo(), Object::GetEntry(), Object::GetGUID(), Object::GetTypeId(), LOG_ERROR, Object::ToCreature(), and ObjectGuid::ToString().

Referenced by ScriptsProcess().

◆ _GetScriptPlayer()

Player * Map::_GetScriptPlayer	(	Object *	obj,
		bool	isSource,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    Player* player = nullptr;
    if (!obj)
        LOG_ERROR("maps.script", "{} {} object is nullptr.", scriptInfo->GetDebugInfo(), isSource ? "source" : "target");
    else
    {
        player = obj->ToPlayer();
        if (!player)
            LOG_ERROR("maps.script", "{} {} object is not a player ({}).",
                           scriptInfo->GetDebugInfo(), isSource ? "source" : "target", obj->GetGUID().ToString());
    }
    return player;
}

References ScriptInfo::GetDebugInfo(), Object::GetGUID(), LOG_ERROR, Object::ToPlayer(), and ObjectGuid::ToString().

Referenced by ScriptsProcess().

◆ _GetScriptPlayerSourceOrTarget()

Player * Map::_GetScriptPlayerSourceOrTarget	(	Object *	source,
		Object *	target,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    Player* player = nullptr;
    if (!source && !target)
        LOG_ERROR("maps.script", "{} source and target objects are nullptr.", scriptInfo->GetDebugInfo());
    else
    {
        // Check target first, then source.
        if (target)
            player = target->ToPlayer();
        if (!player && source)
            player = source->ToPlayer();
 
        if (!player)
            LOG_ERROR("maps.script", "{} neither source nor target object is player (source: TypeId: {}, Entry: {}, GUID: {}; target: TypeId: {}, Entry: {}, GUID: {}), skipping.",
                           scriptInfo->GetDebugInfo(),
                           source ? source->GetTypeId() : 0, source ? source->GetEntry() : 0, source ? source->GetGUID().ToString() : "",
                           target ? target->GetTypeId() : 0, target ? target->GetEntry() : 0, target ? target->GetGUID().ToString() : "");
    }
    return player;
}

References ScriptInfo::GetDebugInfo(), Object::GetEntry(), Object::GetGUID(), Object::GetTypeId(), LOG_ERROR, Object::ToPlayer(), and ObjectGuid::ToString().

Referenced by ScriptsProcess().

◆ _GetScriptUnit()

Unit * Map::_GetScriptUnit	(	Object *	obj,
		bool	isSource,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    Unit* unit = nullptr;
    if (!obj)
        LOG_ERROR("maps.script", "{} {} object is nullptr.", scriptInfo->GetDebugInfo(), isSource ? "source" : "target");
    else if (!obj->IsUnit())
        LOG_ERROR("maps.script", "{} {} object is not unit (TypeId: {}, Entry: {}, GUID: {}), skipping.",
                       scriptInfo->GetDebugInfo(), isSource ? "source" : "target", obj->GetTypeId(), obj->GetEntry(), obj->GetGUID().ToString());
    else
    {
        unit = obj->ToUnit();
        if (!unit)
            LOG_ERROR("maps.script", "{} {} object could not be casted to unit.",
                           scriptInfo->GetDebugInfo(), isSource ? "source" : "target");
    }
    return unit;
}

References ScriptInfo::GetDebugInfo(), Object::GetEntry(), Object::GetGUID(), Object::GetTypeId(), Object::IsUnit(), LOG_ERROR, ObjectGuid::ToString(), and Object::ToUnit().

Referenced by ScriptsProcess().

◆ _GetScriptWorldObject()

WorldObject * Map::_GetScriptWorldObject	(	Object *	obj,
		bool	isSource,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    WorldObject* pWorldObject = nullptr;
    if (!obj)
        LOG_ERROR("maps.script", "{} {} object is nullptr.",
                       scriptInfo->GetDebugInfo(), isSource ? "source" : "target");
    else
    {
        pWorldObject = dynamic_cast<WorldObject*>(obj);
        if (!pWorldObject)
            LOG_ERROR("maps.script", "{} {} object is not a world object ({}).",
                           scriptInfo->GetDebugInfo(), isSource ? "source" : "target", obj->GetGUID().ToString());
    }
    return pWorldObject;
}

References ScriptInfo::GetDebugInfo(), Object::GetGUID(), LOG_ERROR, and ObjectGuid::ToString().

Referenced by ScriptsProcess().

◆ _RemoveObjectFromUpdateList()

void Map::_RemoveObjectFromUpdateList ( WorldObject * obj )

private

{
    UpdatableMapObject* mapUpdatableObject = dynamic_cast<UpdatableMapObject*>(obj);
    ASSERT(mapUpdatableObject && mapUpdatableObject->GetUpdateState() == UpdatableMapObject::UpdateState::Updating);
 
    if (obj != _updatableObjectList.back())
    {
        dynamic_cast<UpdatableMapObject*>(_updatableObjectList.back())->SetMapUpdateListOffset(mapUpdatableObject->GetMapUpdateListOffset());
        std::swap(_updatableObjectList[mapUpdatableObject->GetMapUpdateListOffset()], _updatableObjectList.back());
    }
 
    _updatableObjectList.pop_back();
    mapUpdatableObject->SetUpdateState(UpdatableMapObject::UpdateState::NotUpdating);
}

References _updatableObjectList, ASSERT, UpdatableMapObject::GetMapUpdateListOffset(), UpdatableMapObject::GetUpdateState(), UpdatableMapObject::NotUpdating, UpdatableMapObject::SetUpdateState(), and UpdatableMapObject::Updating.

Referenced by RemoveObjectFromMapUpdateList(), and UpdateNonPlayerObjects().

◆ _ScriptProcessDoor()

void Map::_ScriptProcessDoor	(	Object *	source,
		Object *	target,
		const ScriptInfo *	scriptInfo
	)		const

inlineprivate

{
    bool bOpen = false;
    ObjectGuid::LowType guid = scriptInfo->ToggleDoor.GOGuid;
    int32 nTimeToToggle = std::max(15, int32(scriptInfo->ToggleDoor.ResetDelay));
    switch (scriptInfo->command)
    {
        case SCRIPT_COMMAND_OPEN_DOOR:
            bOpen = true;
            break;
        case SCRIPT_COMMAND_CLOSE_DOOR:
            break;
        default:
            LOG_ERROR("maps.script", "{} unknown command for _ScriptProcessDoor.", scriptInfo->GetDebugInfo());
            return;
    }
    if (!guid)
        LOG_ERROR("maps.script", "{} door guid is not specified.", scriptInfo->GetDebugInfo());
    else if (!source)
        LOG_ERROR("maps.script", "{} source object is nullptr.", scriptInfo->GetDebugInfo());
    else if (!source->IsUnit())
        LOG_ERROR("maps.script", "{} source object is not unit ({}), skipping.", scriptInfo->GetDebugInfo(), source->GetGUID().ToString());
    else
    {
        WorldObject* wSource = dynamic_cast <WorldObject*> (source);
        if (!wSource)
            LOG_ERROR("maps.script", "{} source object could not be casted to world object ({}), skipping.", scriptInfo->GetDebugInfo(), source->GetGUID().ToString());
        else
        {
            GameObject* pDoor = _FindGameObject(wSource, guid);
            if (!pDoor)
                LOG_ERROR("maps.script", "{} gameobject was not found (guid: {}).", scriptInfo->GetDebugInfo(), guid);
            else if (pDoor->GetGoType() != GAMEOBJECT_TYPE_DOOR)
                LOG_ERROR("maps.script", "{} gameobject is not a door ({}).",
                               scriptInfo->GetDebugInfo(), pDoor->GetGUID().ToString());
            else if (bOpen == (pDoor->GetGoState() == GO_STATE_READY))
            {
                pDoor->UseDoorOrButton(nTimeToToggle);
 
                if (target && target->isType(TYPEMASK_GAMEOBJECT))
                {
                    GameObject* goTarget = target->ToGameObject();
                    if (goTarget && goTarget->GetGoType() == GAMEOBJECT_TYPE_BUTTON)
                        goTarget->UseDoorOrButton(nTimeToToggle);
                }
            }
        }
    }
}

References _FindGameObject(), ScriptInfo::command, GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_DOOR, ScriptInfo::GetDebugInfo(), GameObject::GetGoState(), GameObject::GetGoType(), Object::GetGUID(), GO_STATE_READY, ScriptInfo::GOGuid, Object::isType(), Object::IsUnit(), LOG_ERROR, ScriptInfo::ResetDelay, SCRIPT_COMMAND_CLOSE_DOOR, SCRIPT_COMMAND_OPEN_DOOR, Object::ToGameObject(), ScriptInfo::ToggleDoor, ObjectGuid::ToString(), TYPEMASK_GAMEOBJECT, and GameObject::UseDoorOrButton().

Referenced by ScriptsProcess().

◆ AddCorpse()

void Map::AddCorpse ( Corpse * corpse )

{
    corpse->SetMap(this);
 
    GridCoord const gridCoord = Acore::ComputeGridCoord(corpse->GetPositionX(), corpse->GetPositionY());
    _corpsesByGrid[gridCoord.GetId()].insert(corpse);
    if (corpse->GetType() != CORPSE_BONES)
        _corpsesByPlayer[corpse->GetOwnerGUID()] = corpse;
    else
        _corpseBones.insert(corpse);
}

References _corpseBones, _corpsesByGrid, _corpsesByPlayer, Acore::ComputeGridCoord(), CORPSE_BONES, CoordPair< LIMIT >::GetId(), Corpse::GetOwnerGUID(), Position::GetPositionX(), Position::GetPositionY(), Corpse::GetType(), and WorldObject::SetMap().

Referenced by ConvertCorpseToBones(), Player::CreateCorpse(), and LoadCorpseData().

◆ AddCreatureToMoveList()

void Map::AddCreatureToMoveList ( Creature * c )

private

{
    if (c->_moveState == MAP_OBJECT_CELL_MOVE_NONE)
        _creaturesToMove.push_back(c);
    c->_moveState = MAP_OBJECT_CELL_MOVE_ACTIVE;
}

References _creaturesToMove, MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_NONE.

Referenced by CreatureRelocation().

◆ AddDynamicObjectToMoveList()

void Map::AddDynamicObjectToMoveList ( DynamicObject * go )

private

{
    if (dynObj->_moveState == MAP_OBJECT_CELL_MOVE_NONE)
        _dynamicObjectsToMove.push_back(dynObj);
    dynObj->_moveState = MAP_OBJECT_CELL_MOVE_ACTIVE;
}

References _dynamicObjectsToMove, MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_NONE.

Referenced by DynamicObjectRelocation().

◆ AddGameObjectToMoveList()

void Map::AddGameObjectToMoveList ( GameObject * go )

private

{
    if (go->_moveState == MAP_OBJECT_CELL_MOVE_NONE)
        _gameObjectsToMove.push_back(go);
    go->_moveState = MAP_OBJECT_CELL_MOVE_ACTIVE;
}

References _gameObjectsToMove, MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_NONE.

Referenced by GameObjectRelocation().

◆ AddObjectToPendingUpdateList()

void Map::AddObjectToPendingUpdateList ( WorldObject * obj )

{
    if (!obj->CanBeAddedToMapUpdateList())
        return;
 
    UpdatableMapObject* mapUpdatableObject = dynamic_cast<UpdatableMapObject*>(obj);
    if (mapUpdatableObject->GetUpdateState() != UpdatableMapObject::UpdateState::NotUpdating)
        return;
 
    _pendingAddUpdatableObjectList.insert(obj);
    mapUpdatableObject->SetUpdateState(UpdatableMapObject::UpdateState::PendingAdd);
}

References _pendingAddUpdatableObjectList, WorldObject::CanBeAddedToMapUpdateList(), UpdatableMapObject::GetUpdateState(), UpdatableMapObject::NotUpdating, UpdatableMapObject::PendingAdd, and UpdatableMapObject::SetUpdateState().

Referenced by WorldObject::AddToWorld(), and Player::UpdateVisibilityOf().

◆ AddObjectToRemoveList()

void Map::AddObjectToRemoveList ( WorldObject * obj )

{
    ASSERT(obj->GetMapId() == GetId() && obj->GetInstanceId() == GetInstanceId());
 
    obj->CleanupsBeforeDelete(false);                            // remove or simplify at least cross referenced links
 
    i_objectsToRemove.insert(obj);
    //LOG_DEBUG("maps", "Object ({}) added to removing list.", obj->GetGUID().ToString());
}

References ASSERT, WorldObject::CleanupsBeforeDelete(), GetId(), WorldObject::GetInstanceId(), GetInstanceId(), WorldLocation::GetMapId(), and i_objectsToRemove.

Referenced by WorldObject::AddObjectToRemoveList(), and wp_commandscript::HandleWpModifyCommand().

◆ AddPlayerToMap()

bool Map::AddPlayerToMap ( Player * player )

virtual

Reimplemented in InstanceMap, and BattlegroundMap.

{
    CellCoord cellCoord = Acore::ComputeCellCoord(player->GetPositionX(), player->GetPositionY());
    if (!cellCoord.IsCoordValid())
    {
        LOG_ERROR("maps", "Map::Add: Player ({}) has invalid coordinates X:{} Y:{} grid cell [{}:{}]",
            player->GetGUID().ToString(), player->GetPositionX(), player->GetPositionY(), cellCoord.x_coord, cellCoord.y_coord);
        return false;
    }
 
    Cell cell(cellCoord);
    LoadGridsInRange(*player, MAX_VISIBILITY_DISTANCE);
    AddToGrid(player, cell);
 
    // Check if we are adding to correct map
    ASSERT (player->GetMap() == this);
    player->SetMap(this);
    player->AddToWorld();
 
    SendInitTransports(player);
    SendInitSelf(player);
    SendZoneDynamicInfo(player);
 
    player->m_clientGUIDs.clear();
    player->UpdateObjectVisibility(false);
 
    if (player->IsAlive())
        ConvertCorpseToBones(player->GetGUID());
 
    sScriptMgr->OnPlayerEnterMap(this, player);
    return true;
}

References AddToGrid(), Player::AddToWorld(), ASSERT, Acore::ComputeCellCoord(), ConvertCorpseToBones(), Object::GetGUID(), WorldObject::GetMap(), Position::GetPositionX(), Position::GetPositionY(), Unit::IsAlive(), CoordPair< LIMIT >::IsCoordValid(), LoadGridsInRange(), LOG_ERROR, Player::m_clientGUIDs, MAX_VISIBILITY_DISTANCE, SendInitSelf(), SendInitTransports(), SendZoneDynamicInfo(), Player::SetMap(), sScriptMgr, ObjectGuid::ToString(), Player::UpdateObjectVisibility(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by InstanceMap::AddPlayerToMap(), BattlegroundMap::AddPlayerToMap(), and WorldSession::HandlePlayerLoginFromDB().

◆ AddToActive() [1/5]

template<>

void Map::AddToActive ( Corpse * )

{
    // do nothing for corpses
}

◆ AddToActive() [2/5]

template<>

void Map::AddToActive ( Creature * c )

{
    AddToActiveHelper(c);
}

References AddToActiveHelper().

◆ AddToActive() [3/5]

template<>

void Map::AddToActive ( DynamicObject * d )

{
    AddToActiveHelper(d);
}

References AddToActiveHelper().

◆ AddToActive() [4/5]

template<>

void Map::AddToActive ( GameObject * d )

{
    AddToActiveHelper(d);
}

References AddToActiveHelper().

◆ AddToActive() [5/5]

template<class T >

void Map::AddToActive ( T * obj )

{
    AddToActiveHelper(obj);
}

References AddToActiveHelper().

Referenced by GridObjectLoader::AddObjectHelper(), AddToMap(), AddToMap(), and WorldObject::setActive().

◆ AddToActiveHelper()

void Map::AddToActiveHelper ( WorldObject * obj )

inlineprivate

    {
        m_activeNonPlayers.insert(obj);
    }

References m_activeNonPlayers.

Referenced by AddToActive(), AddToActive(), AddToActive(), and AddToActive().

◆ AddToGrid() [1/5]

template<>

void Map::AddToGrid	(	Corpse *	obj,
		Cell const &	cell
	)

{
    MapGridType* grid = GetMapGrid(cell.GridX(), cell.GridY());
    // Corpses are a special object type - they can be added to grid via a call to AddToMap
    // or loaded through ObjectGridLoader.
    // Both corpses loaded from database and these freshly generated by Player::CreateCoprse are added to _corpsesByCell
    // ObjectGridLoader loads all corpses from _corpsesByCell even if they were already added to grid before it was loaded
    // so we need to explicitly check it here (Map::AddToGrid is only called from Player::BuildPlayerRepop, not from ObjectGridLoader)
    // to avoid failing an assertion in GridObject::AddToGrid
    if (grid->IsObjectDataLoaded())
    {
        if (obj->IsWorldObject())
            grid->AddWorldObject(cell.CellX(), cell.CellY(), obj);
        else
            grid->AddGridObject(cell.CellX(), cell.CellY(), obj);
    }
}

References MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::IsObjectDataLoaded(), and WorldObject::IsWorldObject().

◆ AddToGrid() [2/5]

template<>

void Map::AddToGrid	(	Creature *	obj,
		Cell const &	cell
	)

{
    MapGridType* grid = GetMapGrid(cell.GridX(), cell.GridY());
    if (obj->IsWorldObject())
        grid->AddWorldObject(cell.CellX(), cell.CellY(), obj);
    else
        grid->AddGridObject(cell.CellX(), cell.CellY(), obj);
 
    obj->SetCurrentCell(cell);
}

References MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), WorldObject::IsWorldObject(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [3/5]

template<>

void Map::AddToGrid	(	DynamicObject *	obj,
		Cell const &	cell
	)

{
    MapGridType* grid = GetMapGrid(cell.GridX(), cell.GridY());
    if (obj->IsWorldObject())
        grid->AddWorldObject(cell.CellX(), cell.CellY(), obj);
    else
        grid->AddGridObject(cell.CellX(), cell.CellY(), obj);
 
    obj->SetCurrentCell(cell);
}

References MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), WorldObject::IsWorldObject(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [4/5]

template<>

void Map::AddToGrid	(	GameObject *	obj,
		Cell const &	cell
	)

{
    MapGridType* grid = GetMapGrid(cell.GridX(), cell.GridY());
    grid->AddGridObject(cell.CellX(), cell.CellY(), obj);
 
    obj->SetCurrentCell(cell);
}

References MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [5/5]

template<class T >

void Map::AddToGrid	(	T *	object,
		Cell const &	cell
	)

protected

{
    MapGridType* grid = GetMapGrid(cell.GridX(), cell.GridY());
    if (obj->IsWorldObject())
        grid->AddWorldObject<T>(cell.CellX(), cell.CellY(), obj);
    else
        grid->AddGridObject<T>(cell.CellX(), cell.CellY(), obj);
}

References MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), and Cell::GridY().

Referenced by GridObjectLoader::AddObjectHelper(), AddPlayerToMap(), AddToMap(), MoveAllCreaturesInMoveList(), MoveAllDynamicObjectsInMoveList(), MoveAllGameObjectsInMoveList(), and PlayerRelocation().

◆ AddToMap() [1/2]

template<>

bool Map::AddToMap	(	MotionTransport *	obj,
		bool
	)

{
    //TODO: Needs clean up. An object should not be added to map twice.
    if (obj->IsInWorld())
        return true;
 
    CellCoord cellCoord = Acore::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
    if (!cellCoord.IsCoordValid())
    {
        LOG_ERROR("maps", "Map::Add: Object {} has invalid coordinates X:{} Y:{} grid cell [{}:{}]",
            obj->GetGUID().ToString(), obj->GetPositionX(), obj->GetPositionY(), cellCoord.x_coord, cellCoord.y_coord);
        return false; //Should delete object
    }
 
    Cell cell(cellCoord);
    if (obj->isActiveObject())
        EnsureGridLoaded(cell);
 
    obj->AddToWorld();
 
    if (obj->isActiveObject())
        AddToActive(obj);
 
    _transports.insert(obj);
 
    // Broadcast creation to players
    if (!GetPlayers().IsEmpty())
    {
        for (Map::PlayerList::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
        {
            if (itr->GetSource()->GetTransport() != obj)
            {
                UpdateData data;
                obj->BuildCreateUpdateBlockForPlayer(&data, itr->GetSource());
                WorldPacket packet;
                data.BuildPacket(packet);
                itr->GetSource()->SendDirectMessage(&packet);
            }
        }
    }
 
    return true;
}

References _transports, AddToActive(), GameObject::AddToWorld(), GridRefMgr< MapGridType >::begin(), Object::BuildCreateUpdateBlockForPlayer(), UpdateData::BuildPacket(), Acore::ComputeCellCoord(), MapRefMgr::end(), EnsureGridLoaded(), Object::GetGUID(), GetPlayers(), Position::GetPositionX(), Position::GetPositionY(), WorldObject::isActiveObject(), CoordPair< LIMIT >::IsCoordValid(), LinkedListHead::IsEmpty(), Object::IsInWorld(), LOG_ERROR, ObjectGuid::ToString(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

◆ AddToMap() [2/2]

template<class T >

bool Map::AddToMap	(	T *	obj,
		bool	checkTransport = `false`
	)

{
    //TODO: Needs clean up. An object should not be added to map twice.
    if (obj->IsInWorld())
    {
        ASSERT(obj->IsInGrid());
        obj->UpdateObjectVisibilityOnCreate();
        return true;
    }
 
    CellCoord cellCoord = Acore::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
    //It will create many problems (including crashes) if an object is not added to grid after creation
    //The correct way to fix it is to make AddToMap return false and delete the object if it is not added to grid
    //But now AddToMap is used in too many places, I will just see how many ASSERT failures it will cause
    ASSERT(cellCoord.IsCoordValid());
    if (!cellCoord.IsCoordValid())
    {
        LOG_ERROR("maps", "Map::AddToMap: Object {} has invalid coordinates X:{} Y:{} grid cell [{}:{}]",
            obj->GetGUID().ToString(), obj->GetPositionX(), obj->GetPositionY(), cellCoord.x_coord, cellCoord.y_coord);
        return false; //Should delete object
    }
 
    Cell cell(cellCoord);
    if (obj->isActiveObject())
        EnsureGridLoaded(cell);
    else
        EnsureGridCreated(GridCoord(cell.GridX(), cell.GridY()));
 
    AddToGrid(obj, cell);
 
    //Must already be set before AddToMap. Usually during obj->Create.
    //obj->SetMap(this);
    obj->AddToWorld();
 
    if (checkTransport)
        if (!(obj->IsGameObject() && obj->ToGameObject()->IsTransport())) // dont add transport to transport ;d
            if (Transport* transport = GetTransportForPos(obj->GetPhaseMask(), obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), obj))
                transport->AddPassenger(obj, true);
 
    InitializeObject(obj);
 
    if (obj->isActiveObject())
        AddToActive(obj);
 
    //something, such as vehicle, needs to be update immediately
    //also, trigger needs to cast spell, if not update, cannot see visual
    obj->UpdateObjectVisibility(true);
 
    // Xinef: little hack for vehicles, accessories have to be added after visibility update so they wont fall off the vehicle, moved from Creature::AIM_Initialize
    // Initialize vehicle, this is done only for summoned npcs, DB creatures are handled by grid loaders
    if (obj->IsCreature())
        if (Vehicle* vehicle = obj->ToCreature()->GetVehicleKit())
            vehicle->Reset();
    return true;
}

References AddToActive(), AddToGrid(), ASSERT, Acore::ComputeCellCoord(), EnsureGridCreated(), EnsureGridLoaded(), GetTransportForPos(), Cell::GridX(), Cell::GridY(), InitializeObject(), CoordPair< LIMIT >::IsCoordValid(), LOG_ERROR, CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by Battleground::AddCreature(), Battleground::AddObject(), Player::BuildPlayerRepop(), ConvertCorpseToBones(), GameObject::Create(), MotionTransport::CreateGOPassenger(), MotionTransport::CreateNPCPassenger(), Player::CreatePet(), Player::CreatePet(), TransportMgr::CreateTransport(), MotionTransport::DelayedTeleportTransport(), Spell::EffectCreateTamedPet(), Spell::EffectDuel(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectTameCreature(), Spell::EffectTransmitted(), GameEventMgr::GameEventSpawn(), debug_commandscript::HandleDebugSpawnVehicleCommand(), OutdoorPvPSI::HandleDropFlag(), Pet::LoadPetFromDB(), GameObject::Refresh(), ScriptsProcess(), Battlefield::SpawnCreature(), Battlefield::SpawnGameObject(), SummonCreature(), SummonGameObject(), WorldObject::SummonGameObject(), Player::SummonPet(), and GameObject::Update().

◆ AddUpdateObject()

void Map::AddUpdateObject ( Object * obj )

inline

    {
        _updateObjects.insert(obj);
    }

References _updateObjects.

Referenced by WorldObject::AddToObjectUpdate().

◆ AddWorldObject()

void Map::AddWorldObject ( WorldObject * obj )

inline

318{ i_worldObjects.insert(obj); }

References i_worldObjects.

Referenced by WorldObject::SetMap().

◆ AfterPlayerUnlinkFromMap()

void Map::AfterPlayerUnlinkFromMap ( )

virtual

Reimplemented in InstanceMap.

699{

700}

Referenced by InstanceMap::AfterPlayerUnlinkFromMap(), WorldSession::HandleMoveWorldportAck(), and WorldSession::HandleSetRaidDifficultyOpcode().

◆ AllTransportsEmpty()

bool Map::AllTransportsEmpty ( ) const

{
    for (TransportsContainer::const_iterator itr = _transports.begin(); itr != _transports.end(); ++itr)
        if (!(*itr)->GetPassengers().empty())
            return false;
 
    return true;
}

References _transports.

Referenced by MapInstanced::CreateInstanceForPlayer(), and UnloadAll().

◆ AllTransportsRemovePassengers()

void Map::AllTransportsRemovePassengers ( )

{
    for (TransportsContainer::const_iterator itr = _transports.begin(); itr != _transports.end(); ++itr)
        while (!(*itr)->GetPassengers().empty())
            (*itr)->RemovePassenger(*((*itr)->GetPassengers().begin()), true);
}

References _transports.

Referenced by MapInstanced::CreateInstanceForPlayer(), and UnloadAll().

◆ ApplyDynamicModeRespawnScaling()

uint32 Map::ApplyDynamicModeRespawnScaling	(	WorldObject const *	obj,
		uint32	respawnDelay
	)		const

{
    ASSERT(obj->GetMap() == this);
 
    float rate = sWorld->getFloatConfig(obj->IsGameObject() ? CONFIG_RESPAWN_DYNAMICRATE_GAMEOBJECT : CONFIG_RESPAWN_DYNAMICRATE_CREATURE);
 
    if (rate == 1.0f)
        return respawnDelay;
 
    // No instanced maps (dungeons, battlegrounds, arenas etc.)
    if (obj->GetMap()->Instanceable())
        return respawnDelay;
 
    // No quest givers or world bosses
    if (Creature const* creature = obj->ToCreature())
        if (creature->IsQuestGiver() || creature->isWorldBoss()
            || (creature->GetCreatureTemplate()->rank == CREATURE_ELITE_RARE)
            || (creature->GetCreatureTemplate()->rank == CREATURE_ELITE_RAREELITE))
            return respawnDelay;
 
    auto it = _zonePlayerCountMap.find(obj->GetZoneId());
    if (it == _zonePlayerCountMap.end())
        return respawnDelay;
    uint32 const playerCount = it->second;
    if (!playerCount)
        return respawnDelay;
    double const adjustFactor =  rate / playerCount;
    if (adjustFactor >= 1.0) // nothing to do here
        return respawnDelay;
    uint32 const timeMinimum = sWorld->getIntConfig(obj->IsGameObject() ? CONFIG_RESPAWN_DYNAMICMINIMUM_GAMEOBJECT : CONFIG_RESPAWN_DYNAMICMINIMUM_CREATURE);
    if (respawnDelay <= timeMinimum)
        return respawnDelay;
 
    return std::max<uint32>(std::ceil(respawnDelay * adjustFactor), timeMinimum);
}

References _zonePlayerCountMap, ASSERT, CONFIG_RESPAWN_DYNAMICMINIMUM_CREATURE, CONFIG_RESPAWN_DYNAMICMINIMUM_GAMEOBJECT, CONFIG_RESPAWN_DYNAMICRATE_CREATURE, CONFIG_RESPAWN_DYNAMICRATE_GAMEOBJECT, CREATURE_ELITE_RARE, CREATURE_ELITE_RAREELITE, WorldObject::GetMap(), WorldObject::GetZoneId(), Instanceable(), Object::IsGameObject(), sWorld, and Object::ToCreature().

Referenced by Creature::setDeathState(), and GameObject::Update().

◆ Balance()

void Map::Balance ( )

inline

396{ _dynamicTree.balance(); }

DynamicMapTree::balance

void balance()

Definition DynamicTree.cpp:132

Map::_dynamicTree

DynamicMapTree _dynamicTree

Definition Map.h:546

References _dynamicTree, and DynamicMapTree::balance().

Referenced by EnsureGridLoaded().

◆ CannotEnter()

virtual EnterState Map::CannotEnter	(	Player *	,
		bool
	)

inlinevirtual

Reimplemented in InstanceMap, BattlegroundMap, and MapInstanced.

280{ return CAN_ENTER; }

References CAN_ENTER.

Referenced by InstanceMap::CannotEnter(), BattlegroundMap::CannotEnter(), and WorldSession::HandleMoveWorldportAck().

◆ CanReachPositionAndGetValidCoords() [1/3]

bool Map::CanReachPositionAndGetValidCoords	(	WorldObject const *	source,
		float &	destX,
		float &	destY,
		float &	destZ,
		bool	failOnCollision = `true`,
		bool	failOnSlopes = `true`
	)		const

validate the new destination and set reachable coords Check if a given unit can reach a specific point on a segment and set the correct dest coords NOTE: use this method with small segments.

Parameters

failOnCollision	if true, the methods will return false when a collision occurs
failOnSlopes	if true, the methods will return false when a non walkable slope is found

Returns: true if the destination is valid, false otherwise

{
    return CanReachPositionAndGetValidCoords(source, source->GetPositionX(), source->GetPositionY(), source->GetPositionZ(), destX, destY, destZ, failOnCollision, failOnSlopes);
}

References CanReachPositionAndGetValidCoords(), Position::GetPositionX(), Position::GetPositionY(), and Position::GetPositionZ().

◆ CanReachPositionAndGetValidCoords() [2/3]

bool Map::CanReachPositionAndGetValidCoords	(	WorldObject const *	source,
		float	startX,
		float	startY,
		float	startZ,
		float &	destX,
		float &	destY,
		float &	destZ,
		bool	failOnCollision = `true`,
		bool	failOnSlopes = `true`
	)		const

{
    if (!CheckCollisionAndGetValidCoords(source, startX, startY, startZ, destX, destY, destZ, failOnCollision))
    {
        return false;
    }
 
    Unit const* unit = source->ToUnit();
    // if it's not an unit (Object) then we do not have to continue
    // with walkable checks
    if (!unit)
    {
        return true;
    }
 
    /*
     * Walkable checks
     */
    bool isWaterNext = HasEnoughWater(unit, destX, destY, destZ);
    Creature const* creature = unit->ToCreature();
    bool cannotEnterWater = isWaterNext && (creature && !creature->CanEnterWater());
    bool cannotWalkOrFly = !isWaterNext && !source->ToPlayer() && !unit->CanFly() && (creature && !creature->CanWalk());
    if (cannotEnterWater || cannotWalkOrFly ||
        (failOnSlopes && !PathGenerator::IsWalkableClimb(startX, startY, startZ, destX, destY, destZ, source->GetCollisionHeight())))
    {
        return false;
    }
 
    return true;
}

References Creature::CanEnterWater(), Unit::CanFly(), Creature::CanWalk(), CheckCollisionAndGetValidCoords(), WorldObject::GetCollisionHeight(), HasEnoughWater(), PathGenerator::IsWalkableClimb(), Object::ToCreature(), Object::ToPlayer(), and Object::ToUnit().

◆ CanReachPositionAndGetValidCoords() [3/3]

bool Map::CanReachPositionAndGetValidCoords	(	WorldObject const *	source,
		PathGenerator *	path,
		float &	destX,
		float &	destY,
		float &	destZ,
		bool	failOnCollision = `true`,
		bool	failOnSlopes = `true`
	)		const

Check if a given source can reach a specific point following a path and normalize the coords. Use this method for long paths, otherwise use the overloaded method with the start coords when you need to do a quick check on small segments.

{
    G3D::Vector3 prevPath = path->GetStartPosition();
    for (auto& vector : path->GetPath())
    {
        float x = vector.x;
        float y = vector.y;
        float z = vector.z;
 
        if (!CanReachPositionAndGetValidCoords(source, prevPath.x, prevPath.y, prevPath.z, x, y, z, failOnCollision, failOnSlopes))
        {
            destX = x;
            destY = y;
            destZ = z;
            return false;
        }
 
        prevPath = vector;
    }
 
    destX = prevPath.x;
    destY = prevPath.y;
    destZ = prevPath.z;
 
    return true;
}

References CanReachPositionAndGetValidCoords(), PathGenerator::GetPath(), and PathGenerator::GetStartPosition().

Referenced by CanReachPositionAndGetValidCoords(), CanReachPositionAndGetValidCoords(), MotionMaster::MoveBackwards(), and MotionMaster::MoveForwards().

◆ CanUnload()

bool Map::CanUnload ( uint32 diff )

inline

    {
        if (!m_unloadTimer)
            return false;
 
        if (m_unloadTimer <= diff)
            return true;
 
        m_unloadTimer -= diff;
        return false;
    }

References m_unloadTimer.

◆ CheckCollisionAndGetValidCoords()

bool Map::CheckCollisionAndGetValidCoords	(	WorldObject const *	source,
		float	startX,
		float	startY,
		float	startZ,
		float &	destX,
		float &	destY,
		float &	destZ,
		bool	failOnCollision = `true`
	)		const

validate the new destination and set coords Check if a given unit can face collisions in a specific segment

Returns: true if the destination is valid, false otherwise

{
    // Prevent invalid coordinates here, position is unchanged
    if (!Acore::IsValidMapCoord(startX, startY, startZ) || !Acore::IsValidMapCoord(destX, destY, destZ))
    {
        LOG_FATAL("maps", "Map::CheckCollisionAndGetValidCoords invalid coordinates startX: {}, startY: {}, startZ: {}, destX: {}, destY: {}, destZ: {}", startX, startY, startZ, destX, destY, destZ);
        return false;
    }
 
    bool isWaterNext = IsInWater(source->GetPhaseMask(), destX, destY, destZ, source->GetCollisionHeight());
 
    PathGenerator path(source);
 
    // Use a detour raycast to get our first collision point
    path.SetUseRaycast(true);
    bool result = path.CalculatePath(startX, startY, startZ, destX, destY, destZ, false);
 
    Unit const* unit = source->ToUnit();
    bool notOnGround = path.GetPathType() & PATHFIND_NOT_USING_PATH
        || isWaterNext || (unit && unit->IsFlying());
 
    // Check for valid path types before we proceed
    if (!result || (!notOnGround && path.GetPathType() & ~(PATHFIND_NORMAL | PATHFIND_SHORTCUT | PATHFIND_INCOMPLETE | PATHFIND_FARFROMPOLY_END)))
    {
        return false;
    }
 
    G3D::Vector3 endPos = path.GetPath().back();
    destX = endPos.x;
    destY = endPos.y;
    destZ = endPos.z;
 
    // collision check
    bool collided = false;
 
    // check static LOS
    float halfHeight = source->GetCollisionHeight() * 0.5f;
 
    // Unit is not on the ground, check for potential collision via vmaps
    if (notOnGround)
    {
        bool col = VMAP::VMapFactory::createOrGetVMapMgr()->GetObjectHitPos(source->GetMapId(),
            startX, startY, startZ + halfHeight,
            destX, destY, destZ + halfHeight,
            destX, destY, destZ, -CONTACT_DISTANCE);
 
        destZ -= halfHeight;
 
        // Collided with static LOS object, move back to collision point
        if (col)
        {
            collided = true;
        }
    }
 
    // check dynamic collision
    bool col = source->GetMap()->GetObjectHitPos(source->GetPhaseMask(),
        startX, startY, startZ + halfHeight,
        destX, destY, destZ + halfHeight,
        destX, destY, destZ, -CONTACT_DISTANCE);
 
    destZ -= halfHeight;
 
    // Collided with a gameobject, move back to collision point
    if (col)
    {
        collided = true;
    }
 
    float groundZ = VMAP_INVALID_HEIGHT_VALUE;
    source->UpdateAllowedPositionZ(destX, destY, destZ, &groundZ);
 
    // position has no ground under it (or is too far away)
    if (groundZ <= INVALID_HEIGHT && unit && !unit->CanFly())
    {
        // fall back to gridHeight if any
        float gridHeight = GetGridHeight(destX, destY);
        if (gridHeight > INVALID_HEIGHT)
        {
            destZ = gridHeight + unit->GetHoverHeight();
        }
        else
        {
            return false;
        }
    }
 
    return !failOnCollision || !collided;
}

References PathGenerator::CalculatePath(), CanFly, CONTACT_DISTANCE, VMAP::VMapFactory::createOrGetVMapMgr(), WorldObject::GetCollisionHeight(), GetGridHeight(), Unit::GetHoverHeight(), WorldObject::GetMap(), WorldLocation::GetMapId(), GetObjectHitPos(), VMAP::VMapMgr2::GetObjectHitPos(), PathGenerator::GetPath(), PathGenerator::GetPathType(), WorldObject::GetPhaseMask(), INVALID_HEIGHT, Unit::IsFlying(), IsInWater(), Acore::IsValidMapCoord(), LOG_FATAL, PATHFIND_FARFROMPOLY_END, PATHFIND_INCOMPLETE, PATHFIND_NORMAL, PATHFIND_NOT_USING_PATH, PATHFIND_SHORTCUT, PathGenerator::SetUseRaycast(), Object::ToUnit(), WorldObject::UpdateAllowedPositionZ(), and VMAP_INVALID_HEIGHT_VALUE.

Referenced by CanReachPositionAndGetValidCoords().

◆ ContainsGameObjectModel()

bool Map::ContainsGameObjectModel ( const GameObjectModel & model ) const

inline

399{ return _dynamicTree.contains(model);}

DynamicMapTree::contains

bool contains(const GameObjectModel &) const

Definition DynamicTree.cpp:127

References _dynamicTree, and DynamicMapTree::contains().

◆ ConvertCorpseToBones()

Corpse * Map::ConvertCorpseToBones	(	ObjectGuid const	ownerGuid,
		bool	insignia = `false`
	)

{
    Corpse* corpse = GetCorpseByPlayer(ownerGuid);
    if (!corpse)
        return nullptr;
 
    RemoveCorpse(corpse);
 
    // remove corpse from DB
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    corpse->DeleteFromDB(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    Corpse* bones = NULL;
 
    // create the bones only if the map and the grid is loaded at the corpse's location
    // ignore bones creating option in case insignia
    if ((insignia ||
        (IsBattlegroundOrArena() ? sWorld->getBoolConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld->getBoolConfig(CONFIG_DEATH_BONES_WORLD))) &&
        IsGridLoaded(corpse->GetPositionX(), corpse->GetPositionY()))
    {
        // Create bones, don't change Corpse
        bones = new Corpse();
        bones->Create(corpse->GetGUID().GetCounter());
 
        for (uint8 i = OBJECT_FIELD_TYPE + 1; i < CORPSE_END; ++i)                    // don't overwrite guid and object type
            bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 
        bones->SetCellCoord(corpse->GetCellCoord());
        bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
        bones->SetPhaseMask(corpse->GetPhaseMask(), false);
 
        bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
        bones->SetGuidValue(CORPSE_FIELD_OWNER, corpse->GetOwnerGUID());
 
        for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
            if (corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
                bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
 
        AddCorpse(bones);
 
        bones->UpdatePositionData();
 
        // add bones in grid store if grid loaded where corpse placed
        AddToMap(bones);
    }
 
    // all references to the corpse should be removed at this point
    delete corpse;
 
    return bones;
}

References AddCorpse(), AddToMap(), CharacterDatabase, CONFIG_DEATH_BONES_BG_OR_ARENA, CONFIG_DEATH_BONES_WORLD, CORPSE_END, CORPSE_FIELD_FLAGS, CORPSE_FIELD_ITEM, CORPSE_FIELD_OWNER, CORPSE_FLAG_BONES, CORPSE_FLAG_UNK2, Corpse::Create(), Corpse::DeleteFromDB(), EQUIPMENT_SLOT_END, Corpse::GetCellCoord(), GetCorpseByPlayer(), ObjectGuid::GetCounter(), Object::GetGUID(), Position::GetOrientation(), Corpse::GetOwnerGUID(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Object::GetUInt32Value(), IsBattlegroundOrArena(), IsGridLoaded(), OBJECT_FIELD_TYPE, Position::Relocate(), RemoveCorpse(), Corpse::SetCellCoord(), Object::SetGuidValue(), WorldObject::SetPhaseMask(), Object::SetUInt32Value(), sWorld, and WorldObject::UpdatePositionData().

Referenced by AddPlayerToMap(), Player::RemovedInsignia(), and RemoveOldCorpses().

◆ CreatureRelocation()

void Map::CreatureRelocation	(	Creature *	creature,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    Cell old_cell = creature->GetCurrentCell();
    Cell new_cell(x, y);
 
    if (old_cell.DiffGrid(new_cell) || old_cell.DiffCell(new_cell))
    {
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
 
        AddCreatureToMoveList(creature);
    }
    else
        RemoveCreatureFromMoveList(creature);
 
    creature->Relocate(x, y, z, o);
    if (creature->IsVehicle())
        creature->GetVehicleKit()->RelocatePassengers();
    creature->UpdatePositionData();
    creature->UpdateObjectVisibility(false);
}

References AddCreatureToMoveList(), Cell::DiffCell(), Cell::DiffGrid(), EnsureGridLoaded(), MovableMapObject::GetCurrentCell(), Unit::GetVehicleKit(), Unit::IsVehicle(), Position::Relocate(), Vehicle::RelocatePassengers(), RemoveCreatureFromMoveList(), Unit::UpdateObjectVisibility(), and WorldObject::UpdatePositionData().

Referenced by Creature::SetPosition(), StaticTransport::UpdatePassengerPositions(), MotionTransport::UpdatePassengerPositions(), and Unit::UpdatePosition().

◆ DelayedUpdate()

void Map::DelayedUpdate ( const uint32 diff )

virtual

Reimplemented in MapInstanced.

{
    for (_transportsUpdateIter = _transports.begin(); _transportsUpdateIter != _transports.end();)
    {
        MotionTransport* transport = *_transportsUpdateIter;
        ++_transportsUpdateIter;
 
        if (!transport->IsInWorld())
            continue;
 
        transport->DelayedUpdate(t_diff);
    }
 
    RemoveAllObjectsInRemoveList();
}

References _transports, _transportsUpdateIter, MotionTransport::DelayedUpdate(), Object::IsInWorld(), and RemoveAllObjectsInRemoveList().

Referenced by MapInstanced::DelayedUpdate().

◆ DeleteCorpseData()

void Map::DeleteCorpseData ( )

{
    // DELETE FROM corpse WHERE mapId = ? AND instanceId = ?
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CORPSES_FROM_MAP);
    stmt->SetData(0, GetId());
    stmt->SetData(1, GetInstanceId());
    CharacterDatabase.Execute(stmt);
}

References CHAR_DEL_CORPSES_FROM_MAP, CharacterDatabase, GetId(), GetInstanceId(), and PreparedStatementBase::SetData().

Referenced by InstanceMap::UnloadAll().

◆ DeleteFromWorld() [1/2]

template<>

void Map::DeleteFromWorld ( Player * player )

{
    ObjectAccessor::RemoveObject(player);
 
    RemoveUpdateObject(player); //TODO: I do not know why we need this, it should be removed in ~Object anyway
    delete player;
}

References ObjectAccessor::RemoveObject(), and RemoveUpdateObject().

◆ DeleteFromWorld() [2/2]

template<class T >

void Map::DeleteFromWorld ( T * obj )

private

{
    // Note: In case resurrectable corpse and pet its removed from global lists in own destructor
    delete obj;
}

Referenced by RemoveFromMap(), RemoveFromMap(), and RemovePlayerFromMap().

◆ DeleteRespawnTimes()

void Map::DeleteRespawnTimes ( )

{
    _creatureRespawnTimes.clear();
    _goRespawnTimes.clear();
 
    DeleteRespawnTimesInDB(GetId(), GetInstanceId());
}

References _creatureRespawnTimes, _goRespawnTimes, DeleteRespawnTimesInDB(), GetId(), and GetInstanceId().

Referenced by InstanceMap::UnloadAll().

◆ DeleteRespawnTimesInDB()

void Map::DeleteRespawnTimesInDB	(	uint16	mapId,
		uint32	instanceId
	)

static

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN_BY_INSTANCE);
    stmt->SetData(0, mapId);
    stmt->SetData(1, instanceId);
    CharacterDatabase.Execute(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GO_RESPAWN_BY_INSTANCE);
    stmt->SetData(0, mapId);
    stmt->SetData(1, instanceId);
    CharacterDatabase.Execute(stmt);
}

References CHAR_DEL_CREATURE_RESPAWN_BY_INSTANCE, CHAR_DEL_GO_RESPAWN_BY_INSTANCE, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by InstanceSaveMgr::_ResetSave(), InstanceSaveMgr::DeleteInstanceSaveIfNeeded(), and DeleteRespawnTimes().

◆ DoForAllPlayers()

void Map::DoForAllPlayers ( std::function< void(Player *)> exec )

{
    for (auto const& it : GetPlayers())
    {
        if (Player* player = it.GetSource())
        {
            exec(player);
        }
    }
}

References GetPlayers().

Referenced by Battleground::_ProcessProgress(), ArenaSeasonMgr::BroadcastUpdatedWorldState(), WorldState::BuffAdalsSongOfBattle(), WorldState::BuffMagtheridonTeam(), BattlegroundSA::CaptureGraveyard(), WorldState::DispelAdalsSongOfBattle(), WorldState::DispelMagtheridonTeam(), npc_thrall_warchief::npc_thrall_warchiefAI::DoAction(), InstanceScript::DoCastSpellOnPlayers(), InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), InstanceScript::DoSendNotifyToInstance(), InstanceScript::DoStartTimedAchievement(), InstanceScript::DoStopTimedAchievement(), InstanceScript::DoUpdateAchievementCriteria(), BattlegroundSA::EventPlayerDamagedGO(), BattlegroundSA::EventPlayerUsedGO(), boss_azuregos::boss_azuregosAI::JustDied(), boss_rajaxx::JustDied(), boss_alar::JustDied(), boss_felblood_kaelthas::LapseAction(), BattlegroundSA::PostUpdateImpl(), spell_fire_festival_fortitude::PrepareSpellScript(), boss_azuregos::boss_azuregosAI::Reset(), boss_yoggsaron_sara::boss_yoggsaron_saraAI::Reset(), npc_minigob_manabonk::SelectTargetInDalaran(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::SetBossState(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetData(), Battleground::SpiritOfCompetitionEvent(), boss_nefarian::UpdateAI(), boss_cthun::UpdateAI(), npc_gunship::npc_gunshipAI::UpdateAI(), and npc_midsummer_bonfire::UpdateBonfireBlessingBuffs().

◆ DynamicObjectRelocation()

void Map::DynamicObjectRelocation	(	DynamicObject *	go,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    Cell old_cell = dynObj->GetCurrentCell();
    Cell new_cell(x, y);
 
    if (old_cell.DiffGrid(new_cell) || old_cell.DiffCell(new_cell))
    {
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
 
        AddDynamicObjectToMoveList(dynObj);
    }
    else
        RemoveDynamicObjectFromMoveList(dynObj);
 
    dynObj->Relocate(x, y, z, o);
    dynObj->SetPositionDataUpdate();
    dynObj->UpdateObjectVisibility(false);
}

References AddDynamicObjectToMoveList(), Cell::DiffCell(), Cell::DiffGrid(), EnsureGridLoaded(), MovableMapObject::GetCurrentCell(), Position::Relocate(), RemoveDynamicObjectFromMoveList(), WorldObject::SetPositionDataUpdate(), and WorldObject::UpdateObjectVisibility().

Referenced by StaticTransport::UpdatePassengerPositions(), and MotionTransport::UpdatePassengerPositions().

◆ EnsureGridCreated()

void Map::EnsureGridCreated ( GridCoord const & gridCoord )

{
    _mapGridManager.CreateGrid(gridCoord.x_coord, gridCoord.y_coord);
}

References _mapGridManager, MapGridManager::CreateGrid(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by AddToMap(), EnsureGridLoaded(), GetGridTerrainData(), and GetGridTerrainDataSharedPtr().

◆ EnsureGridLoaded()

bool Map::EnsureGridLoaded ( Cell const & cell )

private

{
    EnsureGridCreated(GridCoord(cell.GridX(), cell.GridY()));
 
    if (_mapGridManager.LoadGrid(cell.GridX(), cell.GridY()))
    {
        Balance();
        return true;
    }
 
    return false;
}

References _mapGridManager, Balance(), EnsureGridCreated(), Cell::GridX(), Cell::GridY(), and MapGridManager::LoadGrid().

Referenced by AddToMap(), AddToMap(), CreatureRelocation(), DynamicObjectRelocation(), GameObjectRelocation(), LoadGrid(), LoadGridsInRange(), MoveAllCreaturesInMoveList(), MoveAllDynamicObjectsInMoveList(), MoveAllGameObjectsInMoveList(), PlayerRelocation(), and SummonCreature().

◆ GameObjectRelocation()

void Map::GameObjectRelocation	(	GameObject *	go,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    Cell old_cell = go->GetCurrentCell();
    Cell new_cell(x, y);
 
    if (old_cell.DiffGrid(new_cell) || old_cell.DiffCell(new_cell))
    {
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
 
        AddGameObjectToMoveList(go);
    }
    else
        RemoveGameObjectFromMoveList(go);
 
    go->Relocate(x, y, z, o);
    go->UpdateModelPosition();
    go->SetPositionDataUpdate();
    go->UpdateObjectVisibility(false);
}

References AddGameObjectToMoveList(), Cell::DiffCell(), Cell::DiffGrid(), EnsureGridLoaded(), MovableMapObject::GetCurrentCell(), Position::Relocate(), RemoveGameObjectFromMoveList(), WorldObject::SetPositionDataUpdate(), GameObject::UpdateModelPosition(), and WorldObject::UpdateObjectVisibility().

Referenced by GameObject::SetPosition(), StaticTransport::UpdatePassengerPositions(), MotionTransport::UpdatePassengerPositions(), and StaticTransport::UpdatePosition().

◆ GenerateLowGuid()

template<HighGuid high>

ObjectGuid::LowType Map::GenerateLowGuid ( )

inline

    {
        static_assert(ObjectGuidTraits<high>::MapSpecific, "Only map specific guid can be generated in Map context");
        return GetGuidSequenceGenerator<high>().Generate();
    }

Referenced by Battleground::AddCreature(), Battleground::AddObject(), GameObject::Create(), Pet::CreateBaseAtTamed(), Spell::EffectAddFarsight(), Spell::EffectDuel(), Spell::EffectPersistentAA(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectTransmitted(), debug_commandscript::HandleDebugSpawnVehicleCommand(), OutdoorPvPSI::HandleDropFlag(), gobject_commandscript::HandleGameObjectAddCommand(), npc_commandscript::HandleNpcAddCommand(), wp_commandscript::HandleWpModifyCommand(), wp_commandscript::HandleWpShowCommand(), Creature::LoadCreatureFromDB(), GameObject::LoadGameObjectFromDB(), Pet::LoadPetFromDB(), Battlefield::SpawnCreature(), Battlefield::SpawnGameObject(), WorldObject::SummonGameObject(), and Player::SummonPet().

◆ GetActiveNonPlayersCount()

std::size_t Map::GetActiveNonPlayersCount ( ) const

inline

    {
        return m_activeNonPlayers.size();
    }

References m_activeNonPlayers.

Referenced by debug_commandscript::HandleDebugObjectCountMap().

◆ GetAllTransports()

TransportsContainer const & Map::GetAllTransports ( ) const

inline

472{ return _transports; }

References _transports.

Referenced by npc_preparations_for_war_vehicle::UpdateAI().

◆ GetAreaId()

uint32 Map::GetAreaId	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z
	)		const

{
    uint32 mogpFlags;
    int32 adtId, rootId, groupId;
    float vmapZ = z;
    bool hasVmapArea = GetAreaInfo(phaseMask, x, y, vmapZ, mogpFlags, adtId, rootId, groupId);
 
    uint32 gridAreaId    = 0;
    float  gridMapHeight = INVALID_HEIGHT;
    if (GridTerrainData* gmap = const_cast<Map*>(this)->GetGridTerrainData(x, y))
    {
        gridAreaId    = gmap->getArea(x, y);
        gridMapHeight = gmap->getHeight(x, y);
    }
 
    uint16 areaId = 0;
 
    // floor is the height we are closer to (but only if above)
    if (hasVmapArea && G3D::fuzzyGe(z, vmapZ - GROUND_HEIGHT_TOLERANCE) && (G3D::fuzzyLt(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE) || vmapZ > gridMapHeight))
    {
        // wmo found
        if (WMOAreaTableEntry const* wmoEntry = GetWMOAreaTableEntryByTripple(rootId, adtId, groupId))
            areaId = wmoEntry->areaId;
 
        if (!areaId)
            areaId = gridAreaId;
    }
    else
        areaId = gridAreaId;
 
    if (!areaId)
        areaId = i_mapEntry->linked_zone;
 
    return areaId;
}

References GetAreaInfo(), GetGridTerrainData(), GetWMOAreaTableEntryByTripple(), GROUND_HEIGHT_TOLERANCE, i_mapEntry, INVALID_HEIGHT, and MapEntry::linked_zone.

Referenced by MapMgr::GetAreaId(), GetLiquidData(), GetZoneAndAreaId(), and GetZoneId().

◆ GetAreaInfo()

bool Map::GetAreaInfo	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		uint32 &	mogpflags,
		int32 &	adtId,
		int32 &	rootId,
		int32 &	groupId
	)		const

{
    float vmap_z = z;
    float dynamic_z = z;
    float check_z = z;
    VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr();
    uint32 vflags;
    int32 vadtId;
    int32 vrootId;
    int32 vgroupId;
    uint32 dflags;
    int32 dadtId;
    int32 drootId;
    int32 dgroupId;
 
    bool hasVmapAreaInfo = vmgr->GetAreaInfo(GetId(), x, y, vmap_z, vflags, vadtId, vrootId, vgroupId);
    bool hasDynamicAreaInfo = _dynamicTree.GetAreaInfo(x, y, dynamic_z, phaseMask, dflags, dadtId, drootId, dgroupId);
    auto useVmap = [&]() { check_z = vmap_z; flags = vflags; adtId = vadtId; rootId = vrootId; groupId = vgroupId; };
    auto useDyn = [&]() { check_z = dynamic_z; flags = dflags; adtId = dadtId; rootId = drootId; groupId = dgroupId; };
 
    if (hasVmapAreaInfo)
    {
        if (hasDynamicAreaInfo && dynamic_z > vmap_z)
            useDyn();
        else
            useVmap();
    }
    else if (hasDynamicAreaInfo)
    {
        useDyn();
    }
 
    if (hasVmapAreaInfo || hasDynamicAreaInfo)
    {
        // check if there's terrain between player height and object height
        if (GridTerrainData* gmap = const_cast<Map*>(this)->GetGridTerrainData(x, y))
        {
            float mapHeight = gmap->getHeight(x, y);
            // z + 2.0f condition taken from GetHeight(), not sure if it's such a great choice...
            if (z + 2.0f > mapHeight && mapHeight > check_z)
                return false;
        }
 
        return true;
    }
 
    return false;
}

References _dynamicTree, VMAP::VMapFactory::createOrGetVMapMgr(), DynamicMapTree::GetAreaInfo(), VMAP::IVMapMgr::GetAreaInfo(), GetGridTerrainData(), and GetId().

Referenced by GetAreaId().

◆ GetCorpse()

Corpse * Map::GetCorpse ( ObjectGuid const guid )

{
    return _objectsStore.Find<Corpse>(guid);
}

References _objectsStore, and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

Referenced by ObjectAccessor::GetCorpse(), and ScriptsProcess().

◆ GetCorpseByPlayer()

Corpse * Map::GetCorpseByPlayer ( ObjectGuid const & ownerGuid ) const

inline

    {
        auto itr = _corpsesByPlayer.find(ownerGuid);
        if (itr != _corpsesByPlayer.end())
            return itr->second;
 
        return nullptr;
    }

References _corpsesByPlayer.

Referenced by ConvertCorpseToBones(), Player::GetCorpse(), and WorldSession::HandleMoveWorldportAck().

◆ GetCorpsesInGrid()

std::unordered_set< Corpse * > const * Map::GetCorpsesInGrid ( uint32 gridId ) const

inline

    {
        auto itr = _corpsesByGrid.find(gridId);
        if (itr != _corpsesByGrid.end())
            return &itr->second;
 
        return nullptr;
    }

References _corpsesByGrid.

Referenced by GridObjectLoader::LoadAllCellsInGrid().

◆ GetCreatedCellsInGridCount()

uint32 Map::GetCreatedCellsInGridCount	(	uint16 const	x,
		uint16 const	y
	)

{
    return _mapGridManager.GetCreatedCellsInGridCount(x, y);
}

References _mapGridManager, and MapGridManager::GetCreatedCellsInGridCount().

Referenced by debug_commandscript::HandleDebugMapDataCommand().

◆ GetCreatedCellsInMapCount()

uint32 Map::GetCreatedCellsInMapCount ( )

{
    return _mapGridManager.GetCreatedCellsInMapCount();
}

References _mapGridManager, and MapGridManager::GetCreatedCellsInMapCount().

Referenced by debug_commandscript::HandleDebugMapDataCommand().

◆ GetCreatedGridsCount()

uint32 Map::GetCreatedGridsCount ( )

{
    return _mapGridManager.GetCreatedGridsCount();
}

References _mapGridManager, and MapGridManager::GetCreatedGridsCount().

Referenced by debug_commandscript::HandleDebugMapDataCommand().

◆ GetCreature()

Creature * Map::GetCreature ( ObjectGuid const guid )

{
    return _objectsStore.Find<Creature>(guid);
}

References _objectsStore, and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

◆ GetCreatureBySpawnIdStore()

CreatureBySpawnIdContainer & Map::GetCreatureBySpawnIdStore ( )

inline

357{ return _creatureBySpawnIdStore; }

Map::_creatureBySpawnIdStore

CreatureBySpawnIdContainer _creatureBySpawnIdStore

Definition Map.h:632

References _creatureBySpawnIdStore.

Referenced by Creature::AddToWorld(), OPvPCapturePoint::DelCreature(), OPvPCapturePointNA::DespawnCreatures(), SmartScript::FindCreatureNear(), OPvPCapturePointNA::GetAliveGuardsCount(), ChatHandler::GetCreatureFromPlayerMapByDbGuid(), list_commandscript::HandleListCreatureCommand(), Creature::LoadCreatureFromDB(), and GameEventMgr::UpdateEventNPCFlags().

◆ GetCreatureRespawnTime()

time_t Map::GetCreatureRespawnTime ( ObjectGuid::LowType dbGuid ) const

inline

    {
        std::unordered_map<ObjectGuid::LowType /*dbGUID*/, time_t>::const_iterator itr = _creatureRespawnTimes.find(dbGuid);
        if (itr != _creatureRespawnTimes.end())
            return itr->second;
 
        return time_t(0);
    }

References _creatureRespawnTimes.

Referenced by GetLinkedRespawnTime(), and Creature::LoadCreatureFromDB().

◆ GetDebugInfo()

std::string Map::GetDebugInfo ( ) const

virtual

Reimplemented in InstanceMap.

{
    std::stringstream sstr;
    sstr << std::boolalpha
        << "Id: " << GetId() << " InstanceId: " << GetInstanceId() << " Difficulty: " << std::to_string(GetDifficulty())
        << " HasPlayers: " << HavePlayers();
    return sstr.str();
}

References GetDifficulty(), GetId(), GetInstanceId(), and HavePlayers().

Referenced by InstanceMap::GetDebugInfo().

◆ GetDifficulty()

Difficulty Map::GetDifficulty ( ) const

inline

285{ return Difficulty(GetSpawnMode()); }

Difficulty

Definition DBCEnums.h:266

Map::GetSpawnMode

uint8 GetSpawnMode() const

Definition Map.h:262

References GetSpawnMode().

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), npc_ritual_channeler::npc_ritual_channelerAI::AttackStart(), spell_gen_consumption::CalculateDamage(), InstanceMap::CannotEnter(), Player::CanRollForItemInLFG(), Spell::CheckCast(), MapInstanced::CreateInstanceForPlayer(), boss_twin_valkyrAI::DoAction(), GetDebugInfo(), GetMapDifficulty(), spell_valkyr_touch_aura::HandleEffectPeriodic(), WorldSession::HandleMoveWorldportAck(), WorldSession::HandlePlayerLoginFromDB(), WorldSession::HandlePlayerLoginToCharInWorld(), Player::inRandomLfgDungeon(), IsRegularDifficulty(), LogEncounterFinished(), npc_frost_sphere::npc_frost_sphereAI::npc_frost_sphereAI(), instance_ulduar::instance_ulduar_InstanceMapScript::OnCreatureCreate(), npc_essence_of_twin::OnGossipHello(), lfg::LFGPlayerScript::OnPlayerMapChanged(), Player::RewardReputation(), instance_trial_of_the_crusader::instance_trial_of_the_crusader_InstanceMapScript::SetData(), instance_pit_of_saron::instance_pit_of_saron_InstanceScript::SetData(), boss_jaraxxus::boss_jaraxxusAI::SpellHit(), Player::StoreRaidMapDifficulty(), boss_gluth::boss_gluthAI::UpdateAI(), and UpdateEncounterState().

◆ GetDynamicMapTree()

DynamicMapTree const & Map::GetDynamicMapTree ( ) const

inline

400{ return _dynamicTree; }

References _dynamicTree.

Referenced by BattlegroundRV::CheckPositionForUnit().

◆ GetDynamicObject()

DynamicObject * Map::GetDynamicObject ( ObjectGuid const guid )

{
    return _objectsStore.Find<DynamicObject>(guid);
}

References _objectsStore, and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

Referenced by ObjectAccessor::GetDynamicObject().

◆ GetEntrancePos()

bool Map::GetEntrancePos	(	int32 &	mapid,
		float &	x,
		float &	y
	)

inline

    {
        if (!i_mapEntry)
            return false;
        return i_mapEntry->GetEntrancePos(mapid, x, y);
    }

References MapEntry::GetEntrancePos(), and i_mapEntry.

◆ GetEntry()

MapEntry const * Map::GetEntry ( ) const

inline

165{ return i_mapEntry; }

References i_mapEntry.

Referenced by InstanceMap::GetMaxPlayers(), misc_commandscript::HandleSkirmishCommand(), and LogEncounterFinished().

◆ GetFullTerrainStatusForPosition()

void Map::GetFullTerrainStatusForPosition	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		float	collisionHeight,
		PositionFullTerrainStatus &	data,
		uint8	reqLiquidType = `MAP_ALL_LIQUIDS`
	)

{
    GridTerrainData* gmap = GetGridTerrainData(x, y);
 
    VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr();
    VMAP::AreaAndLiquidData vmapData;
    // VMAP::AreaAndLiquidData dynData;
    VMAP::AreaAndLiquidData* wmoData = nullptr;
    vmgr->GetAreaAndLiquidData(GetId(), x, y, z, reqLiquidType, vmapData);
    // _dynamicTree.GetAreaAndLiquidData(x, y, z, phaseMask, reqLiquidType, dynData);
 
    uint32 gridAreaId = 0;
    float gridMapHeight = INVALID_HEIGHT;
    if (gmap)
    {
        gridAreaId = gmap->getArea(x, y);
        gridMapHeight = gmap->getHeight(x, y);
    }
 
    bool useGridLiquid = true;
 
    // floor is the height we are closer to (but only if above)
    data.floorZ = VMAP_INVALID_HEIGHT;
    if (gridMapHeight > INVALID_HEIGHT && G3D::fuzzyGe(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE))
        data.floorZ = gridMapHeight;
 
    if (vmapData.floorZ > VMAP_INVALID_HEIGHT && G3D::fuzzyGe(z, vmapData.floorZ - GROUND_HEIGHT_TOLERANCE) &&
        (G3D::fuzzyLt(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE) || vmapData.floorZ > gridMapHeight))
    {
        data.floorZ = vmapData.floorZ;
        wmoData = &vmapData;
    }
 
    // NOTE: Objects will not detect a case when a wmo providing area/liquid despawns from under them
    // but this is fine as these kind of objects are not meant to be spawned and despawned a lot
    // example: Lich King platform
    /*
    if (dynData.floorZ > VMAP_INVALID_HEIGHT && G3D::fuzzyGe(z, dynData.floorZ - GROUND_HEIGHT_TOLERANCE) &&
        (G3D::fuzzyLt(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE) || dynData.floorZ > gridMapHeight) &&
        (G3D::fuzzyLt(z, vmapData.floorZ - GROUND_HEIGHT_TOLERANCE) || dynData.floorZ > vmapData.floorZ))
    {
        data.floorZ = dynData.floorZ;
        wmoData = &dynData;
    }
    */
 
    if (wmoData)
    {
        if (wmoData->areaInfo)
        {
            // wmo found
            WMOAreaTableEntry const* wmoEntry = GetWMOAreaTableEntryByTripple(wmoData->areaInfo->rootId, wmoData->areaInfo->adtId, wmoData->areaInfo->groupId);
            data.outdoors = (wmoData->areaInfo->mogpFlags & 0x8) != 0;
            if (wmoEntry)
            {
                data.areaId = wmoEntry->areaId;
                if (wmoEntry->Flags & 4)
                    data.outdoors = true;
                else if (wmoEntry->Flags & 2)
                    data.outdoors = false;
            }
 
            if (!data.areaId)
                data.areaId = gridAreaId;
 
            useGridLiquid = !IsInWMOInterior(wmoData->areaInfo->mogpFlags);
        }
    }
    else
    {
        data.outdoors = true;
        data.areaId = gridAreaId;
        if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(data.areaId))
            data.outdoors = (areaEntry->flags & (AREA_FLAG_INSIDE | AREA_FLAG_OUTSIDE)) != AREA_FLAG_INSIDE;
    }
 
    if (!data.areaId)
        data.areaId = i_mapEntry->linked_zone;
 
    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(data.areaId);
 
    // liquid processing
    if (wmoData && wmoData->liquidInfo && wmoData->liquidInfo->level > wmoData->floorZ)
    {
        uint32 liquidType = wmoData->liquidInfo->type;
        if (GetId() == MAP_OUTLAND && liquidType == 2) // gotta love blizzard hacks
            liquidType = 15;
 
        uint32 liquidFlagType = 0;
        if (LiquidTypeEntry const* liquidData = sLiquidTypeStore.LookupEntry(liquidType))
            liquidFlagType = liquidData->Type;
 
        if (liquidType && liquidType < 21 && areaEntry)
        {
            uint32 overrideLiquid = areaEntry->LiquidTypeOverride[liquidFlagType];
            if (!overrideLiquid && areaEntry->zone)
            {
                AreaTableEntry const* zoneEntry = sAreaTableStore.LookupEntry(areaEntry->zone);
                if (zoneEntry)
                    overrideLiquid = zoneEntry->LiquidTypeOverride[liquidFlagType];
            }
 
            if (LiquidTypeEntry const* overrideData = sLiquidTypeStore.LookupEntry(overrideLiquid))
            {
                liquidType = overrideLiquid;
                liquidFlagType = overrideData->Type;
            }
        }
 
        data.liquidInfo.Level = wmoData->liquidInfo->level;
        data.liquidInfo.DepthLevel = wmoData->floorZ;
        data.liquidInfo.Entry = liquidType;
        data.liquidInfo.Flags = 1 << liquidFlagType;
 
        // Get position delta
        float delta = wmoData->liquidInfo->level - z;
 
        if (delta > collisionHeight)
            data.liquidInfo.Status = LIQUID_MAP_UNDER_WATER;
        else if (delta > 0.0f)
            data.liquidInfo.Status = LIQUID_MAP_IN_WATER;
        else if (delta > -0.1f)
            data.liquidInfo.Status = LIQUID_MAP_WATER_WALK;
        else
            data.liquidInfo.Status = LIQUID_MAP_ABOVE_WATER;
    }
 
    // look up liquid data from grid map
    if (gmap && useGridLiquid)
    {
        LiquidData const& gridLiquidData = gmap->GetLiquidData(x, y, z, collisionHeight, reqLiquidType);
        if (gridLiquidData.Status != LIQUID_MAP_NO_WATER && (!wmoData || gridLiquidData.Level > wmoData->floorZ))
        {
            uint32 liquidEntry = gridLiquidData.Entry;
            if (GetId() == MAP_OUTLAND && liquidEntry == 2)
                liquidEntry = 15;
 
            data.liquidInfo = gridLiquidData;
            data.liquidInfo.Entry = liquidEntry;
        }
    }
}

References AREA_FLAG_INSIDE, AREA_FLAG_OUTSIDE, PositionFullTerrainStatus::areaId, WMOAreaTableEntry::areaId, VMAP::AreaAndLiquidData::areaInfo, VMAP::VMapFactory::createOrGetVMapMgr(), LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, WMOAreaTableEntry::Flags, VMAP::AreaAndLiquidData::floorZ, PositionFullTerrainStatus::floorZ, GridTerrainData::getArea(), VMAP::IVMapMgr::GetAreaAndLiquidData(), GetGridTerrainData(), GridTerrainData::getHeight(), GetId(), GridTerrainData::GetLiquidData(), GetWMOAreaTableEntryByTripple(), GROUND_HEIGHT_TOLERANCE, i_mapEntry, INVALID_HEIGHT, IsInWMOInterior(), LiquidData::Level, MapEntry::linked_zone, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_IN_WATER, LIQUID_MAP_NO_WATER, LIQUID_MAP_UNDER_WATER, LIQUID_MAP_WATER_WALK, VMAP::AreaAndLiquidData::liquidInfo, PositionFullTerrainStatus::liquidInfo, AreaTableEntry::LiquidTypeOverride, MAP_OUTLAND, PositionFullTerrainStatus::outdoors, sAreaTableStore, sLiquidTypeStore, LiquidData::Status, VMAP_INVALID_HEIGHT, and AreaTableEntry::zone.

Referenced by Creature::Create(), and WorldObject::UpdatePositionData().

◆ GetGameObject()

GameObject * Map::GetGameObject ( ObjectGuid const guid )

{
    return _objectsStore.Find<GameObject>(guid);
}

References _objectsStore, and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

◆ GetGameObjectBySpawnIdStore()

GameObjectBySpawnIdContainer & Map::GetGameObjectBySpawnIdStore ( )

inline

360{ return _gameobjectBySpawnIdStore; }

Map::_gameobjectBySpawnIdStore

GameObjectBySpawnIdContainer _gameobjectBySpawnIdStore

Definition Map.h:633

References _gameobjectBySpawnIdStore.

Referenced by _FindGameObject(), GameObject::AddToWorld(), OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointGH::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePoint::DelObject(), SmartScript::FindGameObjectNear(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), list_commandscript::HandleListObjectCommand(), Player::LoadFromDB(), and OPvPCapturePointEP_NPT::SummonGO().

◆ GetGameObjectFloor()

float Map::GetGameObjectFloor	(	uint32	phasemask,
		float	x,
		float	y,
		float	z,
		float	maxSearchDist = `DEFAULT_HEIGHT_SEARCH`
	)		const

inline

    {
        return _dynamicTree.getHeight(x, y, z, maxSearchDist, phasemask);
    }

References _dynamicTree, and DynamicMapTree::getHeight().

◆ GetGORespawnTime()

time_t Map::GetGORespawnTime ( ObjectGuid::LowType dbGuid ) const

inline

    {
        std::unordered_map<ObjectGuid::LowType /*dbGUID*/, time_t>::const_iterator itr = _goRespawnTimes.find(dbGuid);
        if (itr != _goRespawnTimes.end())
            return itr->second;
 
        return time_t(0);
    }

References _goRespawnTimes.

Referenced by GetLinkedRespawnTime(), and GameObject::LoadGameObjectFromDB().

◆ GetGridHeight()

float Map::GetGridHeight	(	float	x,
		float	y
	)		const

{
    if (GridTerrainData* gmap = const_cast<Map*>(this)->GetGridTerrainData(x, y))
        return gmap->getHeight(x, y);
 
    return INVALID_HEIGHT;
}

References GetGridTerrainData(), and INVALID_HEIGHT.

Referenced by CheckCollisionAndGetValidCoords(), and GetHeight().

◆ GetGridTerrainData() [1/2]

GridTerrainData * Map::GetGridTerrainData	(	float	x,
		float	y
	)

{
    GridCoord const gridCoord = Acore::ComputeGridCoord(x, y);
    return GetGridTerrainData(gridCoord);
}

References Acore::ComputeGridCoord(), and GetGridTerrainData().

◆ GetGridTerrainData() [2/2]

GridTerrainData * Map::GetGridTerrainData ( GridCoord const & gridCoord )

{
    if (!MapGridManager::IsValidGridCoordinates(gridCoord.x_coord, gridCoord.y_coord))
        return nullptr;
 
    // ensure GridMap is created
    EnsureGridCreated(gridCoord);
    return _mapGridManager.GetGrid(gridCoord.x_coord, gridCoord.y_coord)->GetTerrainData();
}

References _mapGridManager, EnsureGridCreated(), MapGridManager::GetGrid(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetTerrainData(), MapGridManager::IsValidGridCoordinates(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by GetAreaId(), GetAreaInfo(), GetFullTerrainStatusForPosition(), GetGridHeight(), GetGridTerrainData(), GetLiquidData(), GetMinHeight(), and GetWaterLevel().

◆ GetGridTerrainDataSharedPtr()

std::shared_ptr< GridTerrainData > Map::GetGridTerrainDataSharedPtr ( GridCoord const & gridCoord )

{
    // ensure GridMap is created
    EnsureGridCreated(gridCoord);
    return _mapGridManager.GetGrid(gridCoord.x_coord, gridCoord.y_coord)->GetTerrainDataSharedPtr();
}

References _mapGridManager, EnsureGridCreated(), MapGridManager::GetGrid(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetTerrainDataSharedPtr(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by GridTerrainLoader::LoadMap().

◆ GetGuidSequenceGenerator()

template<HighGuid high>

ObjectGuidGeneratorBase & Map::GetGuidSequenceGenerator ( )

inlineprivate

    {
        auto itr = _guidGenerators.find(high);
        if (itr == _guidGenerators.end())
            itr = _guidGenerators.insert(std::make_pair(high, std::unique_ptr<ObjectGuidGenerator<high>>(new ObjectGuidGenerator<high>()))).first;
 
        return *itr->second;
    }

References _guidGenerators.

◆ GetHeight() [1/2]

float Map::GetHeight	(	float	x,
		float	y,
		float	z,
		bool	checkVMap = `true`,
		float	maxSearchDist = `DEFAULT_HEIGHT_SEARCH`
	)		const

{
    // find raw .map surface under Z coordinates
    float mapHeight = VMAP_INVALID_HEIGHT_VALUE;
    float gridHeight = GetGridHeight(x, y);
    if (G3D::fuzzyGe(z, gridHeight - GROUND_HEIGHT_TOLERANCE))
        mapHeight = gridHeight;
 
    float vmapHeight = VMAP_INVALID_HEIGHT_VALUE;
    if (checkVMap)
    {
        VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr();
        vmapHeight = vmgr->getHeight(GetId(), x, y, z, maxSearchDist);   // look from a bit higher pos to find the floor
    }
 
    // mapHeight set for any above raw ground Z or <= INVALID_HEIGHT
    // vmapheight set for any under Z value or <= INVALID_HEIGHT
    if (vmapHeight > INVALID_HEIGHT)
    {
        if (mapHeight > INVALID_HEIGHT)
        {
            // we have mapheight and vmapheight and must select more appropriate
 
            // we are already under the surface or vmap height above map heigt
            // or if the distance of the vmap height is less the land height distance
            if (vmapHeight > mapHeight || std::fabs(mapHeight - z) > std::fabs(vmapHeight - z))
                return vmapHeight;
            else
                return mapHeight;                           // better use .map surface height
        }
        else
            return vmapHeight;                              // we have only vmapHeight (if have)
    }
 
    return mapHeight;                               // explicitly use map data
}

References VMAP::VMapFactory::createOrGetVMapMgr(), GetGridHeight(), VMAP::IVMapMgr::getHeight(), GetId(), GROUND_HEIGHT_TOLERANCE, INVALID_HEIGHT, and VMAP_INVALID_HEIGHT_VALUE.

Referenced by BattlegroundRV::CheckPositionForUnit(), boss_ick::boss_ickAI::DamageTaken(), GetHeight(), WorldObject::GetMapHeight(), GetTransportForPos(), GetWaterOrGroundLevel(), go_commandscript::HandleGoGridCommand(), go_commandscript::HandleGoXYZCommand(), go_commandscript::HandleGoZoneXYCommand(), spell_winter_veil_racer_rocket_slam::HandleTriggerSpell(), spell_svalna_revive_champion::Land(), Creature::LoadCreatureFromDB(), Spell::SelectImplicitCasterDestTargets(), and npc_cork_gizelton::npc_cork_gizeltonAI::WaypointReached().

◆ GetHeight() [2/2]

float Map::GetHeight	(	uint32	phasemask,
		float	x,
		float	y,
		float	z,
		bool	vmap = `true`,
		float	maxSearchDist = `DEFAULT_HEIGHT_SEARCH`
	)		const

{
    float h1, h2;
    h1 = GetHeight(x, y, z, vmap, maxSearchDist);
    h2 = _dynamicTree.getHeight(x, y, z, maxSearchDist, phasemask);
    return std::max<float>(h1, h2);
}

References _dynamicTree, GetHeight(), and DynamicMapTree::getHeight().

◆ GetId()

uint32 Map::GetId ( ) const

inline

224{ return i_mapEntry->MapID; }

MapEntry::MapID

uint32 MapID

Definition DBCStructure.h:1327

References i_mapEntry, and MapEntry::MapID.

Referenced by Group::_cancelHomebindIfInstance(), AddObjectToRemoveList(), InstanceMap::AddPlayerToMap(), WorldState::BroadcastSIWorldstates(), WorldState::BuffAdalsSongOfBattle(), WorldState::BuffMagtheridonTeam(), spell_gen_consumption::CalculateDamage(), MapUpdateRequest::call(), MapPreloadRequest::call(), InstanceMap::CannotEnter(), Player::CanRollForItemInLFG(), InstanceScript::CheckAchievementCriteriaMeet(), Spell::CheckCast(), GameObject::Create(), StaticTransport::Create(), MapInstanced::CreateBattleground(), MapInstanced::CreateInstance(), MapInstanced::CreateInstanceForPlayer(), InstanceMap::CreateInstanceScript(), TransportMgr::CreateInstanceTransports(), OPvPCapturePoint::DelCreature(), DeleteCorpseData(), DeleteRespawnTimes(), WorldState::DispelAdalsSongOfBattle(), WorldState::DispelMagtheridonTeam(), CreatureAI::DoZoneInCombat(), GetAreaInfo(), GetDebugInfo(), GetFullTerrainStatusForPosition(), GetHeight(), GetLiquidData(), GetMapDifficulty(), debug_commandscript::HandleDebugObjectCountMap(), spell_valkyr_touch_aura::HandleEffectPeriodic(), gobject_commandscript::HandleGameObjectAddCommand(), go_commandscript::HandleGoZoneXYCommand(), WorldSession::HandleMoveWorldportAck(), npc_commandscript::HandleNpcAddCommand(), WorldSession::HandlePlayerLoginFromDB(), WorldSession::HandlePlayerLoginToCharInWorld(), WorldSession::HandleSetRaidDifficultyOpcode(), wp_commandscript::HandleWpModifyCommand(), wp_commandscript::HandleWpShowCommand(), InitVisibilityDistance(), InstanceMap::InitVisibilityDistance(), Player::inRandomLfgDungeon(), isInLineOfSight(), DisableMgr::IsPathfindingEnabled(), InstanceScript::IsTwoFactionInstance(), GridObjectLoader::LoadAllCellsInGrid(), LoadCorpseData(), GridTerrainLoader::LoadMap(), GridTerrainLoader::LoadMMap(), LoadRespawnTimes(), GridTerrainLoader::LoadVMap(), LogEncounterFinished(), AchievementCriteriaData::Meets(), MotionMaster::MoveFall(), lfg::LFGPlayerScript::OnPlayerMapChanged(), InstanceMap::PermBindAllPlayers(), RemoveAllPlayers(), RemoveCreatureRespawnTime(), RemoveGORespawnTime(), InstanceMap::Reset(), Player::RewardReputation(), SaveCreatureRespawnTime(), SaveGORespawnTime(), InstanceMap::SendResetWarnings(), World::SetInitialWorldSettings(), WorldObject::SetMap(), Player::SetMover(), SummonCreatureGroup(), MotionTransport::TeleportTransport(), UnloadGrid(), GridTerrainUnloader::UnloadTerrain(), Update(), UpdateEncounterState(), and ~Map().

◆ GetInstanceId()

uint32 Map::GetInstanceId ( ) const

inline

261{ return i_InstanceId; }

References i_InstanceId.

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), AddObjectToRemoveList(), InstanceMap::AddPlayerToMap(), InstanceMap::CannotEnter(), BattlegroundMap::CannotEnter(), DeleteCorpseData(), DeleteRespawnTimes(), GetDebugInfo(), debug_commandscript::HandleDebugObjectCountMap(), misc_commandscript::HandleGroupSummonCommand(), misc_commandscript::HandleSummonCommand(), LoadCorpseData(), InstanceScript::LoadInstanceSavedGameobjectStateData(), GridTerrainLoader::LoadMap(), LoadRespawnTimes(), GridTerrainLoader::LoadTerrain(), OnCreateMap(), InstanceMap::PermBindAllPlayers(), RemoveCreatureRespawnTime(), RemoveGORespawnTime(), SaveCreatureRespawnTime(), SaveGORespawnTime(), InstanceScript::SaveToDB(), InstanceScript::SetCompletedEncountersMask(), WorldObject::SetMap(), GridTerrainUnloader::UnloadTerrain(), Update(), and InstanceMap::~InstanceMap().

◆ GetInstanceResetPeriod()

time_t Map::GetInstanceResetPeriod ( ) const

inline

434{ return _instanceResetPeriod; }

References _instanceResetPeriod.

Referenced by SaveCreatureRespawnTime(), and SaveGORespawnTime().

◆ GetLinkedRespawnTime()

time_t Map::GetLinkedRespawnTime ( ObjectGuid guid ) const

{
    ObjectGuid linkedGuid = sObjectMgr->GetLinkedRespawnGuid(guid);
    switch (linkedGuid.GetHigh())
    {
        case HighGuid::Unit:
            return GetCreatureRespawnTime(linkedGuid.GetCounter());
        case HighGuid::GameObject:
            return GetGORespawnTime(linkedGuid.GetCounter());
        default:
            break;
    }
 
    return time_t(0);
}

References GameObject, ObjectGuid::GetCounter(), GetCreatureRespawnTime(), GetGORespawnTime(), ObjectGuid::GetHigh(), sObjectMgr, and Unit.

Referenced by Creature::Respawn(), and GameObject::Update().

◆ GetLiquidData()

LiquidData const Map::GetLiquidData	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		float	collisionHeight,
		uint8	ReqLiquidType
	)

{
   LiquidData liquidData;
 
    VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr();
    float liquid_level = INVALID_HEIGHT;
    float ground_level = INVALID_HEIGHT;
    uint32 liquid_type = 0;
    uint32 mogpFlags = 0;
    bool useGridLiquid = true;
    if (vmgr->GetLiquidLevel(GetId(), x, y, z, ReqLiquidType, liquid_level, ground_level, liquid_type, mogpFlags))
    {
        useGridLiquid = !IsInWMOInterior(mogpFlags);
        LOG_DEBUG("maps", "GetLiquidStatus(): vmap liquid level: {} ground: {} type: {}", liquid_level, ground_level, liquid_type);
        // Check water level and ground level
        if (liquid_level > ground_level && G3D::fuzzyGe(z, ground_level - GROUND_HEIGHT_TOLERANCE))
        {
            // hardcoded in client like this
            if (GetId() == MAP_OUTLAND && liquid_type == 2)
                liquid_type = 15;
 
            uint32 liquidFlagType = 0;
            if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(liquid_type))
                liquidFlagType = liq->Type;
 
            if (liquid_type && liquid_type < 21)
            {
                if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(GetAreaId(phaseMask, x, y, z)))
                {
                    uint32 overrideLiquid = area->LiquidTypeOverride[liquidFlagType];
                    if (!overrideLiquid && area->zone)
                    {
                        area = sAreaTableStore.LookupEntry(area->zone);
                        if (area)
                            overrideLiquid = area->LiquidTypeOverride[liquidFlagType];
                    }
 
                    if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(overrideLiquid))
                    {
                        liquid_type = overrideLiquid;
                        liquidFlagType = liq->Type;
                    }
                }
            }
 
            liquidData.Level = liquid_level;
            liquidData.DepthLevel = ground_level;
            liquidData.Entry = liquid_type;
            liquidData.Flags = 1 << liquidFlagType;
        }
 
        float delta = liquid_level - z;
 
        // Get position delta
        if (delta > collisionHeight)
            liquidData.Status = LIQUID_MAP_UNDER_WATER;
        else if (delta > 0.0f)
            liquidData.Status = LIQUID_MAP_IN_WATER;
        else if (delta > -0.1f)
            liquidData.Status = LIQUID_MAP_WATER_WALK;
        else
            liquidData.Status = LIQUID_MAP_ABOVE_WATER;
    }
 
    if (useGridLiquid)
    {
        if (GridTerrainData* gmap = const_cast<Map*>(this)->GetGridTerrainData(x, y))
        {
            LiquidData const& map_data = gmap->GetLiquidData(x, y, z, collisionHeight, ReqLiquidType);
            // Not override LIQUID_MAP_ABOVE_WATER with LIQUID_MAP_NO_WATER:
            if (map_data.Status != LIQUID_MAP_NO_WATER && (map_data.Level > ground_level))
            {
                // hardcoded in client like this
                uint32 liquidEntry = map_data.Entry;
                if (GetId() == MAP_OUTLAND && liquidEntry == 2)
                    liquidEntry = 15;
 
                liquidData = map_data;
                liquidData.Entry = liquidEntry;
            }
        }
    }
 
   return liquidData;
}

References VMAP::VMapFactory::createOrGetVMapMgr(), LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, GetAreaId(), GetGridTerrainData(), GetId(), VMAP::IVMapMgr::GetLiquidLevel(), GROUND_HEIGHT_TOLERANCE, INVALID_HEIGHT, IsInWMOInterior(), LiquidData::Level, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_IN_WATER, LIQUID_MAP_NO_WATER, LIQUID_MAP_UNDER_WATER, LIQUID_MAP_WATER_WALK, LOG_DEBUG, MAP_OUTLAND, sAreaTableStore, sLiquidTypeStore, and LiquidData::Status.

Referenced by PathGenerator::BuildPolyPath(), PathGenerator::GetNavTerrain(), GetWaterOrGroundLevel(), HasEnoughWater(), IsInWater(), IsUnderWater(), Spell::SelectImplicitCasterDestTargets(), and spell_spawn_blood_pool::SetDest().

◆ GetLoadedGridsCount()

uint32 Map::GetLoadedGridsCount ( )

{
    return _mapGridManager.GetLoadedGridsCount();
}

References _mapGridManager, and MapGridManager::GetLoadedGridsCount().

Referenced by debug_commandscript::HandleDebugMapDataCommand().

◆ GetMapDifficulty()

MapDifficulty const * Map::GetMapDifficulty ( ) const

{
    return GetMapDifficultyData(GetId(), GetDifficulty());
}

References GetDifficulty(), GetId(), and GetMapDifficultyData().

Referenced by InstanceMap::GetMaxPlayers(), and InstanceMap::GetMaxResetDelay().

◆ GetMapGrid()

MapGridType * Map::GetMapGrid	(	uint16 const	x,
		uint16 const	y
	)

private

{
    return _mapGridManager.GetGrid(x, y);
}

References _mapGridManager, and MapGridManager::GetGrid().

Referenced by AddToGrid(), AddToGrid(), AddToGrid(), AddToGrid(), AddToGrid(), and Visit().

◆ GetMapName()

char const * Map::GetMapName ( ) const

{
    return i_mapEntry ? i_mapEntry->name[sWorld->GetDefaultDbcLocale()] : "UNNAMEDMAP\x0";
}

References i_mapEntry, MapEntry::name, and sWorld.

Referenced by MapPreloadRequest::call(), InstanceMap::CannotEnter(), debug_commandscript::HandleDebugObjectCountMap(), go_commandscript::HandleGoZoneXYCommand(), GridTerrainLoader::LoadMMap(), GridTerrainLoader::LoadVMap(), LogCommandUsage(), and InstanceMap::PermBindAllPlayers().

◆ GetMinHeight()

float Map::GetMinHeight	(	float	x,
		float	y
	)		const

{
    if (GridTerrainData const* grid = const_cast<Map*>(this)->GetGridTerrainData(x, y))
        return grid->getMinHeight(x, y);
 
    return MIN_HEIGHT;
}

References GetGridTerrainData(), and MIN_HEIGHT.

Referenced by WorldSession::HandleMovementOpcodes().

◆ GetMMapLock()

std::shared_mutex & Map::GetMMapLock ( ) const

inline

229{ return *(const_cast<std::shared_mutex*>(&MMapLock)); }

Map::MMapLock

std::shared_mutex MMapLock

Definition Map.h:538

References MMapLock.

◆ GetObjectHitPos()

bool Map::GetObjectHitPos	(	uint32	phasemask,
		float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2,
		float &	rx,
		float &	ry,
		float &	rz,
		float	modifyDist
	)

{
    G3D::Vector3 startPos(x1, y1, z1);
    G3D::Vector3 dstPos(x2, y2, z2);
 
    G3D::Vector3 resultPos;
    bool result = _dynamicTree.GetObjectHitPos(phasemask, startPos, dstPos, resultPos, modifyDist);
 
    rx = resultPos.x;
    ry = resultPos.y;
    rz = resultPos.z;
    return result;
}

References _dynamicTree, and DynamicMapTree::GetObjectHitPos().

Referenced by CheckCollisionAndGetValidCoords(), and Spell::SelectImplicitCasterDestTargets().

◆ GetObjectsStore()

MapStoredObjectTypesContainer & Map::GetObjectsStore ( )

inline

354{ return _objectsStore; }

References _objectsStore.

Referenced by Corpse::AddToWorld(), Creature::AddToWorld(), DynamicObject::AddToWorld(), GameObject::AddToWorld(), Pet::AddToWorld(), debug_commandscript::HandleDebugObjectCountMap(), Corpse::RemoveFromWorld(), Creature::RemoveFromWorld(), DynamicObject::RemoveFromWorld(), GameObject::RemoveFromWorld(), Pet::RemoveFromWorld(), GameEventMgr::RunSmartAIScripts(), and Update().

◆ GetParent()

Map const * Map::GetParent ( ) const

inline

226{ return m_parentMap; }

References m_parentMap.

Referenced by GridTerrainLoader::LoadMap().

◆ GetPet()

Pet * Map::GetPet ( ObjectGuid const guid )

{
    return _objectsStore.Find<Pet>(guid);
}

References _objectsStore, and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

Referenced by ObjectAccessor::GetPet(), and ScriptsProcess().

◆ GetPlayers()

PlayerList const & Map::GetPlayers ( ) const

inline

324{ return m_mapRefMgr; }

Map::m_mapRefMgr

MapRefMgr m_mapRefMgr

Definition Map.h:549

References m_mapRefMgr.

◆ GetPlayersCountExceptGMs()

uint32 Map::GetPlayersCountExceptGMs ( ) const

{
    uint32 count = 0;
    for (MapRefMgr::const_iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
        if (!itr->GetSource()->IsGameMaster())
            ++count;
    return count;
}

References MapRefMgr::begin(), MapRefMgr::end(), and m_mapRefMgr.

Referenced by InstanceMap::CannotEnter(), instance_naxxramas::CheckAchievementCriteriaMeet(), instance_obsidian_sanctum::instance_obsidian_sanctum_InstanceMapScript::CheckAchievementCriteriaMeet(), AchievementCriteriaData::Meets(), instance_old_hillsbrad::instance_old_hillsbrad_InstanceMapScript::OnPlayerEnter(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::OnPlayerEnter(), instance_culling_of_stratholme::instance_culling_of_stratholme_InstanceMapScript::OnPlayerEnter(), instance_hyjal::instance_mount_hyjal_InstanceMapScript::SetData(), instance_eye_of_eternity::instance_eye_of_eternity_InstanceMapScript::SetData(), and instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::Update().

◆ GetSpawnMode()

uint8 Map::GetSpawnMode ( ) const

inline

262{ return (i_spawnMode); }

References i_spawnMode.

Referenced by InstanceMap::AddPlayerToMap(), InstanceMap::CannotEnter(), SmartScript::FillScript(), GetDifficulty(), SpellMgr::GetSpellIdForDifficulty(), Unit::HandleAuraProc(), gobject_commandscript::HandleGameObjectAddCommand(), npc_commandscript::HandleNpcAddCommand(), spell_dreamwalker_summon_portal::HandleScript(), wp_commandscript::HandleWpModifyCommand(), wp_commandscript::HandleWpShowCommand(), GridObjectLoader::LoadAllCellsInGrid(), AchievementCriteriaData::Meets(), achievement_once_bitten_twice_shy::OnCheck(), ScriptedAI::ScriptedAI(), instance_eye_of_eternity::instance_eye_of_eternity_InstanceMapScript::SetData(), npc_pos_tyrannus_events::npc_pos_tyrannus_eventsAI::SetData(), instance_trial_of_the_crusader::instance_trial_of_the_crusader_InstanceMapScript::Update(), and npc_pos_tyrannus_events::npc_pos_tyrannus_eventsAI::UpdateAI().

◆ GetTransport()

Transport * Map::GetTransport ( ObjectGuid const guid )

{
    if (guid.GetHigh() != HighGuid::Mo_Transport && guid.GetHigh() != HighGuid::Transport)
        return nullptr;
 
    GameObject* go = GetGameObject(guid);
    return go ? go->ToTransport() : nullptr;
}

References GetGameObject(), ObjectGuid::GetHigh(), Mo_Transport, GameObject::ToTransport(), and Transport.

Referenced by ObjectAccessor::GetTransport(), WorldSession::HandleMovementOpcodes(), npc_gunship::npc_gunshipAI::JustDied(), npc_gunship_boarding_addAI::MovementInform(), ScriptsProcess(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::UpdateAI(), and npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::UpdateAI().

◆ GetTransportForPos()

Transport * Map::GetTransportForPos	(	uint32	phase,
		float	x,
		float	y,
		float	z,
		WorldObject *	worldobject = `nullptr`
	)

{
    G3D::Vector3 v(x, y, z + 2.0f);
    G3D::Ray r(v, G3D::Vector3(0, 0, -1));
    for (TransportsContainer::const_iterator itr = _transports.begin(); itr != _transports.end(); ++itr)
        if ((*itr)->IsInWorld() && (*itr)->GetExactDistSq(x, y, z) < 75.0f * 75.0f && (*itr)->m_model)
        {
            float dist = 30.0f;
            bool hit = (*itr)->m_model->intersectRay(r, dist, false, phase, VMAP::ModelIgnoreFlags::Nothing);
            if (hit)
                return *itr;
        }
 
    if (worldobject)
        if (GameObject* staticTrans = worldobject->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_TRANSPORT, 75.0f))
            if (staticTrans->m_model)
            {
                float dist = 10.0f;
                bool hit = staticTrans->m_model->intersectRay(r, dist, false, phase, VMAP::ModelIgnoreFlags::Nothing);
                if (hit)
                    if (GetHeight(phase, x, y, z, true, 30.0f) < (v.z - dist + 1.0f))
                        return staticTrans->ToTransport();
            }
 
    return nullptr;
}

References _transports, WorldObject::FindNearestGameObjectOfType(), GAMEOBJECT_TYPE_TRANSPORT, GetHeight(), and VMAP::Nothing.

Referenced by AddToMap(), and Creature::Update().

◆ GetVisibilityRange()

float Map::GetVisibilityRange ( ) const

inline

190{ return m_VisibleDistance; }

References m_VisibleDistance.

Referenced by WorldObject::GetGridActivationRange(), WorldObject::GetSightRange(), WorldObject::GetVisibilityRange(), AuraEffect::HandleFeignDeath(), AuraEffect::HandleModPossessPet(), WorldSession::HandleMoveTeleportAck(), and SummonCreature().

◆ GetWaterLevel()

float Map::GetWaterLevel	(	float	x,
		float	y
	)		const

{
    if (GridTerrainData* gmap = const_cast<Map*>(this)->GetGridTerrainData(x, y))
        return gmap->getLiquidLevel(x, y);
 
    return INVALID_HEIGHT;
}

References GetGridTerrainData(), and INVALID_HEIGHT.

Referenced by go_commandscript::HandleGoGridCommand(), go_commandscript::HandleGoXYZCommand(), and go_commandscript::HandleGoZoneXYCommand().

◆ GetWaterOrGroundLevel()

float Map::GetWaterOrGroundLevel	(	uint32	phasemask,
		float	x,
		float	y,
		float	z,
		float *	ground = `nullptr`,
		bool	swim = `false`,
		float	collisionHeight = `DEFAULT_COLLISION_HEIGHT`
	)		const

{
    // we need ground level (including grid height version) for proper return water level in point
    float ground_z = GetHeight(phasemask, x, y, z + Z_OFFSET_FIND_HEIGHT, true, 50.0f);
    if (ground)
        *ground = ground_z;
 
    LiquidData const& liquidData = const_cast<Map*>(this)->GetLiquidData(phasemask, x, y, ground_z, collisionHeight, MAP_ALL_LIQUIDS);
    switch (liquidData.Status)
    {
        case LIQUID_MAP_ABOVE_WATER:
            return std::max<float>(liquidData.Level, ground_z);
        case LIQUID_MAP_NO_WATER:
            return ground_z;
        default:
            return liquidData.Level;
    }
 
    return VMAP_INVALID_HEIGHT_VALUE;
}

References GetHeight(), GetLiquidData(), LiquidData::Level, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_NO_WATER, MAP_ALL_LIQUIDS, LiquidData::Status, VMAP_INVALID_HEIGHT_VALUE, and Z_OFFSET_FIND_HEIGHT.

Referenced by WorldObject::GetMapWaterOrGroundLevel().

◆ GetZoneAndAreaId()

void Map::GetZoneAndAreaId	(	uint32	phaseMask,
		uint32 &	zoneid,
		uint32 &	areaid,
		float	x,
		float	y,
		float	z
	)		const

{
    areaid = zoneid = GetAreaId(phaseMask, x, y, z);
    if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaid))
        if (area->zone)
            zoneid = area->zone;
}

References GetAreaId(), and sAreaTableStore.

Referenced by WorldObject::AddToWorld(), and MapMgr::GetZoneAndAreaId().

◆ GetZoneId()

uint32 Map::GetZoneId	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z
	)		const

{
    uint32 areaId = GetAreaId(phaseMask, x, y, z);
    if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
        if (area->zone)
            return area->zone;
 
    return areaId;
}

References GetAreaId(), and sAreaTableStore.

Referenced by MapMgr::GetZoneId().

◆ HandleDelayedVisibility()

void Map::HandleDelayedVisibility ( )

{
    if (i_objectsForDelayedVisibility.empty())
        return;
    for (std::unordered_set<Unit*>::iterator itr = i_objectsForDelayedVisibility.begin(); itr != i_objectsForDelayedVisibility.end(); ++itr)
        (*itr)->ExecuteDelayedUnitRelocationEvent();
    i_objectsForDelayedVisibility.clear();
}

References i_objectsForDelayedVisibility.

Referenced by Update().

◆ HasEnoughWater() [1/2]

bool Map::HasEnoughWater	(	WorldObject const *	searcher,
		float	x,
		float	y,
		float	z
	)		const

{
    LiquidData const& liquidData = const_cast<Map*>(this)->GetLiquidData(
        searcher->GetPhaseMask(), x, y, z, searcher->GetCollisionHeight(), MAP_ALL_LIQUIDS);
 
    if ((liquidData.Status & MAP_LIQUID_STATUS_SWIMMING) == 0)
        return false;
 
    float minHeightInWater = searcher->GetMinHeightInWater();
    return liquidData.Level > INVALID_HEIGHT &&
           liquidData.Level > liquidData.DepthLevel &&
           liquidData.Level - liquidData.DepthLevel >= minHeightInWater;
}

References LiquidData::DepthLevel, WorldObject::GetCollisionHeight(), GetLiquidData(), WorldObject::GetMinHeightInWater(), WorldObject::GetPhaseMask(), INVALID_HEIGHT, LiquidData::Level, MAP_ALL_LIQUIDS, MAP_LIQUID_STATUS_SWIMMING, and LiquidData::Status.

Referenced by CanReachPositionAndGetValidCoords().

◆ HasEnoughWater() [2/2]

bool Map::HasEnoughWater	(	WorldObject const *	searcher,
		LiquidData const &	liquidData
	)		const

◆ HavePlayers()

bool Map::HavePlayers ( ) const

inline

315{ return !m_mapRefMgr.IsEmpty(); }

References LinkedListHead::IsEmpty(), and m_mapRefMgr.

Referenced by InstanceMap::AfterPlayerUnlinkFromMap(), MapInstanced::CreateInstanceForPlayer(), GetDebugInfo(), instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::IsEncounterInProgress(), RemoveAllPlayers(), BattlegroundMap::RemoveAllPlayers(), InstanceMap::Reset(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SpawnGunship(), InstanceMap::UnloadAll(), instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::Update(), and npc_hor_lich_king::npc_hor_lich_kingAI::UpdateAI().

◆ InitializeObject() [1/3]

template<>

void Map::InitializeObject ( Creature * )

{
    //obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
}

◆ InitializeObject() [2/3]

template<>

void Map::InitializeObject ( GameObject * )

{
    //obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
}

◆ InitializeObject() [3/3]

template<class T >

void Map::InitializeObject ( T * obj )

private

304{

305}

Referenced by AddToMap().

◆ InitVisibilityDistance()

void Map::InitVisibilityDistance ( )

virtual

Reimplemented in InstanceMap, BattlegroundMap, and MapInstanced.

{
    //init visibility for continents
    m_VisibleDistance = World::GetMaxVisibleDistanceOnContinents();
 
    switch (GetId())
    {
        case MAP_EBON_HOLD: // Scarlet Enclave (DK starting zone)
            m_VisibleDistance = 125.0f;
            break;
        case MAP_SCOTT_TEST: // (box map)
            m_VisibleDistance = 200.0f;
            break;
    }
}

References GetId(), World::GetMaxVisibleDistanceOnContinents(), m_VisibleDistance, MAP_EBON_HOLD, and MAP_SCOTT_TEST.

Referenced by MapInstanced::InitVisibilityDistance(), and Map().

◆ InsertGameObjectModel()

void Map::InsertGameObjectModel ( const GameObjectModel & model )

inline

398{ _dynamicTree.insert(model); }

DynamicMapTree::insert

void insert(const GameObjectModel &)

Definition DynamicTree.cpp:117

References _dynamicTree, and DynamicMapTree::insert().

Referenced by GameObject::AddToWorld(), GameObject::UpdateModel(), and GameObject::UpdateModelPosition().

◆ Instanceable()

bool Map::Instanceable ( ) const

inline

289{ return i_mapEntry && i_mapEntry->Instanceable(); }

MapEntry::Instanceable

bool Instanceable() const

Definition DBCStructure.h:1354

References i_mapEntry, and MapEntry::Instanceable().

Referenced by ObjectMgr::AddCreData(), ObjectMgr::AddGOData(), Vehicle::ApplyAllImmunities(), ApplyDynamicModeRespawnScaling(), ArenaSeasonMgr::BroadcastUpdatedWorldState(), MapMgr::CreateMap(), MapMgr::FindBaseNonInstanceMap(), MapMgr::FindMap(), GameEventMgr::GameEventSpawn(), MapMgr::GetNumInstances(), MapMgr::GetNumPlayersInInstances(), go_commandscript::HandleGoZoneXYCommand(), misc_commandscript::HandleGroupSummonCommand(), AuraEffect::HandleModInvisibility(), AuraEffect::HandleModStealth(), AuraEffect::HandlePhase(), AuraEffect::HandlePreventResurrection(), ArenaSpectator::HandleSpectatorSpectateCommand(), misc_commandscript::HandleSummonCommand(), OutdoorPvP::SetMapFromZone(), ToMapInstanced(), ToMapInstanced(), and UpdateCreatureHalaa().

◆ Is25ManRaid()

bool Map::Is25ManRaid ( ) const

inline

295{ return IsRaid() && i_spawnMode & RAID_DIFFICULTY_MASK_25MAN; } // since 25man difficulties are 1 and 3, we can check them like that

RAID_DIFFICULTY_MASK_25MAN

#define RAID_DIFFICULTY_MASK_25MAN

Definition DBCEnums.h:279

Map::IsRaid

bool IsRaid() const

Definition Map.h:292

References i_spawnMode, IsRaid(), and RAID_DIFFICULTY_MASK_25MAN.

Referenced by boss_thorim::boss_thorimAI::DamageTaken(), boss_yoggsaron_sara::boss_yoggsaron_saraAI::DoAction(), spell_archavon_rock_shards::HandleScript(), instance_ulduar::instance_ulduar_InstanceMapScript::instance_ulduar_InstanceMapScript(), spell_the_lich_king_vile_spirits_aura::Load(), AchievementCriteriaData::Meets(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnGameObjectCreate(), AreaTrigger_at_celestial_planetarium_enterance::OnTrigger(), npc_frostwing_vrykul::npc_frostwing_vrykulAI::Reset(), npc_gunship::npc_gunshipAI::SetGUID(), instance_ulduar::instance_ulduar_InstanceMapScript::SpawnLeviathanEncounterVehicles(), boss_prince_valanar_icc::boss_prince_valanarAI::UpdateAI(), npc_icc_valkyr_herald::npc_icc_valkyr_heraldAI::UpdateAI(), boss_grobbulus_poison_cloud::boss_grobbulus_poison_cloudAI::UpdateAI(), boss_freya::boss_freyaAI::UpdateAI(), boss_freya_lifebinder::boss_freya_lifebinderAI::UpdateAI(), boss_freya_nature_bomb::boss_freya_nature_bombAI::UpdateAI(), boss_vezax::boss_vezaxAI::UpdateAI(), boss_yoggsaron_sara::boss_yoggsaron_saraAI::UpdateAI(), and UpdateEncounterState().

◆ IsBattleArena()

bool Map::IsBattleArena ( ) const

inline

297{ return i_mapEntry && i_mapEntry->IsBattleArena(); }

MapEntry::IsBattleArena

bool IsBattleArena() const

Definition DBCStructure.h:1357

References i_mapEntry, and MapEntry::IsBattleArena().

Referenced by BattlegroundMap::AddPlayerToMap(), WorldSession::HandleEnterPlayerVehicle(), WorldSession::HandleMoveWorldportAck(), ArenaSpectator::HandleResetCommand(), spectator_commandscript::HandleSpectatorLeaveCommand(), ArenaSpectator::HandleSpectatorSpectateCommand(), ArenaSpectator::HandleSpectatorWatchCommand(), Unit::HandleSpellClick(), BattlegroundMap::InitVisibilityDistance(), Unit::PatchValuesUpdate(), and BattlegroundMap::RemovePlayerFromMap().

◆ IsBattleground()

bool Map::IsBattleground ( ) const

inline

296{ return i_mapEntry && i_mapEntry->IsBattleground(); }

MapEntry::IsBattleground

bool IsBattleground() const

Definition DBCStructure.h:1356

References i_mapEntry, and MapEntry::IsBattleground().

Referenced by SpellMgr::GetSpellIdForDifficulty(), and AuraEffect::HandleAuraDummy().

◆ IsBattlegroundOrArena()

bool Map::IsBattlegroundOrArena ( ) const

inline

298{ return i_mapEntry && i_mapEntry->IsBattlegroundOrArena(); }

MapEntry::IsBattlegroundOrArena

bool IsBattlegroundOrArena() const

Definition DBCStructure.h:1358

References i_mapEntry, and MapEntry::IsBattlegroundOrArena().

Referenced by Spell::CheckCast(), ConvertCorpseToBones(), MapInstanced::CreateBattleground(), MapInstanced::CreateInstanceForPlayer(), spell_dk_scourge_strike::HandleAfterHit(), misc_commandscript::HandleAppearCommand(), spell_dk_blood_caked_blade::HandleProc(), misc_commandscript::HandleSummonCommand(), isInLineOfSight(), DisableMgr::IsPathfindingEnabled(), Player::SetEntryPoint(), ToBattlegroundMap(), and ToBattlegroundMap().

◆ isCellMarked()

bool Map::isCellMarked ( uint32 pCellId )

inline

312{ return marked_cells.test(pCellId); }

Map::marked_cells

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP > marked_cells

Definition Map.h:574

References marked_cells.

◆ IsDungeon()

bool Map::IsDungeon ( ) const

inline

290{ return i_mapEntry && i_mapEntry->IsDungeon(); }

MapEntry::IsDungeon

bool IsDungeon() const

Definition DBCStructure.h:1352

References i_mapEntry, and MapEntry::IsDungeon().

Referenced by Group::_cancelHomebindIfInstance(), Group::_homebindIfInstance(), InstanceSaveMgr::_ResetOrWarnAll(), InstanceMap::AddPlayerToMap(), GameObject::AddToSkillupList(), Spell::CheckCast(), TransportMgr::CreateTransport(), Spell::DoAllEffectOnTarget(), ScriptedAI::DoTeleportAll(), CreatureAI::DoZoneInCombat(), Spell::EffectTeleportUnits(), SmartScript::FillScript(), Acore::XP::Gain(), WorldObject::GetInstanceScript(), Unit::GetMeleeAttackPoint(), SpellMgr::GetSpellIdForDifficulty(), misc_commandscript::HandleAppearCommand(), WorldSession::HandleAreaTriggerOpcode(), spell_freezing_circle::HandleDamage(), spell_item_nitro_boots::HandleDummy(), instance_commandscript::HandleInstanceSaveDataCommand(), WorldSession::HandleSetDungeonDifficultyOpcode(), WorldSession::HandleSetRaidDifficultyOpcode(), misc_commandscript::HandleSummonCommand(), InstanceSave::InsertToDB(), Player::IsAtGroupRewardDistance(), boss_ossirian::JustEngagedWith(), Unit::Kill(), WorldSession::LogoutPlayer(), Condition::Meets(), AchievementCriteriaData::Meets(), npc_image_of_medivh::npc_image_of_medivhAI::NextStep(), InstanceMap::PermBindAllPlayers(), SmartScript::ProcessAction(), boss_krystallus::boss_krystallusAI::RemoveStonedEffect(), CreatureTextMgr::SendChatPacket(), Player::SetEntryPoint(), Creature::SetLootRecipient(), lfg::LFGMgr::TeleportPlayer(), ToInstanceMap(), ToInstanceMap(), and AchievementMgr::UpdateAchievementCriteria().

◆ IsGridCreated() [1/2]

bool Map::IsGridCreated	(	float	x,
		float	y
	)		const

inline

    {
        return IsGridCreated(Acore::ComputeGridCoord(x, y));
    }

References Acore::ComputeGridCoord(), and IsGridCreated().

◆ IsGridCreated() [2/2]

bool Map::IsGridCreated ( GridCoord const & gridCoord ) const

{
    return _mapGridManager.IsGridCreated(gridCoord.x_coord, gridCoord.y_coord);
}

References _mapGridManager, MapGridManager::IsGridCreated(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by IsGridCreated().

◆ IsGridLoaded() [1/2]

bool Map::IsGridLoaded	(	float	x,
		float	y
	)		const

inline

    {
        return IsGridLoaded(Acore::ComputeGridCoord(x, y));
    }

References Acore::ComputeGridCoord(), and IsGridLoaded().

◆ IsGridLoaded() [2/2]

bool Map::IsGridLoaded ( GridCoord const & gridCoord ) const

{
    return _mapGridManager.IsGridLoaded(gridCoord.x_coord, gridCoord.y_coord);
}

References _mapGridManager, MapGridManager::IsGridLoaded(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by ObjectMgr::AddCreData(), ObjectMgr::AddGOData(), ConvertCorpseToBones(), GameEventMgr::GameEventSpawn(), IsGridLoaded(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::SetData(), UpdateCreatureHalaa(), and Visit().

◆ IsHeroic()

bool Map::IsHeroic ( ) const

inline

294{ return IsRaid() ? i_spawnMode >= RAID_DIFFICULTY_10MAN_HEROIC : i_spawnMode >= DUNGEON_DIFFICULTY_HEROIC; }

DUNGEON_DIFFICULTY_HEROIC

@ DUNGEON_DIFFICULTY_HEROIC

Definition DBCEnums.h:270

RAID_DIFFICULTY_10MAN_HEROIC

@ RAID_DIFFICULTY_10MAN_HEROIC

Definition DBCEnums.h:275

References DUNGEON_DIFFICULTY_HEROIC, i_spawnMode, IsRaid(), and RAID_DIFFICULTY_10MAN_HEROIC.

◆ isInLineOfSight()

bool Map::isInLineOfSight	(	float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2,
		uint32	phasemask,
		LineOfSightChecks	checks,
		VMAP::ModelIgnoreFlags	ignoreFlags
	)		const

{
    if (!sWorld->getBoolConfig(CONFIG_VMAP_BLIZZLIKE_PVP_LOS))
    {
        if (IsBattlegroundOrArena())
        {
            ignoreFlags = VMAP::ModelIgnoreFlags::Nothing;
        }
    }
 
    if (!sWorld->getBoolConfig(CONFIG_VMAP_BLIZZLIKE_LOS_OPEN_WORLD))
    {
        if (IsWorldMap())
        {
            ignoreFlags = VMAP::ModelIgnoreFlags::Nothing;
        }
    }
 
    if ((checks & LINEOFSIGHT_CHECK_VMAP) && !VMAP::VMapFactory::createOrGetVMapMgr()->isInLineOfSight(GetId(), x1, y1, z1, x2, y2, z2, ignoreFlags))
    {
        return false;
    }
 
    if (sWorld->getBoolConfig(CONFIG_CHECK_GOBJECT_LOS) && (checks & LINEOFSIGHT_CHECK_GOBJECT_ALL))
    {
        ignoreFlags = VMAP::ModelIgnoreFlags::Nothing;
        if (!(checks & LINEOFSIGHT_CHECK_GOBJECT_M2))
        {
            ignoreFlags = VMAP::ModelIgnoreFlags::M2;
        }
 
        if (!_dynamicTree.isInLineOfSight(x1, y1, z1, x2, y2, z2, phasemask, ignoreFlags))
        {
            return false;
        }
    }
 
    return true;
}

References _dynamicTree, CONFIG_CHECK_GOBJECT_LOS, CONFIG_VMAP_BLIZZLIKE_LOS_OPEN_WORLD, CONFIG_VMAP_BLIZZLIKE_PVP_LOS, VMAP::VMapFactory::createOrGetVMapMgr(), GetId(), IsBattlegroundOrArena(), isInLineOfSight(), DynamicMapTree::isInLineOfSight(), IsWorldMap(), LINEOFSIGHT_CHECK_GOBJECT_ALL, LINEOFSIGHT_CHECK_GOBJECT_M2, LINEOFSIGHT_CHECK_VMAP, VMAP::M2, VMAP::Nothing, and sWorld.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), isInLineOfSight(), WorldObject::IsWithinLOS(), WorldObject::IsWithinLOSInMap(), npc_ulduar_snow_mound::MoveInLineOfSight(), spell_blood_council_summon_shadow_resonance::SetDest(), and PathGenerator::ShortenPathUntilDist().

◆ IsInWater()

bool Map::IsInWater	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		float	collisionHeight
	)		const

{
    LiquidData const& liquidData = const_cast<Map*>(this)->GetLiquidData(phaseMask, x, y, pZ, collisionHeight, MAP_ALL_LIQUIDS);
    return (liquidData.Status & MAP_LIQUID_STATUS_SWIMMING) != 0;
}

References GetLiquidData(), MAP_ALL_LIQUIDS, MAP_LIQUID_STATUS_SWIMMING, and LiquidData::Status.

Referenced by CheckCollisionAndGetValidCoords(), ConfusedMovementGenerator< T >::DoInitialize(), PathGenerator::IsSwimmableSegment(), and Spell::SelectImplicitCasterDestTargets().

◆ IsNonRaidDungeon()

bool Map::IsNonRaidDungeon ( ) const

inline

291{ return i_mapEntry && i_mapEntry->IsNonRaidDungeon(); }

MapEntry::IsNonRaidDungeon

bool IsNonRaidDungeon() const

Definition DBCStructure.h:1353

References i_mapEntry, and MapEntry::IsNonRaidDungeon().

Referenced by WorldSession::HandleSetDungeonDifficultyOpcode(), and Player::RewardReputation().

◆ IsRaid()

bool Map::IsRaid ( ) const

inline

292{ return i_mapEntry && i_mapEntry->IsRaid(); }

MapEntry::IsRaid

bool IsRaid() const

Definition DBCStructure.h:1355

References i_mapEntry, and MapEntry::IsRaid().

Referenced by Group::_cancelHomebindIfInstance(), InstanceMap::CannotEnter(), Creature::CreateFromProto(), MapInstanced::CreateInstanceForPlayer(), misc_commandscript::HandleAppearCommand(), WorldSession::HandleSetRaidDifficultyOpcode(), Creature::InitEntry(), InstanceMap::InstanceMap(), Is25ManRaid(), IsHeroic(), IsRaidOrHeroicDungeon(), LogEncounterFinished(), AchievementCriteriaData::Meets(), InstanceMap::SendResetWarnings(), and AchievementMgr::UpdateAchievementCriteria().

◆ IsRaidOrHeroicDungeon()

bool Map::IsRaidOrHeroicDungeon ( ) const

inline

293{ return IsRaid() || i_spawnMode > DUNGEON_DIFFICULTY_NORMAL; }

DUNGEON_DIFFICULTY_NORMAL

@ DUNGEON_DIFFICULTY_NORMAL

Definition DBCEnums.h:269

References DUNGEON_DIFFICULTY_NORMAL, i_spawnMode, and IsRaid().

Referenced by Unit::Kill(), and WorldSession::LogoutPlayer().

◆ IsRegularDifficulty()

bool Map::IsRegularDifficulty ( ) const

inline

286{ return GetDifficulty() == REGULAR_DIFFICULTY; }

REGULAR_DIFFICULTY

@ REGULAR_DIFFICULTY

Definition DBCEnums.h:267

References GetDifficulty(), and REGULAR_DIFFICULTY.

◆ IsUnderWater()

bool Map::IsUnderWater	(	uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		float	collisionHeight
	)		const

{
    LiquidData const& liquidData = const_cast<Map*>(this)->GetLiquidData(phaseMask, x, y, z, collisionHeight, MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN);
    return liquidData.Status == LIQUID_MAP_UNDER_WATER;
}

References GetLiquidData(), LIQUID_MAP_UNDER_WATER, MAP_LIQUID_TYPE_OCEAN, MAP_LIQUID_TYPE_WATER, and LiquidData::Status.

Referenced by WorldSession::HandleMovementOpcodes().

◆ IsWorldMap()

bool Map::IsWorldMap ( ) const

inline

299{ return i_mapEntry && i_mapEntry->IsWorldMap(); }

MapEntry::IsWorldMap

bool IsWorldMap() const

Definition DBCStructure.h:1359

References i_mapEntry, and MapEntry::IsWorldMap().

Referenced by isInLineOfSight().

◆ LoadAllGrids()

void Map::LoadAllGrids ( )

{
    for (uint32 cellX = 0; cellX < TOTAL_NUMBER_OF_CELLS_PER_MAP; cellX++)
        for (uint32 cellY = 0; cellY < TOTAL_NUMBER_OF_CELLS_PER_MAP; cellY++)
            LoadGrid((cellX + 0.5f - CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL, (cellY + 0.5f - CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL);
}

References CENTER_GRID_CELL_ID, LoadGrid(), SIZE_OF_GRID_CELL, and TOTAL_NUMBER_OF_CELLS_PER_MAP.

Referenced by MapPreloadRequest::call(), OnCreateMap(), and World::SetInitialWorldSettings().

◆ LoadCorpseData()

void Map::LoadCorpseData ( )

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CORPSES);
    stmt->SetData(0, GetId());
    stmt->SetData(1, GetInstanceId());
 
    //        0     1     2     3            4      5          6          7       8       9        10     11        12    13          14          15         16
    // SELECT posX, posY, posZ, orientation, mapId, displayId, itemCache, bytes1, bytes2, guildId, flags, dynFlags, time, corpseType, instanceId, phaseMask, guid FROM corpse WHERE mapId = ? AND instanceId = ?
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
    if (!result)
        return;
 
    do
    {
        Field* fields = result->Fetch();
        CorpseType type = CorpseType(fields[13].Get<uint8>());
        uint32 guid = fields[16].Get<uint32>();
        if (type >= MAX_CORPSE_TYPE || type == CORPSE_BONES)
        {
            LOG_ERROR("maps", "Corpse (guid: {}) have wrong corpse type ({}), not loading.", guid, type);
            continue;
        }
 
        Corpse* corpse = new Corpse(type);
 
        if (!corpse->LoadCorpseFromDB(GenerateLowGuid<HighGuid::Corpse>(), fields))
        {
            delete corpse;
            continue;
        }
 
        AddCorpse(corpse);
 
        corpse->UpdatePositionData();
    } while (result->NextRow());
}

References AddCorpse(), CHAR_SEL_CORPSES, CharacterDatabase, CORPSE_BONES, Field::Get(), GetId(), GetInstanceId(), Corpse::LoadCorpseFromDB(), LOG_ERROR, MAX_CORPSE_TYPE, PreparedStatementBase::SetData(), and WorldObject::UpdatePositionData().

Referenced by MapMgr::CreateBaseMap().

◆ LoadGrid()

void Map::LoadGrid	(	float	x,
		float	y
	)

{
    EnsureGridLoaded(Cell(x, y));
}

References EnsureGridLoaded().

Referenced by CinematicMgr::BeginCinematic(), MotionTransport::DelayedTeleportTransport(), npc_thrall_warchief::npc_thrall_warchiefAI::DoAction(), WorldSession::HandleMoveWorldportAck(), LoadAllGrids(), FlightPathMovementGenerator::PreloadEndGrid(), SmartScript::ProcessAction(), Vehicle::TeleportVehicle(), MotionTransport::UpdatePosition(), and StaticTransport::UpdatePosition().

◆ LoadGridsInRange()

void Map::LoadGridsInRange	(	Position const &	center,
		float	radius
	)

{
    if (_mapGridManager.IsGridsFullyLoaded())
        return;
 
    float const x = center.GetPositionX();
    float const y = center.GetPositionY();
 
    CellCoord cellCoord(Acore::ComputeCellCoord(x, y));
    if (!cellCoord.IsCoordValid())
        return;
 
    if (radius > SIZE_OF_GRIDS)
        radius = SIZE_OF_GRIDS;
 
    CellArea area = Cell::CalculateCellArea(x, y, radius);
    if (!area)
        return;
 
    for (uint32 x = area.low_bound.x_coord; x <= area.high_bound.x_coord; ++x)
    {
        for (uint32 y = area.low_bound.y_coord; y <= area.high_bound.y_coord; ++y)
        {
            CellCoord cellCoord(x, y);
            Cell cell(cellCoord);
            EnsureGridLoaded(cell);
        }
    }
}

References _mapGridManager, Cell::CalculateCellArea(), Acore::ComputeCellCoord(), EnsureGridLoaded(), Position::GetPositionX(), Position::GetPositionY(), CellArea::high_bound, CoordPair< LIMIT >::IsCoordValid(), MapGridManager::IsGridsFullyLoaded(), CellArea::low_bound, SIZE_OF_GRIDS, CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by AddPlayerToMap(), and Unit::ExecuteDelayedUnitRelocationEvent().

◆ LoadRespawnTimes()

void Map::LoadRespawnTimes ( )

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CREATURE_RESPAWNS);
    stmt->SetData(0, GetId());
    stmt->SetData(1, GetInstanceId());
    if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
    {
        do
        {
            Field* fields = result->Fetch();
            ObjectGuid::LowType lowguid = fields[0].Get<uint32>();
            uint32 respawnTime = fields[1].Get<uint32>();
 
            _creatureRespawnTimes[lowguid] = time_t(respawnTime);
        } while (result->NextRow());
    }
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GO_RESPAWNS);
    stmt->SetData(0, GetId());
    stmt->SetData(1, GetInstanceId());
    if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
    {
        do
        {
            Field* fields = result->Fetch();
            ObjectGuid::LowType lowguid = fields[0].Get<uint32>();
            uint32 respawnTime = fields[1].Get<uint32>();
 
            _goRespawnTimes[lowguid] = time_t(respawnTime);
        } while (result->NextRow());
    }
}

References _creatureRespawnTimes, _goRespawnTimes, CHAR_SEL_CREATURE_RESPAWNS, CHAR_SEL_GO_RESPAWNS, CharacterDatabase, Field::Get(), GetId(), GetInstanceId(), and PreparedStatementBase::SetData().

Referenced by MapMgr::CreateBaseMap().

◆ LogEncounterFinished()

void Map::LogEncounterFinished	(	EncounterCreditType	type,
		uint32	creditEntry
	)

{
    if (!IsRaid() || !GetEntry() || GetEntry()->Expansion() < 2) // only for wotlk raids, because logs take up tons of mysql memory
        return;
    InstanceMap* map = ToInstanceMap();
    if (!map)
        return;
    std::string playersInfo;
    char buffer[16384], buffer2[255];
    Map::PlayerList const& pl = map->GetPlayers();
    for (Map::PlayerList::const_iterator itr = pl.begin(); itr != pl.end(); ++itr)
        if (Player* p = itr->GetSource())
        {
            std::string auraStr;
            const Unit::AuraApplicationMap& a = p->GetAppliedAuras();
            for (auto iterator = a.begin(); iterator != a.end(); ++iterator)
            {
                snprintf(buffer2, 255, "%u(%u) ", iterator->first, iterator->second->GetEffectMask());
                auraStr += buffer2;
            }
 
            snprintf(buffer, 16384, "%s (%s, acc: %u, ip: %s, guild: %u), xyz: (%.1f, %.1f, %.1f), auras: %s\n",
                p->GetName().c_str(), p->GetGUID().ToString().c_str(), p->GetSession()->GetAccountId(), p->GetSession()->GetRemoteAddress().c_str(), p->GetGuildId(), p->GetPositionX(), p->GetPositionY(), p->GetPositionZ(), auraStr.c_str());
            playersInfo += buffer;
        }
    CleanStringForMysqlQuery(playersInfo);
    CharacterDatabase.Execute("INSERT INTO log_encounter VALUES(NOW(), {}, {}, {}, {}, '{}')", GetId(), (uint32)GetDifficulty(), type, creditEntry, playersInfo);
}

References MapRefMgr::begin(), CharacterDatabase, CleanStringForMysqlQuery(), MapRefMgr::end(), GetDifficulty(), GetEntry(), GetId(), GetPlayers(), IsRaid(), and ToInstanceMap().

Referenced by UpdateEncounterState().

◆ markCell()

void Map::markCell ( uint32 pCellId )

inline

313{ marked_cells.set(pCellId); }

References marked_cells.

Referenced by MarkNearbyCellsOf().

◆ MarkNearbyCellsOf()

void Map::MarkNearbyCellsOf ( WorldObject * obj )

{
    // Check for valid position
    if (!obj->IsPositionValid())
        return;
 
    // Update mobs/objects in ALL visible cells around object!
    CellArea area = Cell::CalculateCellArea(obj->GetPositionX(), obj->GetPositionY(), obj->GetGridActivationRange());
    for (uint32 x = area.low_bound.x_coord; x <= area.high_bound.x_coord; ++x)
    {
        for (uint32 y = area.low_bound.y_coord; y <= area.high_bound.y_coord; ++y)
        {
            // marked cells are those that have been visited
            uint32 cell_id = (y * TOTAL_NUMBER_OF_CELLS_PER_MAP) + x;
            markCell(cell_id);
        }
    }
}

References Cell::CalculateCellArea(), WorldObject::GetGridActivationRange(), Position::GetPositionX(), Position::GetPositionY(), CellArea::high_bound, Position::IsPositionValid(), CellArea::low_bound, markCell(), TOTAL_NUMBER_OF_CELLS_PER_MAP, CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by Update().

◆ MoveAllCreaturesInMoveList()

void Map::MoveAllCreaturesInMoveList ( )

{
    for (std::vector<Creature*>::iterator itr = _creaturesToMove.begin(); itr != _creaturesToMove.end(); ++itr)
    {
        Creature* c = *itr;
        if (c->FindMap() != this)
            continue;
 
        if (c->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
        {
            c->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
            continue;
        }
 
        c->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
        if (!c->IsInWorld())
            continue;
 
        Cell const& old_cell = c->GetCurrentCell();
        Cell new_cell(c->GetPositionX(), c->GetPositionY());
 
        c->RemoveFromGrid();
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
        AddToGrid(c, new_cell);
    }
    _creaturesToMove.clear();
}

References _creaturesToMove, MovableMapObject::_moveState, AddToGrid(), Cell::DiffGrid(), EnsureGridLoaded(), WorldObject::FindMap(), MovableMapObject::GetCurrentCell(), Position::GetPositionX(), Position::GetPositionY(), Object::IsInWorld(), MAP_OBJECT_CELL_MOVE_ACTIVE, MAP_OBJECT_CELL_MOVE_NONE, and GridObject< T >::RemoveFromGrid().

Referenced by Update().

◆ MoveAllDynamicObjectsInMoveList()

void Map::MoveAllDynamicObjectsInMoveList ( )

{
    for (std::vector<DynamicObject*>::iterator itr = _dynamicObjectsToMove.begin(); itr != _dynamicObjectsToMove.end(); ++itr)
    {
        DynamicObject* dynObj = *itr;
        if (dynObj->FindMap() != this)
            continue;
 
        if (dynObj->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
        {
            dynObj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
            continue;
        }
 
        dynObj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
        if (!dynObj->IsInWorld())
            continue;
 
        Cell const& old_cell = dynObj->GetCurrentCell();
        Cell new_cell(dynObj->GetPositionX(), dynObj->GetPositionY());
 
        dynObj->RemoveFromGrid();
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
        AddToGrid(dynObj, new_cell);
    }
    _dynamicObjectsToMove.clear();
}

References _dynamicObjectsToMove, MovableMapObject::_moveState, AddToGrid(), Cell::DiffGrid(), EnsureGridLoaded(), WorldObject::FindMap(), MovableMapObject::GetCurrentCell(), Position::GetPositionX(), Position::GetPositionY(), Object::IsInWorld(), MAP_OBJECT_CELL_MOVE_ACTIVE, MAP_OBJECT_CELL_MOVE_NONE, and GridObject< T >::RemoveFromGrid().

Referenced by Update().

◆ MoveAllGameObjectsInMoveList()

void Map::MoveAllGameObjectsInMoveList ( )

{
    for (std::vector<GameObject*>::iterator itr = _gameObjectsToMove.begin(); itr != _gameObjectsToMove.end(); ++itr)
    {
        GameObject* go = *itr;
        if (go->FindMap() != this)
            continue;
 
        if (go->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
        {
            go->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
            continue;
        }
 
        go->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
        if (!go->IsInWorld())
            continue;
 
        Cell const& old_cell = go->GetCurrentCell();
        Cell new_cell(go->GetPositionX(), go->GetPositionY());
 
        go->RemoveFromGrid();
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
        AddToGrid(go, new_cell);
    }
    _gameObjectsToMove.clear();
}

References _gameObjectsToMove, MovableMapObject::_moveState, AddToGrid(), Cell::DiffGrid(), EnsureGridLoaded(), WorldObject::FindMap(), MovableMapObject::GetCurrentCell(), Position::GetPositionX(), Position::GetPositionY(), Object::IsInWorld(), MAP_OBJECT_CELL_MOVE_ACTIVE, MAP_OBJECT_CELL_MOVE_NONE, and GridObject< T >::RemoveFromGrid().

Referenced by Update().

◆ OnCreateMap()

void Map::OnCreateMap ( )

{
    // Instances load all grids by default (both base map and child maps)
    if (GetInstanceId())
        LoadAllGrids();
 
    sScriptMgr->OnCreateMap(this);
}

References GetInstanceId(), LoadAllGrids(), and sScriptMgr.

Referenced by MapMgr::CreateBaseMap(), and MapInstanced::CreateBattleground().

◆ PlayDirectSoundToMap()

void Map::PlayDirectSoundToMap	(	uint32	soundId,
		uint32	zoneId = `0`
	)

{
    Map::PlayerList const& players = GetPlayers();
    if (!players.IsEmpty())
    {
        WorldPacket data(SMSG_PLAY_SOUND, 4);
        data << uint32(soundId);
 
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (Player* player = itr->GetSource())
                if (!zoneId || player->GetZoneId() == zoneId)
                    player->SendDirectMessage(&data);
    }
}

References MapRefMgr::begin(), MapRefMgr::end(), GetPlayers(), LinkedListHead::IsEmpty(), and SMSG_PLAY_SOUND.

Referenced by instance_naxxramas::Update().

◆ PlayerRelocation()

void Map::PlayerRelocation	(	Player *	player,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    Cell old_cell(player->GetPositionX(), player->GetPositionY());
    Cell new_cell(x, y);
 
    if (old_cell.DiffGrid(new_cell) || old_cell.DiffCell(new_cell))
    {
        player->RemoveFromGrid();
 
        if (old_cell.DiffGrid(new_cell))
            EnsureGridLoaded(new_cell);
 
        AddToGrid(player, new_cell);
    }
 
    player->Relocate(x, y, z, o);
    if (player->IsVehicle())
        player->GetVehicleKit()->RelocatePassengers();
    player->UpdatePositionData();
    player->UpdateObjectVisibility(false);
}

References AddToGrid(), Cell::DiffCell(), Cell::DiffGrid(), EnsureGridLoaded(), Position::GetPositionX(), Position::GetPositionY(), Unit::GetVehicleKit(), Unit::IsVehicle(), Position::Relocate(), Vehicle::RelocatePassengers(), GridObject< T >::RemoveFromGrid(), Player::UpdateObjectVisibility(), and WorldObject::UpdatePositionData().

Referenced by at_icc_saurfang_portal::OnTrigger(), StaticTransport::UpdatePassengerPositions(), MotionTransport::UpdatePassengerPositions(), and Unit::UpdatePosition().

◆ RemoveAllObjectsInRemoveList()

void Map::RemoveAllObjectsInRemoveList ( )

{
    while (!i_objectsToRemove.empty())
    {
        std::unordered_set<WorldObject*>::iterator itr = i_objectsToRemove.begin();
        WorldObject* obj = *itr;
        i_objectsToRemove.erase(itr);
 
        switch (obj->GetTypeId())
        {
            case TYPEID_CORPSE:
                {
                    Corpse* corpse = ObjectAccessor::GetCorpse(*obj, obj->GetGUID());
                    if (!corpse)
                        LOG_ERROR("maps", "Tried to delete corpse/bones {} that is not in map.", obj->GetGUID().ToString());
                    else
                        RemoveFromMap(corpse, true);
                    break;
                }
            case TYPEID_DYNAMICOBJECT:
                RemoveFromMap((DynamicObject*)obj, true);
                break;
            case TYPEID_GAMEOBJECT:
                if (MotionTransport* transport = obj->ToGameObject()->ToMotionTransport())
                    RemoveFromMap(transport, true);
                else
                    RemoveFromMap(obj->ToGameObject(), true);
                break;
            case TYPEID_UNIT:
                // in case triggered sequence some spell can continue casting after prev CleanupsBeforeDelete call
                // make sure that like sources auras/etc removed before destructor start
                obj->ToCreature()->CleanupsBeforeDelete();
                RemoveFromMap(obj->ToCreature(), true);
                break;
            default:
                LOG_ERROR("maps", "Non-grid object (TypeId: {}) is in grid object remove list, ignored.", obj->GetTypeId());
                break;
        }
    }
}

References Unit::CleanupsBeforeDelete(), ObjectAccessor::GetCorpse(), Object::GetGUID(), Object::GetTypeId(), i_objectsToRemove, LOG_ERROR, RemoveFromMap(), Object::ToCreature(), Object::ToGameObject(), GameObject::ToMotionTransport(), ObjectGuid::ToString(), TYPEID_CORPSE, TYPEID_DYNAMICOBJECT, TYPEID_GAMEOBJECT, and TYPEID_UNIT.

Referenced by DelayedUpdate(), and MapGridManager::UnloadGrid().

◆ RemoveAllPlayers()

void Map::RemoveAllPlayers ( )

virtual

Reimplemented in BattlegroundMap.

{
    if (HavePlayers())
    {
        for (MapRefMgr::iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
        {
            Player* player = itr->GetSource();
            if (!player->IsBeingTeleportedFar())
            {
                // this is happening for bg
                LOG_ERROR("maps", "Map::UnloadAll: player {} is still in map {} during unload, this should not happen!", player->GetName(), GetId());
                player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation());
            }
        }
    }
}

References MapRefMgr::begin(), MapRefMgr::end(), GetId(), WorldObject::GetName(), Position::GetOrientation(), HavePlayers(), Player::IsBeingTeleportedFar(), LOG_ERROR, Player::m_homebindMapId, Player::m_homebindX, Player::m_homebindY, Player::m_homebindZ, m_mapRefMgr, and Player::TeleportTo().

◆ RemoveCorpse()

void Map::RemoveCorpse ( Corpse * corpse )

{
    ASSERT(corpse);
    GridCoord const gridCoord = Acore::ComputeGridCoord(corpse->GetPositionX(), corpse->GetPositionY());
 
    corpse->DestroyForNearbyPlayers();
    if (corpse->IsInGrid())
        RemoveFromMap(corpse, false);
    else
    {
        corpse->RemoveFromWorld();
        corpse->ResetMap();
    }
 
    _corpsesByGrid[gridCoord.GetId()].erase(corpse);
    if (corpse->GetType() != CORPSE_BONES)
        _corpsesByPlayer.erase(corpse->GetOwnerGUID());
    else
        _corpseBones.erase(corpse);
}

References _corpseBones, _corpsesByGrid, _corpsesByPlayer, ASSERT, Acore::ComputeGridCoord(), CORPSE_BONES, WorldObject::DestroyForNearbyPlayers(), CoordPair< LIMIT >::GetId(), Corpse::GetOwnerGUID(), Position::GetPositionX(), Position::GetPositionY(), Corpse::GetType(), GridObject< T >::IsInGrid(), RemoveFromMap(), Corpse::RemoveFromWorld(), and WorldObject::ResetMap().

Referenced by ConvertCorpseToBones(), and RemoveOldCorpses().

◆ RemoveCreatureFromMoveList()

void Map::RemoveCreatureFromMoveList ( Creature * c )

private

{
    if (c->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
        c->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
}

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by CreatureRelocation().

◆ RemoveCreatureRespawnTime()

void Map::RemoveCreatureRespawnTime ( ObjectGuid::LowType dbGuid )

{
    _creatureRespawnTimes.erase(spawnId);
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN);
    stmt->SetData(0, spawnId);
    stmt->SetData(1, GetId());
    stmt->SetData(2, GetInstanceId());
    CharacterDatabase.Execute(stmt);
}

References _creatureRespawnTimes, CHAR_DEL_CREATURE_RESPAWN, CharacterDatabase, GetId(), GetInstanceId(), and PreparedStatementBase::SetData().

Referenced by Creature::DeleteFromDB(), Creature::Respawn(), and SaveCreatureRespawnTime().

◆ RemoveDynamicObjectFromMoveList()

void Map::RemoveDynamicObjectFromMoveList ( DynamicObject * go )

private

{
    if (dynObj->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
        dynObj->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
}

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by DynamicObjectRelocation().

◆ RemoveFromActive() [1/4]

template<>

void Map::RemoveFromActive ( Creature * c )

{
    RemoveFromActiveHelper(c);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [2/4]

template<>

void Map::RemoveFromActive ( DynamicObject * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [3/4]

template<>

void Map::RemoveFromActive ( GameObject * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [4/4]

template<class T >

void Map::RemoveFromActive ( T * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

Referenced by RemoveFromMap(), RemoveFromMap(), and WorldObject::setActive().

◆ RemoveFromActiveHelper()

void Map::RemoveFromActiveHelper ( WorldObject * obj )

inlineprivate

    {
        // Map::Update for active object in proccess
        if (m_activeNonPlayersIter != m_activeNonPlayers.end())
        {
            ActiveNonPlayers::iterator itr = m_activeNonPlayers.find(obj);
            if (itr == m_activeNonPlayers.end())
                return;
            if (itr == m_activeNonPlayersIter)
                ++m_activeNonPlayersIter;
            m_activeNonPlayers.erase(itr);
        }
        else
            m_activeNonPlayers.erase(obj);
    }

References m_activeNonPlayers, and m_activeNonPlayersIter.

Referenced by RemoveFromActive(), RemoveFromActive(), RemoveFromActive(), and RemoveFromActive().

◆ RemoveFromMap() [1/2]

template<>

void Map::RemoveFromMap	(	MotionTransport *	obj,
		bool	remove
	)

{
    obj->RemoveFromWorld();
    if (obj->isActiveObject())
        RemoveFromActive(obj);
 
    Map::PlayerList const& players = GetPlayers();
    if (!players.IsEmpty())
    {
        UpdateData data;
        obj->BuildOutOfRangeUpdateBlock(&data);
        WorldPacket packet;
        data.BuildPacket(packet);
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (itr->GetSource()->GetTransport() != obj)
                itr->GetSource()->SendDirectMessage(&packet);
    }
 
    if (_transportsUpdateIter != _transports.end())
    {
        TransportsContainer::iterator itr = _transports.find(obj);
        if (itr == _transports.end())
            return;
        if (itr == _transportsUpdateIter)
            ++_transportsUpdateIter;
        _transports.erase(itr);
    }
    else
        _transports.erase(obj);
 
    obj->ResetMap();
 
    // Transports are never actually deleted, but it *should* be safe to clear
    // from update list when removing from world
    RemoveObjectFromMapUpdateList(obj);
 
    if (remove)
    {
        // if option set then object already saved at this moment
        if (!sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY))
            obj->SaveRespawnTime();
        DeleteFromWorld(obj);
    }
}

References _transports, _transportsUpdateIter, MapRefMgr::begin(), Object::BuildOutOfRangeUpdateBlock(), UpdateData::BuildPacket(), CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY, DeleteFromWorld(), MapRefMgr::end(), GetPlayers(), WorldObject::isActiveObject(), LinkedListHead::IsEmpty(), RemoveFromActive(), GameObject::RemoveFromWorld(), RemoveObjectFromMapUpdateList(), WorldObject::ResetMap(), GameObject::SaveRespawnTime(), and sWorld.

◆ RemoveFromMap() [2/2]

template<class T >

void Map::RemoveFromMap	(	T *	obj,
		bool	remove
	)

{
    bool inWorld = obj->IsInWorld() && obj->GetTypeId() >= TYPEID_UNIT && obj->GetTypeId() <= TYPEID_GAMEOBJECT;
    obj->RemoveFromWorld();
 
    if (obj->isActiveObject())
        RemoveFromActive(obj);
 
    if (!inWorld) // pussywizard: if was in world, RemoveFromWorld() called DestroyForNearbyPlayers()
        obj->DestroyForNearbyPlayers(); // pussywizard: previous player->UpdateObjectVisibility()
 
    obj->RemoveFromGrid();
 
    obj->ResetMap();
 
    if (remove)
    {
        RemoveObjectFromMapUpdateList(obj);
        DeleteFromWorld(obj);
    }
}

References DeleteFromWorld(), RemoveFromActive(), RemoveObjectFromMapUpdateList(), TYPEID_GAMEOBJECT, and TYPEID_UNIT.

Referenced by MotionTransport::DelayedTeleportTransport(), RemoveAllObjectsInRemoveList(), and RemoveCorpse().

◆ RemoveGameObjectFromMoveList()

void Map::RemoveGameObjectFromMoveList ( GameObject * go )

private

{
    if (go->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
        go->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
}

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by GameObjectRelocation().

◆ RemoveGameObjectModel()

void Map::RemoveGameObjectModel ( const GameObjectModel & model )

inline

397{ _dynamicTree.remove(model); }

DynamicMapTree::remove

void remove(const GameObjectModel &)

Definition DynamicTree.cpp:122

References _dynamicTree, and DynamicMapTree::remove().

Referenced by GameObject::RemoveFromWorld(), GameObject::UpdateModel(), and GameObject::UpdateModelPosition().

◆ RemoveGORespawnTime()

void Map::RemoveGORespawnTime ( ObjectGuid::LowType dbGuid )

{
    _goRespawnTimes.erase(spawnId);
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GO_RESPAWN);
    stmt->SetData(0, spawnId);
    stmt->SetData(1, GetId());
    stmt->SetData(2, GetInstanceId());
    CharacterDatabase.Execute(stmt);
}

References _goRespawnTimes, CHAR_DEL_GO_RESPAWN, CharacterDatabase, GetId(), GetInstanceId(), and PreparedStatementBase::SetData().

Referenced by GameObject::DeleteFromDB(), GameObject::LoadGameObjectFromDB(), GameObject::Respawn(), and SaveGORespawnTime().

◆ RemoveObjectFromMapUpdateList()

void Map::RemoveObjectFromMapUpdateList ( WorldObject * obj )

{
    if (!obj->CanBeAddedToMapUpdateList())
        return;
 
    UpdatableMapObject* mapUpdatableObject = dynamic_cast<UpdatableMapObject*>(obj);
    if (mapUpdatableObject->GetUpdateState() == UpdatableMapObject::UpdateState::PendingAdd)
        _pendingAddUpdatableObjectList.erase(obj);
    else if (mapUpdatableObject->GetUpdateState() == UpdatableMapObject::UpdateState::Updating)
        _RemoveObjectFromUpdateList(obj);
}

References _pendingAddUpdatableObjectList, _RemoveObjectFromUpdateList(), WorldObject::CanBeAddedToMapUpdateList(), UpdatableMapObject::GetUpdateState(), UpdatableMapObject::PendingAdd, and UpdatableMapObject::Updating.

Referenced by RemoveFromMap(), and RemoveFromMap().

◆ RemoveOldCorpses()

void Map::RemoveOldCorpses ( )

{
    time_t now = GameTime::GetGameTime().count();
 
    std::vector<ObjectGuid> corpses;
    corpses.reserve(_corpsesByPlayer.size());
 
    for (auto const& p : _corpsesByPlayer)
        if (p.second->IsExpired(now))
            corpses.push_back(p.first);
 
    for (ObjectGuid const& ownerGuid : corpses)
        ConvertCorpseToBones(ownerGuid);
 
    std::vector<Corpse*> expiredBones;
    for (Corpse* bones : _corpseBones)
        if (bones->IsExpired(now))
            expiredBones.push_back(bones);
 
    for (Corpse* bones : expiredBones)
    {
        RemoveCorpse(bones);
        delete bones;
    }
}

References _corpseBones, _corpsesByPlayer, ConvertCorpseToBones(), GameTime::GetGameTime(), and RemoveCorpse().

Referenced by World::Update().

◆ RemovePlayerFromMap()

void Map::RemovePlayerFromMap	(	Player *	player,
		bool	remove
	)

virtual

Reimplemented in InstanceMap, and BattlegroundMap.

{
    // Before leaving map, update zone/area for stats
    player->UpdateZone(MAP_INVALID_ZONE, 0);
    player->getHostileRefMgr().deleteReferences(true); // pussywizard: multithreading crashfix
 
    bool inWorld = player->IsInWorld();
    player->RemoveFromWorld();
    SendRemoveTransports(player);
 
    if (!inWorld) // pussywizard: if was in world, RemoveFromWorld() called DestroyForNearbyPlayers()
        player->DestroyForNearbyPlayers(); // pussywizard: previous player->UpdateObjectVisibility(true)
 
    if (player->IsInGrid())
        player->RemoveFromGrid();
    else
        ASSERT(remove); //maybe deleted in logoutplayer when player is not in a map
 
    sScriptMgr->OnPlayerLeaveMap(this, player);
    if (remove)
    {
        DeleteFromWorld(player);
    }
}

References ASSERT, DeleteFromWorld(), HostileRefMgr::deleteReferences(), WorldObject::DestroyForNearbyPlayers(), Unit::getHostileRefMgr(), GridObject< T >::IsInGrid(), Object::IsInWorld(), MAP_INVALID_ZONE, GridObject< T >::RemoveFromGrid(), Player::RemoveFromWorld(), SendRemoveTransports(), sScriptMgr, and Player::UpdateZone().

Referenced by WorldSession::HandleMoveWorldportAck(), WorldSession::HandleSetRaidDifficultyOpcode(), InstanceMap::RemovePlayerFromMap(), BattlegroundMap::RemovePlayerFromMap(), and Player::TeleportTo().

◆ RemoveUpdateObject()

void Map::RemoveUpdateObject ( Object * obj )

inline

    {
        _updateObjects.erase(obj);
    }

References _updateObjects.

Referenced by DeleteFromWorld(), and WorldObject::RemoveFromObjectUpdate().

◆ RemoveWorldObject()

void Map::RemoveWorldObject ( WorldObject * obj )

inline

319{ i_worldObjects.erase(obj); }

References i_worldObjects.

Referenced by WorldObject::ResetMap().

◆ resetMarkedCells()

void Map::resetMarkedCells ( )

inline

311{ marked_cells.reset(); }

References marked_cells.

Referenced by Update().

◆ SaveCreatureRespawnTime()

void Map::SaveCreatureRespawnTime	(	ObjectGuid::LowType	dbGuid,
		time_t &	respawnTime
	)

{
    if (!respawnTime)
    {
        // Delete only
        RemoveCreatureRespawnTime(spawnId);
        return;
    }
 
    time_t now = GameTime::GetGameTime().count();
    if (GetInstanceResetPeriod() > 0 && respawnTime - now + 5 >= GetInstanceResetPeriod())
        respawnTime = now + YEAR;
 
    _creatureRespawnTimes[spawnId] = respawnTime;
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CREATURE_RESPAWN);
    stmt->SetData(0, spawnId);
    stmt->SetData(1, uint32(respawnTime));
    stmt->SetData(2, GetId());
    stmt->SetData(3, GetInstanceId());
    CharacterDatabase.Execute(stmt);
}

References _creatureRespawnTimes, CHAR_REP_CREATURE_RESPAWN, CharacterDatabase, GameTime::GetGameTime(), GetId(), GetInstanceId(), GetInstanceResetPeriod(), RemoveCreatureRespawnTime(), PreparedStatementBase::SetData(), and YEAR.

Referenced by Creature::SaveRespawnTime().

◆ SaveGORespawnTime()

void Map::SaveGORespawnTime	(	ObjectGuid::LowType	dbGuid,
		time_t &	respawnTime
	)

{
    if (!respawnTime)
    {
        // Delete only
        RemoveGORespawnTime(spawnId);
        return;
    }
 
    time_t now = GameTime::GetGameTime().count();
    if (GetInstanceResetPeriod() > 0 && respawnTime - now + 5 >= GetInstanceResetPeriod())
        respawnTime = now + YEAR;
 
    _goRespawnTimes[spawnId] = respawnTime;
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_GO_RESPAWN);
    stmt->SetData(0, spawnId);
    stmt->SetData(1, uint32(respawnTime));
    stmt->SetData(2, GetId());
    stmt->SetData(3, GetInstanceId());
    CharacterDatabase.Execute(stmt);
}

References _goRespawnTimes, CHAR_REP_GO_RESPAWN, CharacterDatabase, GameTime::GetGameTime(), GetId(), GetInstanceId(), GetInstanceResetPeriod(), RemoveGORespawnTime(), PreparedStatementBase::SetData(), and YEAR.

Referenced by GameObject::SaveRespawnTime().

◆ ScheduleCreatureRespawn()

void Map::ScheduleCreatureRespawn	(	ObjectGuid	creatureGuid,
		Milliseconds	respawnTimer,
		Position	pos = `Position()`
	)

{
    _creatureRespawnScheduler.Schedule(respawnTimer, [this, creatureGuid, pos](TaskContext)
    {
        if (Creature* creature = GetCreature(creatureGuid))
            creature->Respawn();
        else
            SummonCreature(creatureGuid.GetEntry(), pos);
    });
}

References _creatureRespawnScheduler, GetCreature(), ObjectGuid::GetEntry(), TaskScheduler::Schedule(), and SummonCreature().

Referenced by Creature::DespawnOnEvade(), and Creature::ForcedDespawn().

◆ ScriptCommandStart()

void Map::ScriptCommandStart	(	ScriptInfo const &	script,
		uint32	delay,
		Object *	source,
		Object *	target
	)

If effects should be immediate, launch the script execution

{
    // NOTE: script record _must_ exist until command executed
 
    // prepare static data
    ObjectGuid sourceGUID = source ? source->GetGUID() : ObjectGuid::Empty;
    ObjectGuid targetGUID = target ? target->GetGUID() : ObjectGuid::Empty;
    ObjectGuid ownerGUID  = (source && source->IsItem()) ? ((Item*)source)->GetOwnerGUID() : ObjectGuid::Empty;
 
    ScriptAction sa;
    sa.sourceGUID = sourceGUID;
    sa.targetGUID = targetGUID;
    sa.ownerGUID  = ownerGUID;
 
    sa.script = &script;
    m_scriptSchedule.insert(ScriptScheduleMap::value_type(time_t(GameTime::GetGameTime().count() + delay), sa));
 
    sScriptMgr->IncreaseScheduledScriptsCount();
 
    if (delay == 0 && !i_scriptLock)
    {
        i_scriptLock = true;
        ScriptsProcess();
        i_scriptLock = false;
    }
}

References ObjectGuid::Empty, GameTime::GetGameTime(), Object::GetGUID(), i_scriptLock, Object::IsItem(), m_scriptSchedule, ScriptAction::ownerGUID, ScriptAction::script, ScriptsProcess(), ScriptAction::sourceGUID, sScriptMgr, and ScriptAction::targetGUID.

◆ ScriptsProcess()

void Map::ScriptsProcess ( )

private

Process queued scripts.

Process overdue queued scripts

Todo:: : Allow gameobjects to be targets and casters

{
    if (m_scriptSchedule.empty())
        return;
 
    ScriptScheduleMap::iterator iter = m_scriptSchedule.begin();
    // ok as multimap is a *sorted* associative container
    while (!m_scriptSchedule.empty() && (iter->first <= GameTime::GetGameTime().count()))
    {
        ScriptAction const& step = iter->second;
 
        Object* source = nullptr;
        if (step.sourceGUID)
        {
            switch (step.sourceGUID.GetHigh())
            {
                case HighGuid::Item: // as well as HIGHGUID_CONTAINER
                    if (Player* player = ObjectAccessor::GetPlayer(this, step.ownerGUID))
                        source = player->GetItemByGuid(step.sourceGUID);
                    break;
                case HighGuid::Unit:
                case HighGuid::Vehicle:
                    source = GetCreature(step.sourceGUID);
                    break;
                case HighGuid::Pet:
                    source = GetPet(step.sourceGUID);
                    break;
                case HighGuid::Player:
                    source = HashMapHolder<Player>::Find(step.sourceGUID);
                    break;
                case HighGuid::Transport:
                case HighGuid::GameObject:
                    source = GetGameObject(step.sourceGUID);
                    break;
                case HighGuid::Corpse:
                    source = GetCorpse(step.sourceGUID);
                    break;
                case HighGuid::Mo_Transport:
                    source = GetTransport(step.sourceGUID);
                    break;
                default:
                    LOG_ERROR("maps.script", "{} source with unsupported high guid ({}).",
                                   step.script->GetDebugInfo(), step.sourceGUID.ToString());
                    break;
            }
        }
 
        WorldObject* target = nullptr;
        if (step.targetGUID)
        {
            switch (step.targetGUID.GetHigh())
            {
                case HighGuid::Unit:
                case HighGuid::Vehicle:
                    target = GetCreature(step.targetGUID);
                    break;
                case HighGuid::Pet:
                    target = GetPet(step.targetGUID);
                    break;
                case HighGuid::Player:                       // empty GUID case also
                    target = HashMapHolder<Player>::Find(step.targetGUID);
                    break;
                case HighGuid::Transport:
                case HighGuid::GameObject:
                    target = GetGameObject(step.targetGUID);
                    break;
                case HighGuid::Corpse:
                    target = GetCorpse(step.targetGUID);
                    break;
                case HighGuid::Mo_Transport:
                    target = GetTransport(step.targetGUID);
                    break;
                default:
                    LOG_ERROR("maps.script", "{} target with unsupported high guid ({}).",
                                   step.script->GetDebugInfo(), step.targetGUID.ToString());
                    break;
            }
        }
 
        switch (step.script->command)
        {
            case SCRIPT_COMMAND_TALK:
            {
                if (step.script->Talk.ChatType > CHAT_TYPE_WHISPER && step.script->Talk.ChatType != CHAT_MSG_RAID_BOSS_WHISPER)
                {
                    LOG_ERROR("maps.script", "{} invalid chat type ({}) specified, skipping.", step.script->GetDebugInfo(), step.script->Talk.ChatType);
                    break;
                }
 
                if (step.script->Talk.Flags & SF_TALK_USE_PLAYER)
                {
                    source = _GetScriptPlayerSourceOrTarget(source, target, step.script);
                }
                else
                {
                    source = _GetScriptCreatureSourceOrTarget(source, target, step.script);
                }
 
                if (source)
                {
                    Unit* sourceUnit = source->ToUnit();
                    if (!sourceUnit)
                    {
                        LOG_ERROR("scripts", "{} source object ({}) is not an unit, skipping.", step.script->GetDebugInfo(), source->GetGUID().ToString());
                        break;
                    }
 
                    switch (step.script->Talk.ChatType)
                    {
                        case CHAT_TYPE_SAY:
                            sourceUnit->Say(step.script->Talk.TextID, target);
                            break;
                        case CHAT_TYPE_YELL:
                            sourceUnit->Yell(step.script->Talk.TextID, target);
                            break;
                        case CHAT_TYPE_TEXT_EMOTE:
                        case CHAT_TYPE_BOSS_EMOTE:
                            sourceUnit->TextEmote(step.script->Talk.TextID, target, step.script->Talk.ChatType == CHAT_TYPE_BOSS_EMOTE);
                            break;
                        case CHAT_TYPE_WHISPER:
                        case CHAT_MSG_RAID_BOSS_WHISPER:
                        {
                            Player* receiver = target ? target->ToPlayer() : nullptr;
                            if (!receiver)
                                LOG_ERROR("scripts", "{} attempt to whisper to non-player unit, skipping.", step.script->GetDebugInfo());
                            else
                                sourceUnit->Whisper(step.script->Talk.TextID, receiver, step.script->Talk.ChatType == CHAT_MSG_RAID_BOSS_WHISPER);
                            break;
                        }
                        default:
                            break;                              // must be already checked at load
                    }
                }
                break;
            }
            case SCRIPT_COMMAND_EMOTE:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    if (step.script->Emote.Flags & SF_EMOTE_USE_STATE)
                        cSource->SetUInt32Value(UNIT_NPC_EMOTESTATE, step.script->Emote.EmoteID);
                    else
                        cSource->HandleEmoteCommand(step.script->Emote.EmoteID);
                }
                break;
 
            case SCRIPT_COMMAND_FIELD_SET:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FieldSet.FieldID <= OBJECT_FIELD_ENTRY || step.script->FieldSet.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FieldSet.FieldID, cSource->GetValuesCount(), cSource->GetGUID().ToString());
                    else
                        cSource->SetUInt32Value(step.script->FieldSet.FieldID, step.script->FieldSet.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_MOVE_TO:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    Unit* unit = (Unit*)cSource;
                    if (step.script->MoveTo.TravelTime != 0)
                    {
                        float speed = unit->GetDistance(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ) / ((float)step.script->MoveTo.TravelTime * 0.001f);
                        unit->MonsterMoveWithSpeed(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, speed);
                    }
                    else
                        unit->NearTeleportTo(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, unit->GetOrientation());
                }
                break;
 
            case SCRIPT_COMMAND_FLAG_SET:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FlagToggle.FieldID, cSource->GetValuesCount(), cSource->GetGUID().ToString());
                    else
                        cSource->SetFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_FLAG_REMOVE:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FlagToggle.FieldID, cSource->GetValuesCount(),  cSource->GetGUID().ToString());
                    else
                        cSource->RemoveFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_TELEPORT_TO:
                if (step.script->TeleportTo.Flags & SF_TELEPORT_USE_CREATURE)
                {
                    // Source or target must be Creature.
                    if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                        cSource->NearTeleportTo(step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                }
                else
                {
                    // Source or target must be Player.
                    if (Player* player = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                        player->TeleportTo(step.script->TeleportTo.MapID, step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                }
                break;
 
            case SCRIPT_COMMAND_QUEST_EXPLORED:
                {
                    if (!source)
                    {
                        LOG_ERROR("maps.script", "{} source object is nullptr.", step.script->GetDebugInfo());
                        break;
                    }
                    if (!target)
                    {
                        LOG_ERROR("maps.script", "{} target object is nullptr.", step.script->GetDebugInfo());
                        break;
                    }
 
                    // when script called for item spell casting then target == (unit or GO) and source is player
                    WorldObject* worldObject;
                    Player* player = target->ToPlayer();
                    if (player)
                    {
                        if (!source->IsCreature() && !source->IsGameObject() && !source->IsPlayer())
                        {
                            LOG_ERROR("maps.script", "{} source is not unit, gameobject or player ({}), skipping.", step.script->GetDebugInfo(), source->GetGUID().ToString());
                            break;
                        }
                        worldObject = dynamic_cast<WorldObject*>(source);
                    }
                    else
                    {
                        player = source->ToPlayer();
                        if (player)
                        {
                            if (!target->IsCreature() && !target->IsGameObject() && !target->IsPlayer())
                            {
                                LOG_ERROR("maps.script", "{} target is not unit, gameobject or player ({}), skipping.", step.script->GetDebugInfo(), target->GetGUID().ToString());
                                break;
                            }
                            worldObject = dynamic_cast<WorldObject*>(target);
                        }
                        else
                        {
                            LOG_ERROR("maps.script", "{} neither source nor target is player (source: {}; target: {}), skipping.",
                                           step.script->GetDebugInfo(), source->GetGUID().ToString(), target->GetGUID().ToString());
                            break;
                        }
                    }
 
                    // quest id and flags checked at script loading
                    if ((!worldObject->IsCreature() || ((Unit*)worldObject)->IsAlive()) &&
                            (step.script->QuestExplored.Distance == 0 || worldObject->IsWithinDistInMap(player, float(step.script->QuestExplored.Distance))))
                        player->GroupEventHappens(step.script->QuestExplored.QuestID, worldObject);
                    else
                        player->FailQuest(step.script->QuestExplored.QuestID);
 
                    break;
                }
 
            case SCRIPT_COMMAND_KILL_CREDIT:
                // Source or target must be Player.
                if (Player* player = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                {
                    if (step.script->KillCredit.Flags & SF_KILLCREDIT_REWARD_GROUP)
                        player->RewardPlayerAndGroupAtEvent(step.script->KillCredit.CreatureEntry, player);
                    else
                        player->KilledMonsterCredit(step.script->KillCredit.CreatureEntry);
                }
                break;
 
            case SCRIPT_COMMAND_RESPAWN_GAMEOBJECT:
                if (!step.script->RespawnGameobject.GOGuid)
                {
                    LOG_ERROR("maps.script", "{} gameobject guid (datalong) is not specified.", step.script->GetDebugInfo());
                    break;
                }
 
                // Source or target must be WorldObject.
                if (WorldObject* pSummoner = _GetScriptWorldObject(source, true, step.script))
                {
                    GameObject* pGO = _FindGameObject(pSummoner, step.script->RespawnGameobject.GOGuid);
                    if (!pGO)
                    {
                        LOG_ERROR("maps.script", "{} gameobject was not found (guid: {}).", step.script->GetDebugInfo(), step.script->RespawnGameobject.GOGuid);
                        break;
                    }
 
                    if (pGO->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE ||
                            pGO->GetGoType() == GAMEOBJECT_TYPE_DOOR        ||
                            pGO->GetGoType() == GAMEOBJECT_TYPE_BUTTON      ||
                            pGO->GetGoType() == GAMEOBJECT_TYPE_TRAP)
                    {
                        LOG_ERROR("maps.script", "{} can not be used with gameobject of type {} (guid: {}).",
                                       step.script->GetDebugInfo(), uint32(pGO->GetGoType()), step.script->RespawnGameobject.GOGuid);
                        break;
                    }
 
                    // Check that GO is not spawned
                    if (!pGO->isSpawned())
                    {
                        int32 nTimeToDespawn = std::max(5, int32(step.script->RespawnGameobject.DespawnDelay));
                        pGO->SetLootState(GO_READY);
                        pGO->SetRespawnTime(nTimeToDespawn);
 
                        pGO->GetMap()->AddToMap(pGO);
                    }
                }
                break;
 
            case SCRIPT_COMMAND_TEMP_SUMMON_CREATURE:
                {
                    // Source must be WorldObject.
                    if (WorldObject* pSummoner = _GetScriptWorldObject(source, true, step.script))
                    {
                        if (!step.script->TempSummonCreature.CreatureEntry)
                            LOG_ERROR("maps.script", "{} creature entry (datalong) is not specified.", step.script->GetDebugInfo());
                        else
                        {
                            uint32 entry = step.script->TempSummonCreature.CreatureEntry;
 
                            float x = step.script->TempSummonCreature.PosX;
                            float y = step.script->TempSummonCreature.PosY;
                            float z = step.script->TempSummonCreature.PosZ;
                            float o = step.script->TempSummonCreature.Orientation;
 
                            if (step.script->TempSummonCreature.CheckIfExists)
                                if (Unit* trigger = pSummoner->SummonTrigger(x, y, z, o, 1))
                                    if (trigger->FindNearestCreature(entry, 60.0f))
                                        break;
 
                            if (!pSummoner->SummonCreature(entry, x, y, z, o, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, step.script->TempSummonCreature.DespawnDelay))
                                LOG_ERROR("maps.script", "{} creature was not spawned (entry: {}).", step.script->GetDebugInfo(), step.script->TempSummonCreature.CreatureEntry);
                        }
                    }
                    break;
                }
 
            case SCRIPT_COMMAND_OPEN_DOOR:
            case SCRIPT_COMMAND_CLOSE_DOOR:
                _ScriptProcessDoor(source, target, step.script);
                break;
 
            case SCRIPT_COMMAND_ACTIVATE_OBJECT:
                // Source must be Unit.
                if (Unit* unit = _GetScriptUnit(source, true, step.script))
                {
                    // Target must be GameObject.
                    if (!target)
                    {
                        LOG_ERROR("maps.script", "{} target object is nullptr.", step.script->GetDebugInfo());
                        break;
                    }
 
                    if (!target->IsGameObject())
                    {
                        LOG_ERROR("maps.script", "{} target object is not gameobject ({}), skipping.", step.script->GetDebugInfo(), target->GetGUID().ToString());
                        break;
                    }
 
                    if (GameObject* pGO = target->ToGameObject())
                        pGO->Use(unit);
                }
                break;
 
            case SCRIPT_COMMAND_REMOVE_AURA:
                {
                    // Source (datalong2 != 0) or target (datalong2 == 0) must be Unit.
                    bool bReverse = step.script->RemoveAura.Flags & SF_REMOVEAURA_REVERSE;
                    if (Unit* unit = _GetScriptUnit(bReverse ? source : target, bReverse, step.script))
                        unit->RemoveAurasDueToSpell(step.script->RemoveAura.SpellID);
                    break;
                }
 
            case SCRIPT_COMMAND_CAST_SPELL:
                {
                    if (!source && !target)
                    {
                        LOG_ERROR("maps.script", "{} source and target objects are nullptr.", step.script->GetDebugInfo());
                        break;
                    }
 
                    Unit* uSource = nullptr;
                    Unit* uTarget = nullptr;
                    // source/target cast spell at target/source (script->datalong2: 0: s->t 1: s->s 2: t->t 3: t->s
                    switch (step.script->CastSpell.Flags)
                    {
                        case SF_CASTSPELL_SOURCE_TO_TARGET: // source -> target
                            uSource = source ? source->ToUnit() : nullptr;
                            uTarget = target ? target->ToUnit() : nullptr;
                            break;
                        case SF_CASTSPELL_SOURCE_TO_SOURCE: // source -> source
                            uSource = source ? source->ToUnit() : nullptr;
                            uTarget = uSource;
                            break;
                        case SF_CASTSPELL_TARGET_TO_TARGET: // target -> target
                            uSource = target ? target->ToUnit() : nullptr;
                            uTarget = uSource;
                            break;
                        case SF_CASTSPELL_TARGET_TO_SOURCE: // target -> source
                            uSource = target ? target->ToUnit() : nullptr;
                            uTarget = source ? source->ToUnit() : nullptr;
                            break;
                        case SF_CASTSPELL_SEARCH_CREATURE: // source -> creature with entry
                            uSource = source ? source->ToUnit() : nullptr;
                            uTarget = uSource ? GetClosestCreatureWithEntry(uSource, std::abs(step.script->CastSpell.CreatureEntry), step.script->CastSpell.SearchRadius) : nullptr;
                            break;
                    }
 
                    if (!uSource || !uSource->IsUnit())
                    {
                        LOG_ERROR("maps.script", "{} no source unit found for spell {}", step.script->GetDebugInfo(), step.script->CastSpell.SpellID);
                        break;
                    }
 
                    if (!uTarget || !uTarget->IsUnit())
                    {
                        LOG_ERROR("maps.script", "{} no target unit found for spell {}", step.script->GetDebugInfo(), step.script->CastSpell.SpellID);
                        break;
                    }
 
                    bool triggered = (step.script->CastSpell.Flags != 4) ?
                                     step.script->CastSpell.CreatureEntry & SF_CASTSPELL_TRIGGERED :
                                     step.script->CastSpell.CreatureEntry < 0;
                    uSource->CastSpell(uTarget, step.script->CastSpell.SpellID, triggered);
                    break;
                }
 
            case SCRIPT_COMMAND_PLAY_SOUND:
                // Source must be WorldObject.
                if (WorldObject* object = _GetScriptWorldObject(source, true, step.script))
                {
                    // Playsound.Flags bitmask: 0/1=anyone/target
                    Player* player = nullptr;
                    if (step.script->Playsound.Flags & SF_PLAYSOUND_TARGET_PLAYER)
                    {
                        // Target must be Player.
                        player = _GetScriptPlayer(target, false, step.script);
                        if (!target)
                            break;
                    }
 
                    // Playsound.Flags bitmask: 0/2/4=without/with distance dependent/radius
                    if (step.script->Playsound.Flags & SF_PLAYSOUND_DISTANCE_RADIUS)
                        object->PlayRadiusSound(step.script->Playsound.SoundID, step.script->Playsound.Radius);
                    else if (step.script->Playsound.Flags & SF_PLAYSOUND_DISTANCE_SOUND)
                        object->PlayDistanceSound(step.script->Playsound.SoundID, player);
                    else
                        object->PlayDirectSound(step.script->Playsound.SoundID, player);
                }
                break;
 
            case SCRIPT_COMMAND_CREATE_ITEM:
                // Target or source must be Player.
                if (Player* pReceiver = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                {
                    ItemPosCountVec dest;
                    InventoryResult msg = pReceiver->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, step.script->CreateItem.ItemEntry, step.script->CreateItem.Amount);
                    if (msg == EQUIP_ERR_OK)
                    {
                        if (Item* item = pReceiver->StoreNewItem(dest, step.script->CreateItem.ItemEntry, true))
                            pReceiver->SendNewItem(item, step.script->CreateItem.Amount, false, true);
                    }
                    else
                        pReceiver->SendEquipError(msg, nullptr, nullptr, step.script->CreateItem.ItemEntry);
                }
                break;
 
            case SCRIPT_COMMAND_DESPAWN_SELF:
                // Target or source must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                    cSource->DespawnOrUnsummon(step.script->DespawnSelf.DespawnDelay);
                break;
 
            case SCRIPT_COMMAND_LOAD_PATH:
                // Source must be Unit.
                if (Unit* unit = _GetScriptUnit(source, true, step.script))
                {
                    if (!sWaypointMgr->GetPath(step.script->LoadPath.PathID))
                        LOG_ERROR("maps.script", "{} source object has an invalid path ({}), skipping.", step.script->GetDebugInfo(), step.script->LoadPath.PathID);
                    else
                        unit->GetMotionMaster()->MovePath(step.script->LoadPath.PathID, step.script->LoadPath.IsRepeatable);
                }
                break;
 
            case SCRIPT_COMMAND_CALLSCRIPT_TO_UNIT:
                {
                    if (!step.script->CallScript.CreatureEntry)
                    {
                        LOG_ERROR("maps.script", "{} creature entry is not specified, skipping.", step.script->GetDebugInfo());
                        break;
                    }
                    if (!step.script->CallScript.ScriptID)
                    {
                        LOG_ERROR("maps.script", "{} script id is not specified, skipping.", step.script->GetDebugInfo());
                        break;
                    }
 
                    Creature* cTarget = nullptr;
                    auto creatureBounds = _creatureBySpawnIdStore.equal_range(step.script->CallScript.CreatureEntry);
                    if (creatureBounds.first != creatureBounds.second)
                    {
                        // Prefer alive (last respawned) creature
                        auto creatureItr = std::find_if(creatureBounds.first, creatureBounds.second, [](Map::CreatureBySpawnIdContainer::value_type const& pair)
                        {
                            return pair.second->IsAlive();
                        });
                        cTarget = creatureItr != creatureBounds.second ? creatureItr->second : creatureBounds.first->second;
                    }
 
                    if (!cTarget)
                    {
                        LOG_ERROR("maps.script", "{} target was not found (entry: {})", step.script->GetDebugInfo(), step.script->CallScript.CreatureEntry);
                        break;
                    }
 
                    //Lets choose our ScriptMap map
                    ScriptMapMap* datamap = GetScriptsMapByType(ScriptsType(step.script->CallScript.ScriptType));
                    //if no scriptmap present...
                    if (!datamap)
                    {
                        LOG_ERROR("maps.script", "{} unknown scriptmap ({}) specified, skipping.", step.script->GetDebugInfo(), step.script->CallScript.ScriptType);
                        break;
                    }
 
                    // Insert script into schedule but do not start it
                    ScriptsStart(*datamap, step.script->CallScript.ScriptID, cTarget, nullptr);
                    break;
                }
 
            case SCRIPT_COMMAND_KILL:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    if (cSource->isDead())
                        LOG_ERROR("maps.script", "{} creature is already dead ({})", step.script->GetDebugInfo(), cSource->GetGUID().ToString());
                    else
                    {
                        cSource->setDeathState(DeathState::JustDied);
                        if (step.script->Kill.RemoveCorpse == 1)
                            cSource->RemoveCorpse();
                    }
                }
                break;
 
            case SCRIPT_COMMAND_ORIENTATION:
                // Source must be Unit.
                if (Unit* sourceUnit = _GetScriptUnit(source, true, step.script))
                {
                    if (step.script->Orientation.Flags & SF_ORIENTATION_FACE_TARGET)
                    {
                        // Target must be Unit.
                        Unit* targetUnit = _GetScriptUnit(target, false, step.script);
                        if (!targetUnit)
                            break;
 
                        sourceUnit->SetFacingToObject(targetUnit);
                    }
                    else
                        sourceUnit->SetFacingTo(step.script->Orientation.Orientation);
                }
                break;
 
            case SCRIPT_COMMAND_EQUIP:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                    cSource->LoadEquipment(step.script->Equip.EquipmentID);
                break;
 
            case SCRIPT_COMMAND_MODEL:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                    cSource->SetDisplayId(step.script->Model.ModelID);
                break;
 
            case SCRIPT_COMMAND_CLOSE_GOSSIP:
                // Source must be Player.
                if (Player* player = _GetScriptPlayer(source, true, step.script))
                    player->PlayerTalkClass->SendCloseGossip();
                break;
 
            case SCRIPT_COMMAND_PLAYMOVIE:
                // Source must be Player.
                if (Player* player = _GetScriptPlayer(source, true, step.script))
                    player->SendMovieStart(step.script->PlayMovie.MovieID);
                break;
 
            case SCRIPT_COMMAND_MOVEMENT:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                {
                    if (!cSource->IsAlive())
                        return;
 
                    cSource->GetMotionMaster()->MovementExpired();
                    cSource->GetMotionMaster()->MoveIdle();
 
                    switch (step.script->Movement.MovementType)
                    {
                        case RANDOM_MOTION_TYPE:
                            cSource->GetMotionMaster()->MoveRandom((float)step.script->Movement.MovementDistance);
                            break;
                        case WAYPOINT_MOTION_TYPE:
                            cSource->GetMotionMaster()->MovePath(step.script->Movement.Path, false);
                            break;
                    }
                }
                break;
 
            default:
                LOG_ERROR("maps.script", "Unknown script command {}.", step.script->GetDebugInfo());
                break;
        }
 
        m_scriptSchedule.erase(iter);
        iter = m_scriptSchedule.begin();
        sScriptMgr->DecreaseScheduledScriptCount();
    }
}

References _creatureBySpawnIdStore, _FindGameObject(), _GetScriptCreature(), _GetScriptCreatureSourceOrTarget(), _GetScriptPlayer(), _GetScriptPlayerSourceOrTarget(), _GetScriptUnit(), _GetScriptWorldObject(), _ScriptProcessDoor(), AddToMap(), ScriptInfo::Amount, ScriptInfo::CallScript, Unit::CastSpell(), ScriptInfo::CastSpell, CHAT_MSG_RAID_BOSS_WHISPER, CHAT_TYPE_BOSS_EMOTE, CHAT_TYPE_SAY, CHAT_TYPE_TEXT_EMOTE, CHAT_TYPE_WHISPER, CHAT_TYPE_YELL, ScriptInfo::ChatType, ScriptInfo::CheckIfExists, ScriptInfo::command, Corpse, ScriptInfo::CreateItem, ScriptInfo::CreatureEntry, ScriptInfo::DespawnDelay, ScriptInfo::DespawnSelf, ScriptInfo::DestX, ScriptInfo::DestY, ScriptInfo::DestZ, ScriptInfo::Distance, ScriptInfo::Emote, ScriptInfo::EmoteID, ScriptInfo::Equip, EQUIP_ERR_OK, ScriptInfo::EquipmentID, Player::FailQuest(), ScriptInfo::FieldID, ScriptInfo::FieldSet, ScriptInfo::FieldValue, HashMapHolder< T >::Find(), ScriptInfo::Flags, ScriptInfo::FlagToggle, GameObject, GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_FISHINGNODE, GAMEOBJECT_TYPE_TRAP, GetClosestCreatureWithEntry(), GetCorpse(), GetCreature(), ScriptInfo::GetDebugInfo(), WorldObject::GetDistance(), GetGameObject(), GameTime::GetGameTime(), GameObject::GetGoType(), Object::GetGUID(), ObjectGuid::GetHigh(), WorldObject::GetMap(), Position::GetOrientation(), GetPet(), ObjectAccessor::GetPlayer(), GetScriptsMapByType(), GetTransport(), GO_READY, ScriptInfo::GOGuid, Player::GroupEventHappens(), Object::IsCreature(), Object::IsGameObject(), Object::IsPlayer(), ScriptInfo::IsRepeatable, GameObject::isSpawned(), Object::IsUnit(), WorldObject::IsWithinDistInMap(), Item, ScriptInfo::ItemEntry, JustDied, ScriptInfo::Kill, ScriptInfo::KillCredit, ScriptInfo::LoadPath, LOG_ERROR, m_scriptSchedule, ScriptInfo::MapID, Mo_Transport, ScriptInfo::Model, ScriptInfo::ModelID, Unit::MonsterMoveWithSpeed(), ScriptInfo::Movement, ScriptInfo::MovementDistance, ScriptInfo::MovementType, ScriptInfo::MoveTo, ScriptInfo::MovieID, Unit::NearTeleportTo(), NULL_BAG, NULL_SLOT, OBJECT_FIELD_ENTRY, ScriptInfo::Orientation, ScriptAction::ownerGUID, ScriptInfo::Path, ScriptInfo::PathID, Pet, Player, ScriptInfo::PlayMovie, ScriptInfo::Playsound, ScriptInfo::PosX, ScriptInfo::PosY, ScriptInfo::PosZ, ScriptInfo::QuestExplored, ScriptInfo::QuestID, ScriptInfo::Radius, RANDOM_MOTION_TYPE, ScriptInfo::RemoveAura, ScriptInfo::RemoveCorpse, ScriptInfo::RespawnGameobject, Unit::Say(), ScriptAction::script, SCRIPT_COMMAND_ACTIVATE_OBJECT, SCRIPT_COMMAND_CALLSCRIPT_TO_UNIT, SCRIPT_COMMAND_CAST_SPELL, SCRIPT_COMMAND_CLOSE_DOOR, SCRIPT_COMMAND_CLOSE_GOSSIP, SCRIPT_COMMAND_CREATE_ITEM, SCRIPT_COMMAND_DESPAWN_SELF, SCRIPT_COMMAND_EMOTE, SCRIPT_COMMAND_EQUIP, SCRIPT_COMMAND_FIELD_SET, SCRIPT_COMMAND_FLAG_REMOVE, SCRIPT_COMMAND_FLAG_SET, SCRIPT_COMMAND_KILL, SCRIPT_COMMAND_KILL_CREDIT, SCRIPT_COMMAND_LOAD_PATH, SCRIPT_COMMAND_MODEL, SCRIPT_COMMAND_MOVE_TO, SCRIPT_COMMAND_MOVEMENT, SCRIPT_COMMAND_OPEN_DOOR, SCRIPT_COMMAND_ORIENTATION, SCRIPT_COMMAND_PLAY_SOUND, SCRIPT_COMMAND_PLAYMOVIE, SCRIPT_COMMAND_QUEST_EXPLORED, SCRIPT_COMMAND_REMOVE_AURA, SCRIPT_COMMAND_RESPAWN_GAMEOBJECT, SCRIPT_COMMAND_TALK, SCRIPT_COMMAND_TELEPORT_TO, SCRIPT_COMMAND_TEMP_SUMMON_CREATURE, ScriptInfo::ScriptID, ScriptsStart(), ScriptInfo::ScriptType, ScriptInfo::SearchRadius, GameObject::SetLootState(), GameObject::SetRespawnTime(), SF_CASTSPELL_SEARCH_CREATURE, SF_CASTSPELL_SOURCE_TO_SOURCE, SF_CASTSPELL_SOURCE_TO_TARGET, SF_CASTSPELL_TARGET_TO_SOURCE, SF_CASTSPELL_TARGET_TO_TARGET, SF_CASTSPELL_TRIGGERED, SF_EMOTE_USE_STATE, SF_KILLCREDIT_REWARD_GROUP, SF_ORIENTATION_FACE_TARGET, SF_PLAYSOUND_DISTANCE_RADIUS, SF_PLAYSOUND_DISTANCE_SOUND, SF_PLAYSOUND_TARGET_PLAYER, SF_REMOVEAURA_REVERSE, SF_TALK_USE_PLAYER, SF_TELEPORT_USE_CREATURE, ScriptInfo::SoundID, ScriptAction::sourceGUID, ScriptInfo::SpellID, sScriptMgr, WorldObject::SummonTrigger(), sWaypointMgr, ScriptInfo::Talk, ScriptAction::targetGUID, ScriptInfo::TeleportTo, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, ScriptInfo::TempSummonCreature, Unit::TextEmote(), ScriptInfo::TextID, Object::ToGameObject(), Object::ToPlayer(), ObjectGuid::ToString(), Object::ToUnit(), Transport, ScriptInfo::TravelTime, Unit, UNIT_NPC_EMOTESTATE, Vehicle, WAYPOINT_MOTION_TYPE, Unit::Whisper(), and Unit::Yell().

Referenced by ScriptCommandStart(), ScriptsStart(), and Update().

◆ ScriptsStart()

void Map::ScriptsStart	(	std::map< uint32, std::multimap< uint32, ScriptInfo > > const &	scripts,
		uint32	id,
		Object *	source,
		Object *	target
	)

Put scripts in the execution queue.

Find the script map

Schedule script execution for all scripts in the script map

If one of the effects should be immediate, launch the script execution

{
    ScriptMapMap::const_iterator s = scripts.find(id);
    if (s == scripts.end())
        return;
 
    // prepare static data
    ObjectGuid sourceGUID = source ? source->GetGUID() : ObjectGuid::Empty; //some script commands doesn't have source
    ObjectGuid targetGUID = target ? target->GetGUID() : ObjectGuid::Empty;
    ObjectGuid ownerGUID  = (source && source->IsItem()) ? ((Item*)source)->GetOwnerGUID() : ObjectGuid::Empty;
 
    ScriptMap const* s2 = &(s->second);
    bool immedScript = false;
    for (ScriptMap::const_iterator iter = s2->begin(); iter != s2->end(); ++iter)
    {
        ScriptAction sa;
        sa.sourceGUID = sourceGUID;
        sa.targetGUID = targetGUID;
        sa.ownerGUID  = ownerGUID;
 
        sa.script = &iter->second;
        m_scriptSchedule.insert(ScriptScheduleMap::value_type(time_t(GameTime::GetGameTime().count() + iter->first), sa));
        if (iter->first == 0)
            immedScript = true;
 
        sScriptMgr->IncreaseScheduledScriptsCount();
    }
    if (/*start &&*/ immedScript && !i_scriptLock)
    {
        i_scriptLock = true;
        ScriptsProcess();
        i_scriptLock = false;
    }
}

References ObjectGuid::Empty, GameTime::GetGameTime(), Object::GetGUID(), i_scriptLock, Object::IsItem(), m_scriptSchedule, ScriptAction::ownerGUID, ScriptAction::script, ScriptsProcess(), ScriptAction::sourceGUID, sScriptMgr, and ScriptAction::targetGUID.

Referenced by MotionTransport::DoEventIfAny(), FlightPathMovementGenerator::DoEventIfAny(), WorldSession::DoLootRelease(), Spell::EffectDummy(), Spell::EffectScriptEffect(), Spell::EffectSendEvent(), WaypointMovementGenerator< Creature >::OnArrived(), ScriptsProcess(), and GameObject::Use().

◆ SendInitSelf()

void Map::SendInitSelf ( Player * player )

{
    LOG_DEBUG("maps", "Creating player data for himself {}", player->GetGUID().ToString());
 
    WorldPacket packet;
    UpdateData data;
 
    // attach to player data current transport data
    if (Transport* transport = player->GetTransport())
        transport->BuildCreateUpdateBlockForPlayer(&data, player);
 
    // build data for self presence in world at own client (one time for map)
    player->BuildCreateUpdateBlockForPlayer(&data, player);
 
    // build and send self update packet before sending to player his own auras
    data.BuildPacket(packet);
    player->SendDirectMessage(&packet);
 
    // send to player his own auras (this is needed here for timely initialization of some fields on client)
    player->GetAurasForTarget(player, true);
 
    // clean buffers for further work
    packet.clear();
    data.Clear();
 
    // build other passengers at transport also (they always visible and marked as visible and will not send at visibility update at add to map
    if (Transport* transport = player->GetTransport())
        for (Transport::PassengerSet::const_iterator itr = transport->GetPassengers().begin(); itr != transport->GetPassengers().end(); ++itr)
            if (player != (*itr) && player->HaveAtClient(*itr))
                (*itr)->BuildCreateUpdateBlockForPlayer(&data, player);
 
    data.BuildPacket(packet);
    player->SendDirectMessage(&packet);
}

References Player::BuildCreateUpdateBlockForPlayer(), UpdateData::BuildPacket(), UpdateData::Clear(), ByteBuffer::clear(), Player::GetAurasForTarget(), Object::GetGUID(), WorldObject::GetTransport(), Player::HaveAtClient(), LOG_DEBUG, Player::SendDirectMessage(), and ObjectGuid::ToString().

Referenced by AddPlayerToMap(), and WorldSession::HandlePlayerLoginToCharInWorld().

◆ SendInitTransports()

void Map::SendInitTransports ( Player * player )

{
    // Hack to send out transports
    UpdateData transData;
    for (TransportsContainer::const_iterator itr = _transports.begin(); itr != _transports.end(); ++itr)
        if (*itr != player->GetTransport())
            (*itr)->BuildCreateUpdateBlockForPlayer(&transData, player);
 
    WorldPacket packet;
    transData.BuildPacket(packet);
    player->GetSession()->SendPacket(&packet);
}

References _transports, UpdateData::BuildPacket(), Player::GetSession(), WorldObject::GetTransport(), and WorldSession::SendPacket().

Referenced by AddPlayerToMap(), and WorldSession::HandlePlayerLoginToCharInWorld().

◆ SendObjectUpdates()

void Map::SendObjectUpdates ( )

private

{
    UpdateDataMapType update_players;
    UpdatePlayerSet player_set;
 
    while (!_updateObjects.empty())
    {
        Object* obj = *_updateObjects.begin();
        ASSERT(obj->IsInWorld());
 
        _updateObjects.erase(_updateObjects.begin());
        obj->BuildUpdate(update_players, player_set);
    }
 
    WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
    for (UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
    {
        iter->second.BuildPacket(packet);
        iter->first->GetSession()->SendPacket(&packet);
        packet.clear();                                     // clean the string
    }
}

References _updateObjects, ASSERT, Object::BuildUpdate(), ByteBuffer::clear(), and Object::IsInWorld().

Referenced by Update().

◆ SendRemoveTransports()

void Map::SendRemoveTransports ( Player * player )

{
    // Hack to send out transports
    UpdateData transData;
    for (TransportsContainer::const_iterator itr = _transports.begin(); itr != _transports.end(); ++itr)
        if (*itr != player->GetTransport())
            (*itr)->BuildOutOfRangeUpdateBlock(&transData);
 
    // pussywizard: remove static transports from client
    for (GuidUnorderedSet::const_iterator it = player->m_clientGUIDs.begin(); it != player->m_clientGUIDs.end(); )
    {
        if ((*it).IsTransport())
        {
            transData.AddOutOfRangeGUID(*it);
            it = player->m_clientGUIDs.erase(it);
        }
        else
            ++it;
    }
 
    WorldPacket packet;
    transData.BuildPacket(packet);
    player->GetSession()->SendPacket(&packet);
}

References _transports, UpdateData::AddOutOfRangeGUID(), UpdateData::BuildPacket(), Player::GetSession(), WorldObject::GetTransport(), Player::m_clientGUIDs, and WorldSession::SendPacket().

Referenced by RemovePlayerFromMap().

◆ SendToPlayers()

void Map::SendToPlayers ( WorldPacket const * data ) const

{
    for (MapRefMgr::const_iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
        itr->GetSource()->GetSession()->SendPacket(data);
}

References MapRefMgr::begin(), MapRefMgr::end(), and m_mapRefMgr.

Referenced by boss_ossirian::JustEngagedWith(), and InstanceScript::SendEncounterUnit().

◆ SendZoneDynamicInfo()

void Map::SendZoneDynamicInfo ( Player * player )

{
    uint32 zoneId = player->GetZoneId();
    ZoneDynamicInfoMap::const_iterator itr = _zoneDynamicInfo.find(zoneId);
    if (itr == _zoneDynamicInfo.end())
        return;
 
    if (uint32 music = itr->second.MusicId)
        player->SendDirectMessage(WorldPackets::Misc::PlayMusic(music).Write());
 
    if (WeatherState weatherId = itr->second.WeatherId)
    {
        WorldPackets::Misc::Weather weather(weatherId, itr->second.WeatherGrade);
        player->SendDirectMessage(weather.Write());
    }
 
    if (uint32 overrideLight = itr->second.OverrideLightId)
    {
        WorldPacket data(SMSG_OVERRIDE_LIGHT, 4 + 4 + 1);
        data << uint32(_defaultLight);
        data << uint32(overrideLight);
        data << uint32(itr->second.LightFadeInTime);
        player->SendDirectMessage(&data);
    }
}

References _defaultLight, _zoneDynamicInfo, WorldObject::GetZoneId(), Player::SendDirectMessage(), SMSG_OVERRIDE_LIGHT, and WorldPackets::Misc::Weather::Write().

Referenced by AddPlayerToMap(), and WorldSession::HandlePlayerLoginToCharInWorld().

◆ SetVisibilityRange()

void Map::SetVisibilityRange ( float range )

inline

191{ m_VisibleDistance = range; }

References m_VisibleDistance.

Referenced by boss_nightbane::DoAction(), boss_nightbane::PathEndReached(), and instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetBossState().

◆ SetZoneMusic()

void Map::SetZoneMusic	(	uint32	zoneId,
		uint32	musicId
	)

{
    if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
        _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
    _zoneDynamicInfo[zoneId].MusicId = musicId;
 
    Map::PlayerList const& players = GetPlayers();
    if (!players.IsEmpty())
    {
        WorldPackets::Misc::PlayMusic playMusic(musicId);
        playMusic.Write();
 
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (Player* player = itr->GetSource())
                if (player->GetZoneId() == zoneId)
                    player->SendDirectMessage(playMusic.GetRawPacket());
    }
}

References _zoneDynamicInfo, MapRefMgr::begin(), MapRefMgr::end(), GetPlayers(), WorldPackets::Packet::GetRawPacket(), LinkedListHead::IsEmpty(), and WorldPackets::Misc::PlayMusic::Write().

Referenced by boss_the_lich_king::boss_the_lich_kingAI::DamageTaken(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::DoAction(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::DoAction(), npc_gunship::npc_gunshipAI::JustDied(), npc_tirion_fordring_tft::npc_tirion_fordringAI::MovementInform(), boss_the_lich_king::boss_the_lich_kingAI::MovementInform(), boss_the_lich_king::boss_the_lich_kingAI::UpdateAI(), and npc_tirion_fordring_tft::npc_tirion_fordringAI::UpdateAI().

◆ SetZoneOverrideLight()

void Map::SetZoneOverrideLight	(	uint32	zoneId,
		uint32	lightId,
		Milliseconds	fadeInTime
	)

{
    if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
        _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
    ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
    info.OverrideLightId = lightId;
    info.LightFadeInTime = static_cast<uint32>(fadeInTime.count());
    Map::PlayerList const& players = GetPlayers();
 
    if (!players.IsEmpty())
    {
        WorldPacket data(SMSG_OVERRIDE_LIGHT, 4 + 4 + 4);
        data << uint32(_defaultLight);
        data << uint32(lightId);
        data << uint32(static_cast<uint32>(fadeInTime.count()));
 
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (Player* player = itr->GetSource())
                if (player->GetZoneId() == zoneId)
                    player->SendDirectMessage(&data);
    }
}

References _defaultLight, _zoneDynamicInfo, MapRefMgr::begin(), MapRefMgr::end(), GetPlayers(), LinkedListHead::IsEmpty(), ZoneDynamicInfo::LightFadeInTime, ZoneDynamicInfo::OverrideLightId, and SMSG_OVERRIDE_LIGHT.

Referenced by boss_the_lich_king::boss_the_lich_kingAI::DoAction(), boss_malygos::boss_malygosAI::EnterEvadeMode(), boss_malygos::boss_malygosAI::MovementInform(), boss_the_lich_king::boss_the_lich_kingAI::SpellHitTarget(), npc_tirion_fordring_tft::npc_tirion_fordringAI::UpdateAI(), and boss_malygos::boss_malygosAI::UpdateAI().

◆ SetZoneWeather()

void Map::SetZoneWeather	(	uint32	zoneId,
		WeatherState	weatherId,
		float	weatherGrade
	)

{
    if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
        _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
    ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
    info.WeatherId = weatherId;
    info.WeatherGrade = weatherGrade;
    Map::PlayerList const& players = GetPlayers();
 
    if (!players.IsEmpty())
    {
        WorldPackets::Misc::Weather weather(weatherId, weatherGrade);
 
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (Player* player = itr->GetSource())
                if (player->GetZoneId() == zoneId)
                    player->SendDirectMessage(weather.Write());
    }
}

References _zoneDynamicInfo, MapRefMgr::begin(), MapRefMgr::end(), GetPlayers(), LinkedListHead::IsEmpty(), ZoneDynamicInfo::WeatherGrade, ZoneDynamicInfo::WeatherId, and WorldPackets::Misc::Weather::Write().

Referenced by boss_the_lich_king::boss_the_lich_kingAI::DoAction(), boss_akilzon::SetWeather(), boss_the_lich_king::boss_the_lich_kingAI::SpellHitTarget(), and npc_tirion_fordring_tft::npc_tirion_fordringAI::UpdateAI().

◆ SummonCreature()

TempSummon * Map::SummonCreature	(	uint32	entry,
		Position const &	pos,
		SummonPropertiesEntry const *	properties = `nullptr`,
		uint32	duration = `0`,
		WorldObject *	summoner = `nullptr`,
		uint32	spellId = `0`,
		uint32	vehId = `0`,
		bool	visibleBySummonerOnly = `false`
	)

{
    uint32 mask = UNIT_MASK_SUMMON;
    if (properties)
    {
        switch (properties->Category)
        {
            case SUMMON_CATEGORY_PET:
                mask = UNIT_MASK_GUARDIAN;
                break;
            case SUMMON_CATEGORY_PUPPET:
                mask = UNIT_MASK_PUPPET;
                break;
            case SUMMON_CATEGORY_VEHICLE:
                mask = UNIT_MASK_MINION;
                break;
            case SUMMON_CATEGORY_WILD:
            case SUMMON_CATEGORY_ALLY:
            case SUMMON_CATEGORY_UNK:
                {
                    switch (properties->Type)
                    {
                        case SUMMON_TYPE_MINION:
                        case SUMMON_TYPE_GUARDIAN:
                        case SUMMON_TYPE_GUARDIAN2:
                            mask = UNIT_MASK_GUARDIAN;
                            break;
                        case SUMMON_TYPE_TOTEM:
                        case SUMMON_TYPE_LIGHTWELL:
                            mask = UNIT_MASK_TOTEM;
                            break;
                        case SUMMON_TYPE_VEHICLE:
                        case SUMMON_TYPE_VEHICLE2:
                            mask = UNIT_MASK_SUMMON;
                            break;
                        case SUMMON_TYPE_MINIPET:
                        case SUMMON_TYPE_JEEVES:
                            mask = UNIT_MASK_MINION;
                            break;
                        default:
                            if (properties->Flags & 512) // Mirror Image, Summon Gargoyle
                                mask = UNIT_MASK_GUARDIAN;
                            break;
                    }
                    break;
                }
            default:
                return nullptr;
        }
    }
 
    uint32 phase = PHASEMASK_NORMAL;
    if (summoner)
        phase = summoner->GetPhaseMask();
 
    TempSummon* summon = nullptr;
    switch (mask)
    {
        case UNIT_MASK_SUMMON:
            summon = new TempSummon(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        case UNIT_MASK_GUARDIAN:
            summon = new Guardian(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        case UNIT_MASK_PUPPET:
            summon = new Puppet(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty);
            break;
        case UNIT_MASK_TOTEM:
            summon = new Totem(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty);
            break;
        case UNIT_MASK_MINION:
            summon = new Minion(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        default:
            return nullptr;
    }
 
    EnsureGridLoaded(Cell(pos.GetPositionX(), pos.GetPositionY()));
    if (!summon->Create(GenerateLowGuid<HighGuid::Unit>(), this, phase, entry, vehId, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()))
    {
        delete summon;
        return nullptr;
    }
 
    summon->SetUInt32Value(UNIT_CREATED_BY_SPELL, spellId);
 
    summon->SetHomePosition(pos);
 
    summon->InitStats(duration);
 
    summon->SetVisibleBySummonerOnly(visibleBySummonerOnly);
 
    bool summonerHasTransport = summoner && summoner->GetTransport();
    bool summonerIsVehicle = summoner && summoner->IsUnit() && summoner->ToUnit()->IsVehicle();
    bool checkTransport = summon->GetOwnerGUID().IsPlayer() || (summonerHasTransport && !summonerIsVehicle);
    if (!AddToMap(summon->ToCreature(), checkTransport))
    {
        delete summon;
        return nullptr;
    }
 
    summon->InitSummon();
 
    // call MoveInLineOfSight for nearby creatures
    Acore::AIRelocationNotifier notifier(*summon);
    Cell::VisitAllObjects(summon, notifier, GetVisibilityRange());
 
    return summon;
}

References AddToMap(), SummonPropertiesEntry::Category, Creature::Create(), ObjectGuid::Empty, EnsureGridLoaded(), SummonPropertiesEntry::Flags, Object::GetGUID(), Position::GetOrientation(), Unit::GetOwnerGUID(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldObject::GetTransport(), GetVisibilityRange(), TempSummon::InitStats(), TempSummon::InitSummon(), ObjectGuid::IsPlayer(), Object::IsUnit(), Unit::IsVehicle(), PHASEMASK_NORMAL, Creature::SetHomePosition(), Unit::SetUInt32Value(), TempSummon::SetVisibleBySummonerOnly(), SUMMON_CATEGORY_ALLY, SUMMON_CATEGORY_PET, SUMMON_CATEGORY_PUPPET, SUMMON_CATEGORY_UNK, SUMMON_CATEGORY_VEHICLE, SUMMON_CATEGORY_WILD, SUMMON_TYPE_GUARDIAN, SUMMON_TYPE_GUARDIAN2, SUMMON_TYPE_JEEVES, SUMMON_TYPE_LIGHTWELL, SUMMON_TYPE_MINION, SUMMON_TYPE_MINIPET, SUMMON_TYPE_TOTEM, SUMMON_TYPE_VEHICLE, SUMMON_TYPE_VEHICLE2, Object::ToCreature(), Object::ToUnit(), SummonPropertiesEntry::Type, UNIT_CREATED_BY_SPELL, UNIT_MASK_GUARDIAN, UNIT_MASK_MINION, UNIT_MASK_PUPPET, UNIT_MASK_SUMMON, UNIT_MASK_TOTEM, and Cell::VisitAllObjects().

◆ SummonCreatureGroup()

void Map::SummonCreatureGroup	(	uint8	group,
		std::list< TempSummon * > *	list = `nullptr`
	)

Summons group of creatures.

Parameters

group	Id of group to summon.
list	List to store pointers to summoned creatures.

{
    std::vector<TempSummonData> const* data = sObjectMgr->GetSummonGroup(GetId(), SUMMONER_TYPE_MAP, group);
    if (!data)
        return;
 
    for (std::vector<TempSummonData>::const_iterator itr = data->begin(); itr != data->end(); ++itr)
        if (TempSummon* summon = SummonCreature(itr->entry, itr->pos, nullptr, itr->time))
            if (list)
                list->push_back(summon);
}

References GetId(), sObjectMgr, SummonCreature(), and SUMMONER_TYPE_MAP.

Referenced by at_ancient_leaf::OnTrigger(), and instance_hyjal::instance_mount_hyjal_InstanceMapScript::ScheduleWaves().

◆ SummonGameObject() [1/2]

GameObject * Map::SummonGameObject	(	uint32	entry,
		float	x,
		float	y,
		float	z,
		float	ang,
		float	rotation0,
		float	rotation1,
		float	rotation2,
		float	rotation3,
		uint32	respawnTime,
		bool	checkTransport = `true`
	)

{
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
    if (!goinfo)
    {
        LOG_ERROR("sql.sql", "Gameobject template {} not found in database!", entry);
        return nullptr;
    }
 
    GameObject* go = sObjectMgr->IsGameObjectStaticTransport(entry) ? new StaticTransport() : new GameObject();
    if (!go->Create(GenerateLowGuid<HighGuid::GameObject>(), entry, this, PHASEMASK_NORMAL, x, y, z, ang, G3D::Quat(rotation0, rotation1, rotation2, rotation3), 100, GO_STATE_READY))
    {
        delete go;
        return nullptr;
    }
 
    // Xinef: if gameobject is temporary, set custom spellid
    if (respawnTime)
        go->SetSpellId(1);
 
    go->SetRespawnTime(respawnTime);
    go->SetSpawnedByDefault(false);
    AddToMap(go, checkTransport);
    return go;
}

References AddToMap(), GameObject::Create(), GO_STATE_READY, LOG_ERROR, PHASEMASK_NORMAL, GameObject::SetRespawnTime(), GameObject::SetSpawnedByDefault(), GameObject::SetSpellId(), and sObjectMgr.

Referenced by instance_sunken_temple::instance_sunken_temple_InstanceMapScript::OnGameObjectCreate(), SummonGameObject(), and instance_sunken_temple::instance_sunken_temple_InstanceMapScript::Update().

◆ SummonGameObject() [2/2]

GameObject * Map::SummonGameObject	(	uint32	entry,
		Position const &	pos,
		float	rotation0 = `0.0f`,
		float	rotation1 = `0.0f`,
		float	rotation2 = `0.0f`,
		float	rotation3 = `0.0f`,
		uint32	respawnTime = `100`,
		bool	checkTransport = `true`
	)

{
    return SummonGameObject(entry, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), rotation0, rotation1, rotation2, rotation3, respawnTime, checkTransport);
}

References Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), and SummonGameObject().

◆ ToBattlegroundMap() [1/2]

BattlegroundMap * Map::ToBattlegroundMap ( )

inline

386{ if (IsBattlegroundOrArena()) return reinterpret_cast<BattlegroundMap*>(this); else return nullptr; }

BattlegroundMap

Definition Map.h:689

References IsBattlegroundOrArena().

Referenced by npc_av_marshal_or_warmaster::npc_av_marshal_or_warmasterAI::AttackStart(), boss_drekthar::boss_drektharAI::AttackStart(), boss_vanndar::boss_vanndarAI::AttackStart(), WorldObject::CanSeeOrDetect(), npc_av_marshal_or_warmaster::npc_av_marshal_or_warmasterAI::EnterEvadeMode(), boss_drekthar::boss_drektharAI::EnterEvadeMode(), boss_vanndar::boss_vanndarAI::EnterEvadeMode(), MapMgr::GetNumPlayersInInstances(), Unit::isInAccessiblePlaceFor(), and npc_ioc_gunship_captain::npc_ioc_gunship_captainAI::UpdateAI().

◆ ToBattlegroundMap() [2/2]

BattlegroundMap const * Map::ToBattlegroundMap ( ) const

inline

387{ if (IsBattlegroundOrArena()) return reinterpret_cast<BattlegroundMap const*>(this); return nullptr; }

References IsBattlegroundOrArena().

◆ ToInstanceMap() [1/2]

InstanceMap * Map::ToInstanceMap ( )

inline

383{ if (IsDungeon()) return reinterpret_cast<InstanceMap*>(this); else return nullptr; }

Map::IsDungeon

bool IsDungeon() const

Definition Map.h:290

References IsDungeon().

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), boss_flame_leviathan::boss_flame_leviathanAI::BindPlayers(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::CheckAchievementCriteriaMeet(), TransportMgr::CreateTransport(), npc_harrison_jones::DoAction(), WorldObject::GetInstanceScript(), go_celestial_planetarium_access::go_celestial_planetarium_accessAI::GossipHello(), instance_commandscript::HandleInstanceGetBossStateCommand(), instance_commandscript::HandleInstanceSaveDataCommand(), instance_commandscript::HandleInstanceSetBossStateCommand(), WorldSession::HandleSetRaidDifficultyOpcode(), InstanceSave::InsertToDB(), InstanceHasScript(), boss_skeram::JustDied(), Unit::Kill(), LogEncounterFinished(), Condition::Meets(), AchievementCriteriaData::Meets(), instance_karazhan::instance_karazhan_InstanceMapScript::OnUnitDeath(), Player::ResetInstances(), Group::ResetInstances(), instance_karazhan::instance_karazhan_InstanceMapScript::SetData(), instance_trial_of_the_champion::instance_trial_of_the_champion_InstanceMapScript::SetData(), WorldObject::SetZoneScript(), instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::Update(), and AchievementMgr::UpdateAchievementCriteria().

◆ ToInstanceMap() [2/2]

InstanceMap const * Map::ToInstanceMap ( ) const

inline

384{ if (IsDungeon()) return (const InstanceMap*)((InstanceMap*)this); else return nullptr; }

References IsDungeon().

◆ ToMapInstanced() [1/2]

MapInstanced * Map::ToMapInstanced ( )

inline

380{ if (Instanceable()) return reinterpret_cast<MapInstanced*>(this); else return nullptr; }

MapInstanced

Definition MapInstanced.h:26

Map::Instanceable

bool Instanceable() const

Definition Map.h:289

References Instanceable().

Referenced by MapMgr::DoForAllMaps(), and MapMgr::DoForAllMapsWithMapId().

◆ ToMapInstanced() [2/2]

MapInstanced const * Map::ToMapInstanced ( ) const

inline

381{ if (Instanceable()) return (const MapInstanced*)((MapInstanced*)this); else return nullptr; }

References Instanceable().

◆ UnloadAll()

void Map::UnloadAll ( )

virtual

Reimplemented in InstanceMap, and MapInstanced.

{
    // clear all delayed moves, useless anyway do this moves before map unload.
    _creaturesToMove.clear();
    _gameObjectsToMove.clear();
 
    for (GridRefMgr<MapGridType>::iterator i = GridRefMgr<MapGridType>::begin(); i != GridRefMgr<MapGridType>::end();)
    {
        MapGridType& grid(*i->GetSource());
        ++i;
        UnloadGrid(grid); // deletes the grid and removes it from the GridRefMgr
    }
 
    // pussywizard: crashfix, some npc can be left on transport (not a default passenger)
    if (!AllTransportsEmpty())
        AllTransportsRemovePassengers();
 
    for (TransportsContainer::iterator itr = _transports.begin(); itr != _transports.end();)
    {
        MotionTransport* transport = *itr;
        ++itr;
 
        transport->RemoveFromWorld();
        delete transport;
    }
 
    _transports.clear();
 
    for (auto& cellCorpsePair : _corpsesByGrid)
    {
        for (Corpse* corpse : cellCorpsePair.second)
        {
            corpse->RemoveFromWorld();
            corpse->ResetMap();
            delete corpse;
        }
    }
 
    _corpsesByGrid.clear();
    _corpsesByPlayer.clear();
    _corpseBones.clear();
}

References _corpseBones, _corpsesByGrid, _corpsesByPlayer, _creaturesToMove, _gameObjectsToMove, _transports, AllTransportsEmpty(), AllTransportsRemovePassengers(), GridRefMgr< OBJECT >::end(), GameObject::RemoveFromWorld(), and UnloadGrid().

Referenced by InstanceMap::UnloadAll(), and MapInstanced::UnloadAll().

◆ UnloadGrid()

bool Map::UnloadGrid ( MapGridType & grid )

{
    _mapGridManager.UnloadGrid(grid.GetX(), grid.GetY());
 
    ASSERT(i_objectsToRemove.empty());
    LOG_DEBUG("maps", "Unloading grid[{}, {}] for map {} finished", grid.GetX(), grid.GetY(), GetId());
    return true;
}

References _mapGridManager, ASSERT, GetId(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetX(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetY(), i_objectsToRemove, LOG_DEBUG, and MapGridManager::UnloadGrid().

Referenced by UnloadAll().

◆ Update()

void Map::Update	(	const uint32	t_diff,
		const uint32	s_diff,
		bool	thread = `true`
	)

virtual

Process necessary scripts

Reimplemented in InstanceMap, and MapInstanced.

{
    if (t_diff)
        _dynamicTree.update(t_diff);
 
    // Update world sessions and players
    for (m_mapRefIter = m_mapRefMgr.begin(); m_mapRefIter != m_mapRefMgr.end(); ++m_mapRefIter)
    {
        Player* player = m_mapRefIter->GetSource();
        if (player && player->IsInWorld())
        {
            // Update session
            WorldSession* session = player->GetSession();
            MapSessionFilter updater(session);
            session->Update(s_diff, updater);
 
            // update players at tick
            if (!t_diff)
                player->Update(s_diff);
        }
    }
 
    _creatureRespawnScheduler.Update(t_diff);
 
    if (!t_diff)
    {
        HandleDelayedVisibility();
        return;
    }
 
    _updatableObjectListRecheckTimer.Update(t_diff);
    resetMarkedCells();
 
    // Update players
    for (m_mapRefIter = m_mapRefMgr.begin(); m_mapRefIter != m_mapRefMgr.end(); ++m_mapRefIter)
    {
        Player* player = m_mapRefIter->GetSource();
 
        if (!player || !player->IsInWorld())
            continue;
 
        player->Update(s_diff);
 
        if (_updatableObjectListRecheckTimer.Passed())
        {
            MarkNearbyCellsOf(player);
 
            // If player is using far sight, update viewpoint
            if (WorldObject* viewPoint = player->GetViewpoint())
            {
                if (Creature* viewCreature = viewPoint->ToCreature())
                    MarkNearbyCellsOf(viewCreature);
                else if (DynamicObject* viewObject = viewPoint->ToDynObject())
                    MarkNearbyCellsOf(viewObject);
            }
        }
    }
 
    if (_updatableObjectListRecheckTimer.Passed())
    {
        // Mark all cells near active objects
        for (m_activeNonPlayersIter = m_activeNonPlayers.begin(); m_activeNonPlayersIter != m_activeNonPlayers.end(); ++m_activeNonPlayersIter)
        {
            WorldObject* obj = *m_activeNonPlayersIter;
            if (!obj || !obj->IsInWorld())
                continue;
 
            MarkNearbyCellsOf(obj);
        }
    }
 
    UpdateNonPlayerObjects(t_diff);
 
    SendObjectUpdates();
 
    if (!m_scriptSchedule.empty())
    {
        i_scriptLock = true;
        ScriptsProcess();
        i_scriptLock = false;
    }
 
    MoveAllCreaturesInMoveList();
    MoveAllGameObjectsInMoveList();
    MoveAllDynamicObjectsInMoveList();
 
    HandleDelayedVisibility();
 
    sScriptMgr->OnMapUpdate(this, t_diff);
 
    METRIC_VALUE("map_creatures", uint64(GetObjectsStore().Size<Creature>()),
        METRIC_TAG("map_id", std::to_string(GetId())),
        METRIC_TAG("map_instanceid", std::to_string(GetInstanceId())));
 
    METRIC_VALUE("map_gameobjects", uint64(GetObjectsStore().Size<GameObject>()),
        METRIC_TAG("map_id", std::to_string(GetId())),
        METRIC_TAG("map_instanceid", std::to_string(GetInstanceId())));
}

References _creatureRespawnScheduler, _dynamicTree, _updatableObjectListRecheckTimer, MapRefMgr::begin(), MapRefMgr::end(), GetId(), GetInstanceId(), GetObjectsStore(), Player::GetSession(), Reference< TO, FROM >::GetSource(), Player::GetViewpoint(), HandleDelayedVisibility(), i_scriptLock, Object::IsInWorld(), m_activeNonPlayers, m_activeNonPlayersIter, m_mapRefIter, m_mapRefMgr, m_scriptSchedule, MarkNearbyCellsOf(), METRIC_TAG, METRIC_VALUE, MoveAllCreaturesInMoveList(), MoveAllDynamicObjectsInMoveList(), MoveAllGameObjectsInMoveList(), IntervalTimer::Passed(), resetMarkedCells(), ScriptsProcess(), SendObjectUpdates(), sScriptMgr, Object::ToCreature(), Object::ToDynObject(), TaskScheduler::Update(), IntervalTimer::Update(), DynamicMapTree::update(), WorldSession::Update(), Player::Update(), and UpdateNonPlayerObjects().

Referenced by MapUpdateRequest::call(), InstanceMap::Update(), and MapInstanced::Update().

◆ UpdateEncounterState()

void Map::UpdateEncounterState	(	EncounterCreditType	type,
		uint32	creditEntry,
		Unit *	source
	)

{
    Difficulty difficulty_fixed = (IsSharedDifficultyMap(GetId()) ? Difficulty(GetDifficulty() % 2) : GetDifficulty());
    DungeonEncounterList const* encounters;
    // 631 : ICC - 724 : Ruby Sanctum --- For heroic difficulties, for some reason, we don't have an encounter list, so we get the encounter list from normal diff. We shouldn't change difficulty_fixed variable.
    if ((GetId() == 631 || GetId() == 724) && IsHeroic())
    {
        encounters = sObjectMgr->GetDungeonEncounterList(GetId(), !Is25ManRaid() ? RAID_DIFFICULTY_10MAN_NORMAL : RAID_DIFFICULTY_25MAN_NORMAL);
    }
    else
    {
        encounters = sObjectMgr->GetDungeonEncounterList(GetId(), difficulty_fixed);
    }
 
    if (!encounters)
    {
        return;
    }
 
    uint32 dungeonId = 0;
    bool updated = false;
 
    for (DungeonEncounterList::const_iterator itr = encounters->begin(); itr != encounters->end(); ++itr)
    {
        DungeonEncounter const* encounter = *itr;
        if (encounter->creditType == type && encounter->creditEntry == creditEntry)
        {
            if (source)
                if (InstanceScript* instanceScript = source->GetInstanceScript())
                {
                    uint32 prevMask = instanceScript->GetCompletedEncounterMask();
                    instanceScript->SetCompletedEncountersMask((1 << encounter->dbcEntry->encounterIndex) | instanceScript->GetCompletedEncounterMask(), true);
                    if (prevMask != instanceScript->GetCompletedEncounterMask())
                        updated = true;
                }
 
            if (encounter->lastEncounterDungeon)
            {
                dungeonId = encounter->lastEncounterDungeon;
                break;
            }
        }
    }
 
    // pussywizard:
    LogEncounterFinished(type, creditEntry);
 
    sScriptMgr->OnAfterUpdateEncounterState(this, type, creditEntry, source, difficulty_fixed, encounters, dungeonId, updated);
 
    if (dungeonId)
    {
        Map::PlayerList const& players = GetPlayers();
        for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
        {
            if (Player* player = i->GetSource())
                if (Group* grp = player->GetGroup())
                    if (grp->isLFGGroup())
                    {
                        sLFGMgr->FinishDungeon(grp->GetGUID(), dungeonId, this);
                        return;
                    }
        }
    }
}

References MapRefMgr::begin(), DungeonEncounter::creditEntry, DungeonEncounter::creditType, DungeonEncounter::dbcEntry, DungeonEncounterEntry::encounterIndex, MapRefMgr::end(), GetDifficulty(), GetId(), WorldObject::GetInstanceScript(), GetPlayers(), Is25ManRaid(), IsHeroic(), IsSharedDifficultyMap(), DungeonEncounter::lastEncounterDungeon, LogEncounterFinished(), RAID_DIFFICULTY_10MAN_NORMAL, RAID_DIFFICULTY_25MAN_NORMAL, sLFGMgr, sObjectMgr, and sScriptMgr.

Referenced by boss_eadric::boss_eadricAI::DamageTaken(), boss_illidari_council::DoAction(), Spell::finish(), instance_karazhan::instance_karazhan_InstanceMapScript::SetBossState(), boss_majordomo::boss_majordomoAI::SummonedCreatureDies(), and npc_grimstone::npc_grimstoneAI::WaypointReached().

◆ UpdateIteratorBack()

void Map::UpdateIteratorBack ( Player * player )

{
    if (m_mapRefIter == player->GetMapRef())
        m_mapRefIter = m_mapRefIter->nocheck_prev();
}

References Player::GetMapRef(), m_mapRefIter, and MapReference::nocheck_prev().

Referenced by Player::ResetMap().

◆ UpdateNonPlayerObjects()

void Map::UpdateNonPlayerObjects ( uint32 const diff )

private

{
    for (WorldObject* obj : _pendingAddUpdatableObjectList)
        _AddObjectToUpdateList(obj);
    _pendingAddUpdatableObjectList.clear();
 
    if (_updatableObjectListRecheckTimer.Passed())
    {
        for (uint32 i = 0; i < _updatableObjectList.size();)
        {
            WorldObject* obj = _updatableObjectList[i];
            if (!obj->IsInWorld())
            {
                ++i;
                continue;
            }
 
            obj->Update(diff);
 
            if (!obj->IsUpdateNeeded())
            {
                _RemoveObjectFromUpdateList(obj);
                // Intentional no iteration here, obj is swapped with last element in
                // _updatableObjectList so next loop will update that object at the same index
            }
            else
                ++i;
        }
        _updatableObjectListRecheckTimer.Reset();
    }
    else
    {
        for (uint32 i = 0; i < _updatableObjectList.size(); ++i)
        {
            WorldObject* obj = _updatableObjectList[i];
            if (!obj->IsInWorld())
                continue;
 
            obj->Update(diff);
        }
    }
}

References _AddObjectToUpdateList(), _pendingAddUpdatableObjectList, _RemoveObjectFromUpdateList(), _updatableObjectList, _updatableObjectListRecheckTimer, Object::IsInWorld(), WorldObject::IsUpdateNeeded(), IntervalTimer::Passed(), IntervalTimer::Reset(), and WorldObject::Update().

Referenced by Update().

◆ UpdatePlayerZoneStats()

void Map::UpdatePlayerZoneStats	(	uint32	oldZone,
		uint32	newZone
	)

{
    // Nothing to do if no change
    if (oldZone == newZone)
        return;
 
    if (oldZone != MAP_INVALID_ZONE)
    {
        uint32& oldZoneCount = _zonePlayerCountMap[oldZone];
        if (!oldZoneCount)
            LOG_ERROR("maps", "A player left zone {} (went to {}) - but there were no players in the zone!", oldZone, newZone);
        else
            --oldZoneCount;
    }
    ++_zonePlayerCountMap[newZone];
}

References _zonePlayerCountMap, LOG_ERROR, and MAP_INVALID_ZONE.

Referenced by Player::UpdateZone().

◆ Visit()

template<class T , class CONTAINER >

void Map::Visit	(	const Cell &	cell,
		TypeContainerVisitor< T, CONTAINER > &	visitor
	)

inline

{
    uint32 const grid_x = cell.GridX();
    uint32 const grid_y = cell.GridY();
 
    // If grid is not loaded, nothing to visit.
    if (!IsGridLoaded(GridCoord(grid_x, grid_y)))
        return;
 
    GetMapGrid(grid_x, grid_y)->VisitCell(cell.CellX(), cell.CellY(), visitor);
}

References Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), IsGridLoaded(), and MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::VisitCell().

Referenced by Cell::Visit(), and Cell::VisitCircle().

Friends And Related Symbol Documentation

◆ GridObjectLoader

Referenced by ApplyDynamicModeRespawnScaling(), Map(), and UpdatePlayerZoneStats().

◆ CreatureGroupHolder

CreatureGroupHolderType Map::CreatureGroupHolder

Referenced by FormationMgr::AddCreatureToGroup(), and FormationMgr::RemoveCreatureFromGroup().

◆ CustomData

DataMap Map::CustomData

◆ i_InstanceId

uint32 Map::i_InstanceId

protected

Referenced by GetInstanceId(), and ~Map().

◆ i_mapEntry

MapEntry const* Map::i_mapEntry

protected

Referenced by GetAreaId(), GetEntrancePos(), GetEntry(), GetFullTerrainStatusForPosition(), GetId(), GetMapName(), Instanceable(), IsBattleArena(), IsBattleground(), IsBattlegroundOrArena(), IsDungeon(), IsNonRaidDungeon(), IsRaid(), and IsWorldMap().

std::shared_mutex Map::MMapLock

protected

Referenced by GetMMapLock().

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

azerothcore-wotlk/src/server/game/Maps/Map.h
azerothcore-wotlk/src/server/game/Entities/Object/Object.cpp
azerothcore-wotlk/src/server/game/Maps/Map.cpp
azerothcore-wotlk/src/server/game/Scripting/MapScripts.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ActiveNonPlayers

◆ CreatureBySpawnIdContainer

◆ GameObjectBySpawnIdContainer

◆ PendingAddUpdatableObjectList

◆ PlayerList

◆ ScriptScheduleMap

◆ UpdatableObjectList

Member Enumeration Documentation

◆ EnterState

Constructor & Destructor Documentation

◆ Map()

◆ ~Map()

Member Function Documentation

◆ _AddObjectToUpdateList()

◆ _FindGameObject()

◆ _GetScriptCreature()

◆ _GetScriptCreatureSourceOrTarget()

◆ _GetScriptPlayer()

◆ _GetScriptPlayerSourceOrTarget()

◆ _GetScriptUnit()

◆ _GetScriptWorldObject()

◆ _RemoveObjectFromUpdateList()

◆ _ScriptProcessDoor()

◆ AddCorpse()

◆ AddCreatureToMoveList()

◆ AddDynamicObjectToMoveList()

◆ AddGameObjectToMoveList()

◆ AddObjectToPendingUpdateList()

◆ AddObjectToRemoveList()

◆ AddPlayerToMap()

◆ AddToActive() [1/5]

◆ AddToActive() [2/5]

◆ AddToActive() [3/5]

◆ AddToActive() [4/5]

◆ AddToActive() [5/5]

◆ AddToActiveHelper()

◆ AddToGrid() [1/5]

◆ AddToGrid() [2/5]

◆ AddToGrid() [3/5]

◆ AddToGrid() [4/5]

◆ AddToGrid() [5/5]

◆ AddToMap() [1/2]

◆ AddToMap() [2/2]

◆ AddUpdateObject()

◆ AddWorldObject()

◆ AfterPlayerUnlinkFromMap()

◆ AllTransportsEmpty()

◆ AllTransportsRemovePassengers()

◆ ApplyDynamicModeRespawnScaling()

◆ Balance()

◆ CannotEnter()

◆ CanReachPositionAndGetValidCoords() [1/3]

◆ CanReachPositionAndGetValidCoords() [2/3]

◆ CanReachPositionAndGetValidCoords() [3/3]

◆ CanUnload()

◆ CheckCollisionAndGetValidCoords()

◆ ContainsGameObjectModel()

◆ ConvertCorpseToBones()

◆ CreatureRelocation()

◆ DelayedUpdate()

◆ DeleteCorpseData()

◆ DeleteFromWorld() [1/2]

◆ DeleteFromWorld() [2/2]

◆ DeleteRespawnTimes()

◆ DeleteRespawnTimesInDB()

◆ DoForAllPlayers()

◆ DynamicObjectRelocation()