#include "Map.h"

Inheritance diagram for Map:

Classes
struct	RespawnEntry

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

void	HandleDelayedVisibility ()

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

float	GetHeight (Position const &pos, 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, Optional< uint8 > reqLiquidType={})

LiquidData const	GetLiquidData (uint32 phaseMask, float x, float y, float z, float collisionHeight, Optional< 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 (bool aliveOnly=false) const

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)

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)

void	SummonGameObjectGroup (uint8 group, std::list< GameObject * > *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

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)

std::unordered_map< ObjectGuid::LowType, time_t > const &	GetCreatureRespawnTimes () const

std::unordered_map< ObjectGuid::LowType, time_t > const &	GetGORespawnTimes () const

void	LoadRespawnTimes ()

void	DeleteRespawnTimes ()

time_t	GetInstanceResetPeriod () const

void	UpdatePlayerZoneStats (uint32 oldZone, uint32 newZone)

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

bool	SpawnGroupSpawn (uint32 groupId, bool ignoreRespawn=false, bool force=false)

bool	SpawnGroupDespawn (uint32 groupId, bool deleteRespawnTimes=false)

bool	IsSpawnGroupActive (uint32 groupId) const

void	ProcessRespawns ()

void	ProcessCreatureRespawn (ObjectGuid::LowType spawnId)

void	ProcessGameObjectRespawn (ObjectGuid::LowType spawnId)

time_t	GetRespawnTime (SpawnObjectType type, ObjectGuid::LowType spawnId) const

void	RemoveRespawnTime (SpawnObjectType type, ObjectGuid::LowType spawnId)

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 ()

bool	SendZoneMessage (uint32 zone, WorldPacket const packet, WorldSession const self=nullptr, TeamId teamId=TEAM_NEUTRAL) const
	Send a packet to all players (or players selected team) in the zone (except self if mentioned)

void	SendZoneText (uint32 zoneId, char const text, WorldSession const self=nullptr, TeamId teamId=TEAM_NEUTRAL) const
	Send a System Message to all players in the zone (except self if mentioned)

void	SendInitTransports (Player *player)

void	SendRemoveTransports (Player *player)

void	SendZoneDynamicInfo (uint32 zoneId, Player *player) const

void	SendZoneWeather (uint32 zoneId, Player *player) const

void	SendZoneWeather (ZoneDynamicInfo const &zoneDynamicInfo, Player *player) const

void	SendInitSelf (Player *player)

void	UpdateWeather (uint32 const diff)

void	UpdateExpiredCorpses (uint32 const diff)

void	PlayDirectSoundToMap (uint32 soundId, uint32 zoneId=0)

void	SetZoneMusic (uint32 zoneId, uint32 musicId)

Weather *	GetOrGenerateZoneDefaultWeather (uint32 zoneId)

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)

size_t	GetUpdatableObjectsCount () 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)

void	AddWorldObjectToFarVisibleMap (WorldObject *obj)

void	RemoveWorldObjectFromFarVisibleMap (WorldObject *obj)

void	AddWorldObjectToZoneWideVisibleMap (uint32 zoneId, WorldObject *obj)

void	RemoveWorldObjectFromZoneWideVisibleMap (uint32 zoneId, WorldObject *obj)

ZoneWideVisibleWorldObjectsSet const *	GetZoneWideVisibleWorldObjectsForZone (uint32 zoneId) const

uint32	GetPlayerCountInZone (uint32 zoneId) const

MapCollisionData &	GetMapCollisionData ()

MapCollisionData const &	GetMapCollisionData () const

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

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

template<>
void	AddToGrid (Player *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 (Transport *obj, bool)

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

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

EventProcessor	Events

DataMap	CustomData

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

Protected Attributes
std::mutex	Lock

MapGridManager	_mapGridManager

MapEntry const *	i_mapEntry

MapCollisionData	_mapCollisionData

uint8	i_spawnMode

uint32	i_InstanceId

uint32	m_unloadTimer

float	m_VisibleDistance

time_t	_instanceResetPeriod

MapRefMgr	m_mapRefMgr

MapRefMgr::iterator	m_mapRefIter

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	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

ScriptScheduleMap	m_scriptSchedule

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

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

std::set< RespawnEntry >	_respawnQueue

std::unordered_set< uint32 >	_toggledSpawnGroupIds

uint32	_respawnCheckTimer {0}

std::unordered_map< uint32, uint32 >	_zonePlayerCountMap

ZoneDynamicInfoMap	_zoneDynamicInfo

IntervalTimer	_weatherUpdateTimer

uint32	_defaultLight

IntervalTimer	_corpseUpdateTimer

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

ZoneWideVisibleWorldObjectsMap	_zoneWideVisibleWorldObjectsMap

Friends
class	MapReference

class	GridObjectLoader

Detailed Description

Member Typedef Documentation

◆ 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)), _mapCollisionData(*this, _parent),
    i_spawnMode(SpawnMode), i_InstanceId(InstanceId), m_unloadTimer(0),
    m_VisibleDistance(DEFAULT_VISIBILITY_DISTANCE), _instanceResetPeriod(0),
    _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();
 
    _weatherUpdateTimer.SetInterval(1 * IN_MILLISECONDS);
    _corpseUpdateTimer.SetInterval(20 * MINUTE * IN_MILLISECONDS);
}

References _corpseUpdateTimer, _updatableObjectListRecheckTimer, _weatherUpdateTimer, _zonePlayerCountMap, IN_MILLISECONDS, InitVisibilityDistance(), m_parentMap, MINUTE, IntervalTimer::SetInterval(), and UPDATABLE_OBJECT_LIST_RECHECK_TIMER.

◆ ~Map()

Map::~Map ( )

override

{
    // UnloadAll must be called before deleting the map
 
    // Kill all scheduled events without executing them, since the map and its objects are being destroyed.
    // This prevents events from running on invalid or deleted objects during map destruction.
    Events.KillAllEvents(false);
 
    sScriptMgr->OnDestroyMap(this);
 
    if (!m_scriptSchedule.empty())
        sScriptMgr->DecreaseScheduledScriptCount(m_scriptSchedule.size());
}

References m_scriptSchedule, and sScriptMgr.

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 || 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(), WorldObject::setActive(), 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);
 
    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, MAX_VISIBILITY_DISTANCE, SendInitSelf(), SendInitTransports(), 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().

◆ 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())
        grid->AddGridObject(cell.CellX(), cell.CellY(), obj);
}

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

◆ AddToGrid() [2/5]

template<>

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

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

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

◆ AddToGrid() [3/5]

template<>

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

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

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

◆ AddToGrid() [4/5]

template<>

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

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

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

◆ AddToGrid() [5/5]

template<class T >

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

protected

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

References MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::AddGridObject(), 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<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);
 
    //something, such as vehicle, needs to be update immediately
    //also, trigger needs to cast spell, if not update, cannot see visual
    obj->UpdateObjectVisibility(true);
 
    // Post-visibility so accessories seat after the vehicle's create packet reaches clients.
    if (obj->IsCreature())
        if (Vehicle* vehicle = obj->ToCreature()->GetVehicleKit())
            vehicle->Reset();
    return true;
}

References 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().

◆ AddToMap() [2/2]

template<>

bool Map::AddToMap	(	Transport *	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);
    EnsureGridLoaded(cell);
 
    obj->AddToWorld();
 
    _transports.insert(obj);
 
    // Broadcast creation to players
    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, GameObject::AddToWorld(), GridRefMgr< MapGridType >::begin(), Object::BuildCreateUpdateBlockForPlayer(), UpdateData::BuildPacket(), Acore::ComputeCellCoord(), MapRefMgr::end(), EnsureGridLoaded(), Object::GetGUID(), GetPlayers(), Position::GetPositionX(), Position::GetPositionY(), CoordPair< LIMIT >::IsCoordValid(), Object::IsInWorld(), LOG_ERROR, ObjectGuid::ToString(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

◆ AddUpdateObject()

void Map::AddUpdateObject ( Object * obj )

inline

    {
        _updateObjects.insert(obj);
    }

References _updateObjects.

Referenced by WorldObject::AddToObjectUpdate().

◆ AddWorldObjectToFarVisibleMap()

void Map::AddWorldObjectToFarVisibleMap ( WorldObject * obj )

{
    if (Creature* creature = obj->ToCreature())
    {
        if (!creature->IsInGrid())
            return;
 
        Cell curr_cell = creature->GetCurrentCell();
        MapGridType* grid = GetMapGrid(curr_cell.GridX(), curr_cell.GridY());
        grid->AddFarVisibleObject(curr_cell.CellX(), curr_cell.CellY(), creature);
    }
    else if (GameObject* go = obj->ToGameObject())
    {
        if (!go->IsInGrid())
            return;
 
        Cell curr_cell = go->GetCurrentCell();
        MapGridType* grid = GetMapGrid(curr_cell.GridX(), curr_cell.GridY());
        grid->AddFarVisibleObject(curr_cell.CellX(), curr_cell.CellY(), go);
    }
}

References MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::AddFarVisibleObject(), Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), Object::ToCreature(), and Object::ToGameObject().

Referenced by WorldObject::AddToMapVisibilityOverrideContainers().

◆ AddWorldObjectToZoneWideVisibleMap()

void Map::AddWorldObjectToZoneWideVisibleMap	(	uint32	zoneId,
		WorldObject *	obj
	)

{
    _zoneWideVisibleWorldObjectsMap[zoneId].insert(obj);
}

References _zoneWideVisibleWorldObjectsMap.

Referenced by WorldObject::AddToMapVisibilityOverrideContainers(), WorldObject::AddToWorld(), and WorldObject::ProcessPositionDataChanged().

◆ AfterPlayerUnlinkFromMap()

void Map::AfterPlayerUnlinkFromMap ( )

virtual

Reimplemented in InstanceMap.

733{

734}

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

394{ _mapCollisionData.GetDynamicTree().balance(); }

DynamicMapTree::balance

void balance()

Definition DynamicTree.cpp:132

MapCollisionData::GetDynamicTree

DynamicVMapCollisionData & GetDynamicTree()

Definition MapCollisionData.h:82

References _mapCollisionData, DynamicMapTree::balance(), and MapCollisionData::GetDynamicTree().

Referenced by EnsureGridLoaded().

◆ CannotEnter()

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

inlinevirtual

Reimplemented in InstanceMap, BattlegroundMap, and MapInstanced.

287{ 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 || Events.HasEvents())
            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 = _mapCollisionData.GetStaticTree().GetObjectHitPos(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 = _mapCollisionData.GetDynamicTree().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 _mapCollisionData, PathGenerator::CalculatePath(), CanFly, CONTACT_DISTANCE, WorldObject::GetCollisionHeight(), MapCollisionData::GetDynamicTree(), GetGridHeight(), Unit::GetHoverHeight(), StaticVMapCollisionData::GetObjectHitPos(), DynamicVMapCollisionData::GetObjectHitPos(), PathGenerator::GetPath(), PathGenerator::GetPathType(), WorldObject::GetPhaseMask(), MapCollisionData::GetStaticTree(), 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

397{ return _mapCollisionData.GetDynamicTree().contains(model);}

DynamicMapTree::contains

bool contains(const GameObjectModel &) const

Definition DynamicTree.cpp:127

References _mapCollisionData, DynamicMapTree::contains(), and MapCollisionData::GetDynamicTree().

◆ 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();)
    {
        Transport* transport = *_transportsUpdateIter;
        ++_transportsUpdateIter;
 
        if (!transport->IsInWorld())
            continue;
 
        transport->DelayedUpdate(t_diff);
    }
 
    RemoveAllObjectsInRemoveList();
}

References _transports, _transportsUpdateIter, Transport::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();
    _respawnQueue.clear();
 
    DeleteRespawnTimesInDB(GetId(), GetInstanceId());
}

References _creatureRespawnTimes, _goRespawnTimes, _respawnQueue, 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(), ScriptedAI::DoRewardPlayersInArea(), InstanceScript::DoSendNotifyToInstance(), InstanceScript::DoStartTimedAchievement(), InstanceScript::DoStopTimedAchievement(), InstanceScript::DoUpdateAchievementCriteria(), BattlegroundSA::EventPlayerDamagedGO(), BattlegroundSA::EventPlayerUsedGO(), boss_azuregos::boss_azuregosAI::JustDied(), boss_rajaxx::JustDied(), boss_alar::JustDied(), boss_devourer_of_souls::JustEngagedWith(), boss_felblood_kaelthas::LapseAction(), spell_malygos_vortex_visual::OnRemove(), BattlegroundSA::PostUpdateImpl(), spell_fire_festival_fortitude::PrepareSpellScript(), boss_azuregos::boss_azuregosAI::Reset(), boss_yoggsaron_sara::Reset(), npc_minigob_manabonk::SelectTargetInDalaran(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::SetBossState(), instance_halls_of_reflection::SetBossState(), instance_ulduar::instance_ulduar_InstanceMapScript::SetBossState(), instance_halls_of_reflection::SetData(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetData(), Battleground::SpiritOfCompetitionEvent(), boss_nefarian::UpdateAI(), boss_cthun::UpdateAI(), boss_malygos::UpdateAI(), npc_gunship::npc_gunshipAI::UpdateAI(), npc_midsummer_bonfire::UpdateBonfireBlessingBuffs(), instance_halls_of_reflection::UpdateOutro(), and instance_eye_of_eternity::VortexHandling().

◆ 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(), MapGridManager::CreateGrid(), EnsureGridLoaded(), and GetGridTerrainData().

◆ 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(), and MotionTransport::UpdatePassengerPositions().

◆ 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(), StaticTransport::LoadGameObjectFromDB(), Pet::LoadPetFromDB(), Battlefield::SpawnCreature(), Battlefield::SpawnGameObject(), WorldObject::SummonGameObject(), and Player::SummonPet().

◆ GetAllTransports()

TransportsContainer const & Map::GetAllTransports ( ) const

inline

514{ return _transports; }

References _transports.

Referenced by go_commandscript::DoTeleportToTransport(), and 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 check_z = z;
    VMAP::AreaAndLiquidData vdata;
    VMAP::AreaAndLiquidData ddata;
 
    bool hasVmapAreaInfo = _mapCollisionData.GetStaticTree().GetAreaAndLiquidData(x, y, z, {}, vdata) && vdata.areaInfo.has_value();
    bool hasDynamicAreaInfo = _mapCollisionData.GetDynamicTree().GetAreaAndLiquidData(x, y, z, phaseMask, {}, ddata) && ddata.areaInfo.has_value();
    auto useVmap = [&] { check_z = vdata.floorZ; groupId = vdata.areaInfo->groupId; adtId = vdata.areaInfo->adtId; rootId = vdata.areaInfo->rootId; flags = vdata.areaInfo->mogpFlags; };
    auto useDyn = [&] { check_z = ddata.floorZ; groupId = ddata.areaInfo->groupId; adtId = ddata.areaInfo->adtId; rootId = ddata.areaInfo->rootId; flags = ddata.areaInfo->mogpFlags; };
    if (hasVmapAreaInfo)
    {
        if (hasDynamicAreaInfo && ddata.floorZ > vdata.floorZ)
            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 _mapCollisionData, VMAP::AreaAndLiquidData::areaInfo, VMAP::AreaAndLiquidData::floorZ, StaticVMapCollisionData::GetAreaAndLiquidData(), DynamicMapTree::GetAreaAndLiquidData(), MapCollisionData::GetDynamicTree(), GetGridTerrainData(), and MapCollisionData::GetStaticTree().

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

355{ return _creatureBySpawnIdStore; }

Map::_creatureBySpawnIdStore

CreatureBySpawnIdContainer _creatureBySpawnIdStore

Definition Map.h:684

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 MotionTransport::CreateNPCPassenger(), GetLinkedRespawnTime(), GetRespawnTime(), and Creature::LoadCreatureFromDB().

◆ GetCreatureRespawnTimes()

std::unordered_map< ObjectGuid::LowType, time_t > const & Map::GetCreatureRespawnTimes ( ) const

inline

429{ return _creatureRespawnTimes; }

References _creatureRespawnTimes.

Referenced by list_commandscript::HandleListRespawnsCommand(), and misc_commandscript::HandleRespawnAllCommand().

◆ 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

292{ return Difficulty(GetSpawnMode()); }

Difficulty

Definition DBCEnums.h:266

Map::GetSpawnMode

uint8 GetSpawnMode() const

Definition Map.h:269

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(), instance_commandscript::HandleInstanceGetBossStateCommand(), 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

398{ return _mapCollisionData.GetDynamicTree(); }

References _mapCollisionData, and MapCollisionData::GetDynamicTree().

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

173{ 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,
		Optional< uint8 >	reqLiquidType = `{}`
	)

{
    GridTerrainData* gmap = GetGridTerrainData(x, y);
 
    VMAP::AreaAndLiquidData vmapData;
    // VMAP::AreaAndLiquidData dynData;
    VMAP::AreaAndLiquidData* wmoData = nullptr;
    _mapCollisionData.GetStaticTree().GetAreaAndLiquidData(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 _mapCollisionData, AREA_FLAG_INSIDE, AREA_FLAG_OUTSIDE, PositionFullTerrainStatus::areaId, WMOAreaTableEntry::areaId, VMAP::AreaAndLiquidData::areaInfo, LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, WMOAreaTableEntry::Flags, VMAP::AreaAndLiquidData::floorZ, PositionFullTerrainStatus::floorZ, GridTerrainData::getArea(), StaticVMapCollisionData::GetAreaAndLiquidData(), GetGridTerrainData(), GridTerrainData::getHeight(), GetId(), GridTerrainData::GetLiquidData(), MapCollisionData::GetStaticTree(), 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

358{ return _gameobjectBySpawnIdStore; }

Map::_gameobjectBySpawnIdStore

GameObjectBySpawnIdContainer _gameobjectBySpawnIdStore

Definition Map.h:685

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 _mapCollisionData.GetDynamicTree().getHeight(x, y, z, maxSearchDist, phasemask);
    }

References _mapCollisionData, MapCollisionData::GetDynamicTree(), 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 MotionTransport::CreateGOPassenger(), GetLinkedRespawnTime(), GetRespawnTime(), and GameObject::LoadGameObjectFromDB().

◆ GetGORespawnTimes()

std::unordered_map< ObjectGuid::LowType, time_t > const & Map::GetGORespawnTimes ( ) const

inline

430{ return _goRespawnTimes; }

References _goRespawnTimes.

Referenced by list_commandscript::HandleListRespawnsCommand(), and misc_commandscript::HandleRespawnAllCommand().

◆ 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< GRID_OBJECT_TYPES, FAR_VISIBLE_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 )

{
    MapGridType* grid = _mapGridManager.GetGrid(gridCoord.x_coord, gridCoord.y_coord);
    ASSERT(grid); // Grid should always exist during this call
    return grid->GetTerrainDataSharedPtr();
}

References _mapGridManager, ASSERT, MapGridManager::GetGrid(), MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_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/3]

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)
        vmapHeight = _mapCollisionData.GetStaticTree().getHeight(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 _mapCollisionData, GetGridHeight(), StaticVMapCollisionData::getHeight(), MapCollisionData::GetStaticTree(), 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_mimiron_magnetic_core_summon::ModDest(), Spell::SelectImplicitCasterDestTargets(), boss_yoggsaron_sara::SpawnTentacle(), and npc_cork_gizelton::npc_cork_gizeltonAI::WaypointReached().

◆ GetHeight() [2/3]

float Map::GetHeight	(	Position const &	pos,
		bool	checkVMap = `true`,
		float	maxSearchDist = `DEFAULT_HEIGHT_SEARCH`
	)		const

inline

243{ return GetHeight(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), checkVMap, maxSearchDist); }

Map::GetHeight

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

Definition Map.cpp:1156

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

Referenced by GetHeight().

◆ GetHeight() [3/3]

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 = _mapCollisionData.GetDynamicTree().getHeight(x, y, z, maxSearchDist, phasemask);
    return std::max<float>(h1, h2);
}

References _mapCollisionData, MapCollisionData::GetDynamicTree(), GetHeight(), and DynamicMapTree::getHeight().

◆ GetId()

uint32 Map::GetId ( ) const

inline

232{ return i_mapEntry->MapID; }

MapEntry::MapID

uint32 MapID

Definition DBCStructure.h:1326

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(), GetDebugInfo(), GetFullTerrainStatusForPosition(), GetLiquidData(), GetMapDifficulty(), debug_commandscript::HandleDebugObjectCountMap(), spell_valkyr_touch_aura::HandleEffectPeriodic(), gobject_commandscript::HandleGameObjectAddCommand(), go_commandscript::HandleGoZoneXYCommand(), instance_commandscript::HandleInstanceGetBossStateCommand(), list_commandscript::HandleListRespawnsCommand(), WorldSession::HandleMoveWorldportAck(), npc_commandscript::HandleNpcAddCommand(), WorldSession::HandlePlayerLoginFromDB(), WorldSession::HandlePlayerLoginToCharInWorld(), WorldSession::HandleSetRaidDifficultyOpcode(), wp_commandscript::HandleWpModifyCommand(), wp_commandscript::HandleWpShowCommand(), InitVisibilityDistance(), InstanceMap::InitVisibilityDistance(), Player::inRandomLfgDungeon(), DisableMgr::IsPathfindingEnabled(), InstanceScript::IsTwoFactionInstance(), GridObjectLoader::LoadAllCellsInGrid(), LoadCorpseData(), GridTerrainLoader::LoadMap(), GridTerrainLoader::LoadMMap(), MapCollisionData::LoadMMapTile(), LoadRespawnTimes(), GridTerrainLoader::LoadVMap(), LogEncounterFinished(), MapCollisionData::MapCollisionData(), 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(), SpawnGroupDespawn(), SpawnGroupSpawn(), SummonCreatureGroup(), SummonGameObjectGroup(), MotionTransport::TeleportTransport(), UnloadGrid(), Update(), and UpdateEncounterState().

◆ GetInstanceId()

uint32 Map::GetInstanceId ( ) const

inline

268{ return i_InstanceId; }

References i_InstanceId.

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

◆ GetInstanceResetPeriod()

time_t Map::GetInstanceResetPeriod ( ) const

inline

433{ 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,
		Optional< uint8 >	ReqLiquidType
	)

{
   LiquidData liquidData;
   liquidData.Status = LIQUID_MAP_NO_WATER;
 
    VMAP::AreaAndLiquidData vmapData;
    bool useGridLiquid = true;
    if (_mapCollisionData.GetStaticTree().GetAreaAndLiquidData(x, y, z, ReqLiquidType, vmapData) && vmapData.liquidInfo)
    {
        useGridLiquid = !vmapData.areaInfo || !IsInWMOInterior(vmapData.areaInfo->mogpFlags);
        LOG_DEBUG("maps", "GetLiquidStatus(): vmap liquid level: {} ground: {} type: {}", vmapData.liquidInfo->level, vmapData.floorZ, vmapData.liquidInfo->type);
        // Check water level and ground level
        if (vmapData.liquidInfo->level > vmapData.floorZ && G3D::fuzzyGe(z, vmapData.floorZ - GROUND_HEIGHT_TOLERANCE))
        {
            // hardcoded in client like this
            if (GetId() == MAP_OUTLAND && vmapData.liquidInfo->type == 2)
                vmapData.liquidInfo->type = 15;
 
            uint32 liquidFlagType = 0;
            if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(vmapData.liquidInfo->type))
                liquidFlagType = liq->Type;
 
            if (vmapData.liquidInfo->type && vmapData.liquidInfo->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))
                    {
                        vmapData.liquidInfo->type = overrideLiquid;
                        liquidFlagType = liq->Type;
                    }
                }
            }
 
            liquidData.Level = vmapData.liquidInfo->level;
            liquidData.DepthLevel = vmapData.floorZ;
            liquidData.Entry = vmapData.liquidInfo->type;
            liquidData.Flags = 1 << liquidFlagType;
        }
 
        float delta = vmapData.liquidInfo->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 > vmapData.floorZ))
            {
                // 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 _mapCollisionData, VMAP::AreaAndLiquidData::areaInfo, LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, VMAP::AreaAndLiquidData::floorZ, StaticVMapCollisionData::GetAreaAndLiquidData(), GetAreaId(), GetGridTerrainData(), GetId(), MapCollisionData::GetStaticTree(), GROUND_HEIGHT_TOLERANCE, IsInWMOInterior(), LiquidData::Level, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_IN_WATER, LIQUID_MAP_NO_WATER, LIQUID_MAP_UNDER_WATER, LIQUID_MAP_WATER_WALK, VMAP::AreaAndLiquidData::liquidInfo, 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().

◆ GetMapCollisionData() [1/2]

MapCollisionData & Map::GetMapCollisionData ( )

inline

564{ return _mapCollisionData; }

References _mapCollisionData.

Referenced by misc_commandscript::HandleGPSCommand(), mmaps_commandscript::HandleMmapLoadedTilesCommand(), mmaps_commandscript::HandleMmapLocCommand(), mmaps_commandscript::HandleMmapPathCommand(), mmaps_commandscript::HandleMmapStatsCommand(), GridTerrainLoader::LoadMMap(), GridTerrainLoader::LoadVMap(), MapCollisionData::MapCollisionData(), PathGenerator::PathGenerator(), spell_entropius_black_hole_effect::RaycastToObstacle(), and Spell::SelectImplicitCasterDestTargets().

◆ GetMapCollisionData() [2/2]

MapCollisionData const & Map::GetMapCollisionData ( ) const

inline

565{ return _mapCollisionData; }

References _mapCollisionData.

◆ 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(), AddWorldObjectToFarVisibleMap(), RemoveWorldObjectFromFarVisibleMap(), 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.

◆ GetObjectsStore()

MapStoredObjectTypesContainer & Map::GetObjectsStore ( )

inline

352{ 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().

◆ GetOrGenerateZoneDefaultWeather()

Weather * Map::GetOrGenerateZoneDefaultWeather ( uint32 zoneId )

{
    WeatherData const* weatherData = WeatherMgr::GetWeatherData(zoneId);
    if (!weatherData)
        return nullptr;
 
    ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
 
    if (!info.DefaultWeather)
    {
        info.DefaultWeather = std::make_unique<Weather>(this, zoneId, weatherData);
        info.DefaultWeather->ReGenerate();
        info.DefaultWeather->UpdateWeather();
    }
 
    return info.DefaultWeather.get();
}

References _zoneDynamicInfo, ZoneDynamicInfo::DefaultWeather, and WeatherMgr::GetWeatherData().

Referenced by misc_commandscript::HandleChangeWeather(), npc_herald_of_the_lich_king::UpdateWeather(), npc_pallid_horror::UpdateWeather(), and Player::UpdateZone().

◆ GetParent()

Map const * Map::GetParent ( ) const

inline

234{ return m_parentMap; }

References m_parentMap.

Referenced by MapGridManager::CreateGrid(), and GridTerrainLoader::LoadMap().

◆ GetPet()

Pet * Map::GetPet ( ObjectGuid const & guid )

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

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

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

◆ GetPlayerCountInZone()

uint32 Map::GetPlayerCountInZone ( uint32 zoneId ) const

inline

    {
        if (auto const& it = _zonePlayerCountMap.find(zoneId); it != _zonePlayerCountMap.end())
            return it->second;
 
        return 0;
    };

References _zonePlayerCountMap.

Referenced by debug_commandscript::HandleDebugZoneStatsCommand().

◆ GetPlayers()

PlayerList const & Map::GetPlayers ( ) const

inline

329{ return m_mapRefMgr; }

Map::m_mapRefMgr

MapRefMgr m_mapRefMgr

Definition Map.h:604

References m_mapRefMgr.

◆ GetPlayersCountExceptGMs()

uint32 Map::GetPlayersCountExceptGMs ( bool aliveOnly = false ) const

{
    uint32 count = 0;
    for (auto const& ref : m_mapRefMgr)
        if (Player* player = ref.GetSource())
            if (!player->IsGameMaster() && (!aliveOnly || (player->IsAlive() && !player->HasSpiritOfRedemptionAura())))
                ++count;
    return count;
}

References m_mapRefMgr.

Referenced by InstanceMap::CannotEnter(), instance_naxxramas::CheckAchievementCriteriaMeet(), instance_obsidian_sanctum::instance_obsidian_sanctum_InstanceMapScript::CheckAchievementCriteriaMeet(), instance_violet_hold::instance_violet_hold_InstanceMapScript::DoNeedCleanup(), 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_eye_of_eternity::SetBossState(), instance_hyjal::instance_mount_hyjal_InstanceMapScript::SetData(), and instance_halls_of_reflection::Update().

◆ GetRespawnTime()

time_t Map::GetRespawnTime	(	SpawnObjectType	type,
		ObjectGuid::LowType	spawnId
	)		const

inline

    {
        switch (type)
        {
            case SPAWN_TYPE_CREATURE:
                return GetCreatureRespawnTime(spawnId);
            case SPAWN_TYPE_GAMEOBJECT:
                return GetGORespawnTime(spawnId);
            default:
                return time_t(0);
        }
    }

References GetCreatureRespawnTime(), GetGORespawnTime(), SPAWN_TYPE_CREATURE, and SPAWN_TYPE_GAMEOBJECT.

Referenced by SpawnGroupSpawn().

◆ GetSpawnMode()

uint8 Map::GetSpawnMode ( ) const

inline

269{ return (i_spawnMode); }

References i_spawnMode.

Referenced by InstanceMap::AddPlayerToMap(), InstanceMap::CannotEnter(), SmartScript::FillScript(), GetDifficulty(), SpellMgr::GetSpellIdForDifficulty(), 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::SetBossState(), 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::HandleMoverRelocation(), 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().

◆ GetUpdatableObjectsCount()

size_t Map::GetUpdatableObjectsCount ( ) const

inline

535{ return _updatableObjectList.size(); }

References _updatableObjectList.

Referenced by debug_commandscript::HandleDebugObjectCountMap().

◆ GetVisibilityRange()

float Map::GetVisibilityRange ( ) const

inline

198{ 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, {});
    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, 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().

◆ GetZoneWideVisibleWorldObjectsForZone()

ZoneWideVisibleWorldObjectsSet const * Map::GetZoneWideVisibleWorldObjectsForZone ( uint32 zoneId ) const

{
    ZoneWideVisibleWorldObjectsMap::const_iterator itr = _zoneWideVisibleWorldObjectsMap.find(zoneId);
    if (itr == _zoneWideVisibleWorldObjectsMap.end())
        return nullptr;
 
    return &itr->second;
}

References _zoneWideVisibleWorldObjectsMap.

Referenced by debug_commandscript::HandleDebugVisibilityDataCommand(), and Acore::VisibleNotifier::SendToSelf().

◆ 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

322{ return !m_mapRefMgr.IsEmpty(); }

LinkedListHead::IsEmpty

bool IsEmpty() const

Definition LinkedList.h:97

References LinkedListHead::IsEmpty(), and m_mapRefMgr.

Referenced by InstanceMap::AfterPlayerUnlinkFromMap(), MapInstanced::CreateInstanceForPlayer(), GetDebugInfo(), instance_halls_of_reflection::IsEncounterInProgress(), RemoveAllPlayers(), BattlegroundMap::RemoveAllPlayers(), InstanceMap::Reset(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SpawnGunship(), InstanceMap::UnloadAll(), instance_halls_of_reflection::Update(), and npc_hor_lich_king::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

288{

289}

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

396{ _mapCollisionData.GetDynamicTree().insert(model); }

DynamicMapTree::insert

void insert(const GameObjectModel &)

Definition DynamicTree.cpp:117

References _mapCollisionData, MapCollisionData::GetDynamicTree(), and DynamicMapTree::insert().

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

◆ Instanceable()

bool Map::Instanceable ( ) const

inline

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

MapEntry::Instanceable

bool Instanceable() const

Definition DBCStructure.h:1353

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

302{ 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:299

References i_spawnMode, IsRaid(), and RAID_DIFFICULTY_MASK_25MAN.

Referenced by boss_thorim::DamageTaken(), boss_yoggsaron_sara::DoAction(), instance_commandscript::HandleInstanceGetBossStateCommand(), 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(), boss_flame_leviathan_seat::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_freya::UpdateAI(), boss_vezax::UpdateAI(), boss_yoggsaron_sara::UpdateAI(), and UpdateEncounterState().

◆ IsBattleArena()

bool Map::IsBattleArena ( ) const

inline

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

MapEntry::IsBattleArena

bool IsBattleArena() const

Definition DBCStructure.h:1356

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

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

MapEntry::IsBattleground

bool IsBattleground() const

Definition DBCStructure.h:1355

References i_mapEntry, and MapEntry::IsBattleground().

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

◆ IsBattlegroundOrArena()

bool Map::IsBattlegroundOrArena ( ) const

inline

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

MapEntry::IsBattlegroundOrArena

bool IsBattlegroundOrArena() const

Definition DBCStructure.h:1357

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

319{ 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:624

References marked_cells.

◆ IsDungeon()

bool Map::IsDungeon ( ) const

inline

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

MapEntry::IsDungeon

bool IsDungeon() const

Definition DBCStructure.h:1351

References i_mapEntry, and MapEntry::IsDungeon().

Referenced by Group::_cancelHomebindIfInstance(), Group::_homebindIfInstance(), InstanceSaveMgr::_ResetOrWarnAll(), InstanceMap::AddPlayerToMap(), GameObject::AddToSkillupList(), Spell::CheckCast(), TransportMgr::CreateTransport(), ScriptedAI::DoTeleportAll(), CreatureAI::DoZoneInCombat(), Spell::EffectSanctuary(), Spell::EffectTeleportUnits(), SmartScript::FillScript(), WorldObject::GetInstanceScript(), Unit::GetMeleeAttackPoint(), SpellMgr::GetSpellIdForDifficulty(), misc_commandscript::HandleAppearCommand(), WorldSession::HandleAreaTriggerOpcode(), spell_freezing_circle::HandleDamage(), spell_item_nitro_boots::HandleDummy(), AuraEffect::HandleFeignDeath(), 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(), ProcessCreatureRespawn(), ProcessGameObjectRespawn(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::SetData(), SpawnGroupSpawn(), UpdateCreatureHalaa(), and Visit().

◆ IsHeroic()

bool Map::IsHeroic ( ) const

inline

301{ 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) && !_mapCollisionData.GetStaticTree().isInLineOfSight(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 (!_mapCollisionData.GetDynamicTree().isInLineOfSight(x1, y1, z1, x2, y2, z2, phasemask, ignoreFlags))
        {
            return false;
        }
    }
 
    return true;
}

References _mapCollisionData, CONFIG_CHECK_GOBJECT_LOS, CONFIG_VMAP_BLIZZLIKE_LOS_OPEN_WORLD, CONFIG_VMAP_BLIZZLIKE_PVP_LOS, MapCollisionData::GetDynamicTree(), MapCollisionData::GetStaticTree(), IsBattlegroundOrArena(), DynamicMapTree::isInLineOfSight(), StaticVMapCollisionData::isInLineOfSight(), IsWorldMap(), LINEOFSIGHT_CHECK_GOBJECT_ALL, LINEOFSIGHT_CHECK_GOBJECT_M2, LINEOFSIGHT_CHECK_VMAP, VMAP::M2, VMAP::Nothing, and sWorld.

Referenced by Unit::_ExitVehicle(), RandomMovementGenerator< T >::_setRandomLocation(), 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, {});
    return (liquidData.Status & MAP_LIQUID_STATUS_SWIMMING) != 0;
}

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

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

◆ IsNonRaidDungeon()

bool Map::IsNonRaidDungeon ( ) const

inline

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

MapEntry::IsNonRaidDungeon

bool IsNonRaidDungeon() const

Definition DBCStructure.h:1352

References i_mapEntry, and MapEntry::IsNonRaidDungeon().

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

◆ IsRaid()

bool Map::IsRaid ( ) const

inline

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

MapEntry::IsRaid

bool IsRaid() const

Definition DBCStructure.h:1354

References i_mapEntry, and MapEntry::IsRaid().

Referenced by Group::_cancelHomebindIfInstance(), InstanceMap::CannotEnter(), Creature::CreateFromProto(), MapInstanced::CreateInstanceForPlayer(), UnitAI::EvadeTimerExpired(), 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

300{ 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

293{ return GetDifficulty() == REGULAR_DIFFICULTY; }

REGULAR_DIFFICULTY

@ REGULAR_DIFFICULTY

Definition DBCEnums.h:267

References GetDifficulty(), and REGULAR_DIFFICULTY.

◆ IsSpawnGroupActive()

bool Map::IsSpawnGroupActive ( uint32 groupId ) const

{
    SpawnGroupTemplateData const* data = sObjectMgr->GetSpawnGroupData(groupId);
    if (!data)
        return false;
 
    // System groups are always active
    if (data->flags & SPAWNGROUP_FLAG_SYSTEM)
        return true;
 
    // Per-map toggled state: XOR with default.
    // MANUAL_SPAWN groups default to inactive; toggling makes them active.
    // Non-MANUAL groups default to active; toggling makes them inactive.
    bool toggled = _toggledSpawnGroupIds.count(groupId) != 0;
    bool defaultActive = !(data->flags & SPAWNGROUP_FLAG_MANUAL_SPAWN);
    return toggled != defaultActive; // XOR: toggled flips the default
}

References _toggledSpawnGroupIds, SpawnGroupTemplateData::flags, sObjectMgr, SPAWNGROUP_FLAG_MANUAL_SPAWN, and SPAWNGROUP_FLAG_SYSTEM.

Referenced by GridObjectLoader::LoadCreatures(), GridObjectLoader::LoadGameObjects(), ProcessCreatureRespawn(), and ProcessGameObjectRespawn().

◆ 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::ProcessMovementInfo().

◆ IsWorldMap()

bool Map::IsWorldMap ( ) const

inline

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

MapEntry::IsWorldMap

bool IsWorldMap() const

Definition DBCStructure.h:1358

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 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(), Unit::ExecuteDelayedUnitRelocationEvent(), CinematicMgr::StartCinematicCamera(), and CinematicMgr::UpdateCinematic().

◆ 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>();
            time_t respawnTime = time_t(fields[1].Get<uint32>());
 
            _creatureRespawnTimes[lowguid] = respawnTime;
            _respawnQueue.insert({respawnTime, SPAWN_TYPE_CREATURE, lowguid});
        } 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>();
            time_t respawnTime = time_t(fields[1].Get<uint32>());
 
            _goRespawnTimes[lowguid] = respawnTime;
            _respawnQueue.insert({respawnTime, SPAWN_TYPE_GAMEOBJECT, lowguid});
        } while (result->NextRow());
    }
}

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

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

320{ 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());
        if (c->IsFarVisible())
        {
            // Removes via GetCurrentCell, added back in AddToGrid
            RemoveWorldObjectFromFarVisibleMap(c);
        }
 
        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(), WorldObject::IsFarVisible(), Object::IsInWorld(), MAP_OBJECT_CELL_MOVE_ACTIVE, MAP_OBJECT_CELL_MOVE_NONE, GridObject< T >::RemoveFromGrid(), and RemoveWorldObjectFromFarVisibleMap().

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());
 
        if (go->IsFarVisible())
        {
            // Removes via GetCurrentCell, added back in AddToGrid
            RemoveWorldObjectFromFarVisibleMap(go);
        }
 
        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(), WorldObject::IsFarVisible(), Object::IsInWorld(), MAP_OBJECT_CELL_MOVE_ACTIVE, MAP_OBJECT_CELL_MOVE_NONE, GridObject< T >::RemoveFromGrid(), and RemoveWorldObjectFromFarVisibleMap().

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().

◆ ProcessCreatureRespawn()

void Map::ProcessCreatureRespawn ( ObjectGuid::LowType spawnId )

{
    // Pool members are handled entirely by PoolMgr
    if (uint32 poolId = sPoolMgr->IsPartOfAPool<Creature>(spawnId))
    {
        sPoolMgr->UpdatePool<Creature>(poolId, spawnId);
        RemoveCreatureRespawnTime(spawnId);
        return;
    }
 
    CreatureData const* data = sObjectMgr->GetCreatureData(spawnId);
    if (!data)
    {
        RemoveCreatureRespawnTime(spawnId);
        return;
    }
 
    // Compat-mode creatures handle their own respawn in-place — don't interfere.
    // Clean up the stale respawn time entry since the legacy system manages these.
    SpawnGroupTemplateData const* groupData = sObjectMgr->GetSpawnGroupData(data->spawnGroupId);
    if (!groupData || (groupData->flags & SPAWNGROUP_FLAG_COMPATIBILITY_MODE))
    {
        RemoveCreatureRespawnTime(spawnId);
        return;
    }
 
    // Don't respawn if the spawn group is not active
    if (!IsSpawnGroupActive(data->spawnGroupId))
    {
        // Re-queue — will be checked again next ProcessRespawns() tick
        _respawnQueue.insert({GameTime::GetGameTime().count() + 5, SPAWN_TYPE_CREATURE, spawnId});
        return;
    }
 
    // Skip if grid isn't loaded (will be handled in grid loader)
    if (!IsGridLoaded(data->posX, data->posY))
    {
        _respawnQueue.insert({GameTime::GetGameTime().count() + 5, SPAWN_TYPE_CREATURE, spawnId});
        return;
    }
 
    // Skip if already alive
    auto bounds = _creatureBySpawnIdStore.equal_range(spawnId);
    for (auto itr = bounds.first; itr != bounds.second; ++itr)
    {
        if (itr->second->IsAlive())
        {
            RemoveCreatureRespawnTime(spawnId);
            return;
        }
    }
 
    // Remove respawn time BEFORE LoadFromDB, otherwise the creature
    // reads it back and loads as DEAD instead of ALIVE
    RemoveCreatureRespawnTime(spawnId);
 
    Creature* creature = new Creature();
    if (!creature->LoadCreatureFromDB(spawnId, this, true, true))
        delete creature;
}

References _creatureBySpawnIdStore, _respawnQueue, SpawnGroupTemplateData::flags, GameTime::GetGameTime(), IsGridLoaded(), IsSpawnGroupActive(), Creature::LoadCreatureFromDB(), SpawnData::posX, SpawnData::posY, RemoveCreatureRespawnTime(), sObjectMgr, SPAWN_TYPE_CREATURE, SPAWNGROUP_FLAG_COMPATIBILITY_MODE, SpawnData::spawnGroupId, and sPoolMgr.

Referenced by ProcessRespawns().

◆ ProcessGameObjectRespawn()

void Map::ProcessGameObjectRespawn ( ObjectGuid::LowType spawnId )

{
    // Pool members are handled entirely by PoolMgr
    if (uint32 poolId = sPoolMgr->IsPartOfAPool<GameObject>(spawnId))
    {
        sPoolMgr->UpdatePool<GameObject>(poolId, spawnId);
        RemoveGORespawnTime(spawnId);
        return;
    }
 
    GameObjectData const* data = sObjectMgr->GetGameObjectData(spawnId);
    if (!data)
    {
        RemoveGORespawnTime(spawnId);
        return;
    }
 
    // Compat-mode gameobjects handle their own respawn — don't interfere.
    // Clean up the stale respawn time entry since the legacy system manages these.
    SpawnGroupTemplateData const* groupData = sObjectMgr->GetSpawnGroupData(data->spawnGroupId);
    if (!groupData || (groupData->flags & SPAWNGROUP_FLAG_COMPATIBILITY_MODE))
    {
        RemoveGORespawnTime(spawnId);
        return;
    }
 
    // Don't respawn if the spawn group is not active
    if (!IsSpawnGroupActive(data->spawnGroupId))
    {
        _respawnQueue.insert({GameTime::GetGameTime().count() + 5, SPAWN_TYPE_GAMEOBJECT, spawnId});
        return;
    }
 
    // Skip if grid isn't loaded (will be handled in grid loader)
    if (!IsGridLoaded(data->posX, data->posY))
    {
        _respawnQueue.insert({GameTime::GetGameTime().count() + 5, SPAWN_TYPE_GAMEOBJECT, spawnId});
        return;
    }
 
    if (_gameobjectBySpawnIdStore.count(spawnId))
    {
        RemoveGORespawnTime(spawnId);
        return;
    }
 
    // Remove respawn time BEFORE LoadFromDB, otherwise the GO
    // reads it back and loads as despawned
    RemoveGORespawnTime(spawnId);
 
    GameObject* gameobject = new GameObject();
    if (!gameobject->LoadGameObjectFromDB(spawnId, this, true))
        delete gameobject;
}

References _gameobjectBySpawnIdStore, _respawnQueue, SpawnGroupTemplateData::flags, GameTime::GetGameTime(), IsGridLoaded(), IsSpawnGroupActive(), GameObject::LoadGameObjectFromDB(), SpawnData::posX, SpawnData::posY, RemoveGORespawnTime(), sObjectMgr, SPAWN_TYPE_GAMEOBJECT, SPAWNGROUP_FLAG_COMPATIBILITY_MODE, SpawnData::spawnGroupId, and sPoolMgr.

Referenced by ProcessRespawns().

◆ ProcessRespawns()

void Map::ProcessRespawns ( )

{
    time_t now = GameTime::GetGameTime().count();
 
    // Process due respawns from the time-ordered queue.
    // Entries are sorted by respawnTime — once we hit a future time, we're done.
    while (!_respawnQueue.empty())
    {
        auto it = _respawnQueue.begin();
        if (it->respawnTime > now)
            break; // nothing else is due this tick
 
        SpawnObjectType type = it->type;
        ObjectGuid::LowType spawnId = it->spawnId;
 
        // Remove from queue first — handlers below call Remove*RespawnTime()
        // which also erases from queue, so we must pop before processing.
        _respawnQueue.erase(it);
 
        if (type == SPAWN_TYPE_CREATURE)
            ProcessCreatureRespawn(spawnId);
        else if (type == SPAWN_TYPE_GAMEOBJECT)
            ProcessGameObjectRespawn(spawnId);
    }
}

References _respawnQueue, GameTime::GetGameTime(), ProcessCreatureRespawn(), ProcessGameObjectRespawn(), SPAWN_TYPE_CREATURE, and SPAWN_TYPE_GAMEOBJECT.

Referenced by Update().

◆ 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 (Transport* transport = obj->ToGameObject()->ToTransport())
                    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(), ObjectGuid::ToString(), GameObject::ToTransport(), 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->DestroyForVisiblePlayers();
    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::DestroyForVisiblePlayers(), 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 )

{
    auto itr = _creatureRespawnTimes.find(spawnId);
    if (itr != _creatureRespawnTimes.end())
    {
        _respawnQueue.erase({itr->second, SPAWN_TYPE_CREATURE, spawnId});
        _creatureRespawnTimes.erase(itr);
    }
 
    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, _respawnQueue, CHAR_DEL_CREATURE_RESPAWN, CharacterDatabase, GetId(), GetInstanceId(), PreparedStatementBase::SetData(), and SPAWN_TYPE_CREATURE.

Referenced by Creature::DeleteFromDB(), ProcessCreatureRespawn(), RemoveRespawnTime(), 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().

◆ RemoveFromMap() [1/2]

template<class T >

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

{
    obj->RemoveFromWorld();
 
    obj->RemoveFromGrid();
 
    obj->ResetMap();
 
    if (remove)
    {
        RemoveObjectFromMapUpdateList(obj);
        DeleteFromWorld(obj);
    }
}

References DeleteFromWorld(), and RemoveObjectFromMapUpdateList().

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

◆ RemoveFromMap() [2/2]

template<>

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

{
    obj->RemoveFromWorld();
 
    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();
 
    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(), LinkedListHead::IsEmpty(), GameObject::RemoveFromWorld(), RemoveObjectFromMapUpdateList(), WorldObject::ResetMap(), GameObject::SaveRespawnTime(), and sWorld.

◆ 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

395{ _mapCollisionData.GetDynamicTree().remove(model); }

DynamicMapTree::remove

void remove(const GameObjectModel &)

Definition DynamicTree.cpp:122

References _mapCollisionData, MapCollisionData::GetDynamicTree(), and DynamicMapTree::remove().

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

◆ RemoveGORespawnTime()

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

{
    auto itr = _goRespawnTimes.find(spawnId);
    if (itr != _goRespawnTimes.end())
    {
        _respawnQueue.erase({itr->second, SPAWN_TYPE_GAMEOBJECT, spawnId});
        _goRespawnTimes.erase(itr);
    }
 
    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, _respawnQueue, CHAR_DEL_GO_RESPAWN, CharacterDatabase, GetId(), GetInstanceId(), PreparedStatementBase::SetData(), and SPAWN_TYPE_GAMEOBJECT.

Referenced by GameObject::DeleteFromDB(), GameObject::LoadGameObjectFromDB(), ProcessGameObjectRespawn(), RemoveRespawnTime(), 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 server_commandscript::HandleServerCorpsesCommand(), and UpdateExpiredCorpses().

◆ RemovePlayerFromMap()

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

virtual

Reimplemented in InstanceMap, and BattlegroundMap.

{
    UpdatePlayerZoneStats(player->GetZoneId(), MAP_INVALID_ZONE);
 
    player->GetThreatMgr().RemoveMeFromThreatLists(); // pussywizard: multithreading crashfix
 
    player->RemoveFromWorld();
    SendRemoveTransports(player);
 
    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(), Unit::GetThreatMgr(), WorldObject::GetZoneId(), GridObject< T >::IsInGrid(), MAP_INVALID_ZONE, GridObject< T >::RemoveFromGrid(), Player::RemoveFromWorld(), ThreatManager::RemoveMeFromThreatLists(), SendRemoveTransports(), sScriptMgr, and UpdatePlayerZoneStats().

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

◆ RemoveRespawnTime()

void Map::RemoveRespawnTime	(	SpawnObjectType	type,
		ObjectGuid::LowType	spawnId
	)

inline

    {
        switch (type)
        {
            case SPAWN_TYPE_CREATURE:
                RemoveCreatureRespawnTime(spawnId);
                break;
            case SPAWN_TYPE_GAMEOBJECT:
                RemoveGORespawnTime(spawnId);
                break;
            default:
                break;
        }
    }

References RemoveCreatureRespawnTime(), RemoveGORespawnTime(), SPAWN_TYPE_CREATURE, and SPAWN_TYPE_GAMEOBJECT.

Referenced by SpawnGroupDespawn(), and SpawnGroupSpawn().

◆ RemoveUpdateObject()

void Map::RemoveUpdateObject ( Object * obj )

inline

    {
        _updateObjects.erase(obj);
    }

References _updateObjects.

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

◆ RemoveWorldObjectFromFarVisibleMap()

void Map::RemoveWorldObjectFromFarVisibleMap ( WorldObject * obj )

{
    if (Creature* creature = obj->ToCreature())
    {
        Cell curr_cell = creature->GetCurrentCell();
        MapGridType* grid = GetMapGrid(curr_cell.GridX(), curr_cell.GridY());
        grid->RemoveFarVisibleObject(curr_cell.CellX(), curr_cell.CellY(), creature);
    }
    else if (GameObject* go = obj->ToGameObject())
    {
        Cell curr_cell = go->GetCurrentCell();
        MapGridType* grid = GetMapGrid(curr_cell.GridX(), curr_cell.GridY());
        grid->RemoveFarVisibleObject(curr_cell.CellX(), curr_cell.CellY(), go);
    }
}

References Cell::CellX(), Cell::CellY(), GetMapGrid(), Cell::GridX(), Cell::GridY(), MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::RemoveFarVisibleObject(), Object::ToCreature(), and Object::ToGameObject().

Referenced by MoveAllCreaturesInMoveList(), MoveAllGameObjectsInMoveList(), and WorldObject::RemoveFromMapVisibilityOverrideContainers().

◆ RemoveWorldObjectFromZoneWideVisibleMap()

void Map::RemoveWorldObjectFromZoneWideVisibleMap	(	uint32	zoneId,
		WorldObject *	obj
	)

{
    ZoneWideVisibleWorldObjectsMap::iterator itr = _zoneWideVisibleWorldObjectsMap.find(zoneId);
    if (itr == _zoneWideVisibleWorldObjectsMap.end())
        return;
 
    itr->second.erase(obj);
}

References _zoneWideVisibleWorldObjectsMap.

Referenced by WorldObject::ProcessPositionDataChanged(), and WorldObject::RemoveFromMapVisibilityOverrideContainers().

◆ resetMarkedCells()

void Map::resetMarkedCells ( )

inline

318{ 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;
 
    // Remove old queue entry if updating an existing respawn time
    auto itr = _creatureRespawnTimes.find(spawnId);
    if (itr != _creatureRespawnTimes.end())
        _respawnQueue.erase({itr->second, SPAWN_TYPE_CREATURE, spawnId});
 
    _creatureRespawnTimes[spawnId] = respawnTime;
    _respawnQueue.insert({respawnTime, SPAWN_TYPE_CREATURE, spawnId});
 
    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, _respawnQueue, CHAR_REP_CREATURE_RESPAWN, CharacterDatabase, GameTime::GetGameTime(), GetId(), GetInstanceId(), GetInstanceResetPeriod(), RemoveCreatureRespawnTime(), PreparedStatementBase::SetData(), SPAWN_TYPE_CREATURE, and YEAR.

Referenced by misc_commandscript::HandleRespawnAllCommand(), Creature::Respawn(), and 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;
 
    // Remove old queue entry if updating an existing respawn time
    auto itr = _goRespawnTimes.find(spawnId);
    if (itr != _goRespawnTimes.end())
        _respawnQueue.erase({itr->second, SPAWN_TYPE_GAMEOBJECT, spawnId});
 
    _goRespawnTimes[spawnId] = respawnTime;
    _respawnQueue.insert({respawnTime, SPAWN_TYPE_GAMEOBJECT, spawnId});
 
    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, _respawnQueue, CHAR_REP_GO_RESPAWN, CharacterDatabase, GameTime::GetGameTime(), GetId(), GetInstanceId(), GetInstanceResetPeriod(), RemoveGORespawnTime(), PreparedStatementBase::SetData(), SPAWN_TYPE_GAMEOBJECT, and YEAR.

Referenced by misc_commandscript::HandleRespawnAllCommand(), and GameObject::SaveRespawnTime().

◆ ScheduleCreatureRespawn()

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

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

References GetCreature(), ObjectGuid::GetEntry(), 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->GetMotionMaster()->MovePoint(0, step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, FORCED_MOVEMENT_NONE, 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(Milliseconds(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()->MoveWaypoint(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()->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()->MoveWaypoint(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, FORCED_MOVEMENT_NONE, 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(), Unit::GetMotionMaster(), 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, ScriptInfo::Movement, ScriptInfo::MovementDistance, ScriptInfo::MovementType, MotionMaster::MovePoint(), 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(), WaypointMovementGenerator< Creature >::DoUpdate(), Spell::EffectDummy(), Spell::EffectScriptEffect(), Spell::EffectSendEvent(), WaypointMovementGenerator< Creature >::ProcessWaypointArrival(), 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 )

{
    if (_transports.empty())
        return;
 
    // 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);
 
    if (!transData.HasData())
        return;
 
    WorldPacket packet;
    transData.BuildPacket(packet);
    player->SendDirectMessage(&packet);
}

References _transports, UpdateData::BuildPacket(), WorldObject::GetTransport(), UpdateData::HasData(), and Player::SendDirectMessage().

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

◆ SendObjectUpdates()

void Map::SendObjectUpdates ( )

private

{
    UpdateDataMapType update_players;
 
    while (!_updateObjects.empty())
    {
        Object* obj = *_updateObjects.begin();
        ASSERT(obj->IsInWorld());
 
        _updateObjects.erase(_updateObjects.begin());
        obj->BuildUpdate(update_players);
    }
 
    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->SendDirectMessage(&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 )

{
    if (_transports.empty())
        return;
 
    // 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);
 
    if (!transData.HasData())
        return;
 
    WorldPacket packet;
    transData.BuildPacket(packet);
    player->SendDirectMessage(&packet);
}

References _transports, UpdateData::BuildPacket(), WorldObject::GetTransport(), UpdateData::HasData(), and Player::SendDirectMessage().

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()->SendDirectMessage(data);
}

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

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

◆ SendZoneDynamicInfo()

void Map::SendZoneDynamicInfo	(	uint32	zoneId,
		Player *	player
	)		const

{
    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());
 
    SendZoneWeather(itr->second, player);
 
    if (uint32 overrideLight = itr->second.OverrideLightId)
    {
        WorldPacket data(SMSG_OVERRIDE_LIGHT, 4 + 4 + 4);
        data << uint32(_defaultLight);
        data << uint32(overrideLight);
        data << uint32(itr->second.LightFadeInTime);
        player->SendDirectMessage(&data);
    }
}

References _defaultLight, _zoneDynamicInfo, Player::SendDirectMessage(), SendZoneWeather(), and SMSG_OVERRIDE_LIGHT.

Referenced by Player::UpdateZone().

◆ SendZoneMessage()

bool Map::SendZoneMessage	(	uint32	zone,
		WorldPacket const *	packet,
		WorldSession const *	self = `nullptr`,
		TeamId	teamId = `TEAM_NEUTRAL`
	)		const

Send a packet to all players (or players selected team) in the zone (except self if mentioned)

{
    bool foundPlayerToSend = false;
 
    for (MapReference const& ref : GetPlayers())
    {
        Player* player = ref.GetSource();
        if (player->IsInWorld() &&
            player->GetZoneId() == zone &&
            player->GetSession() != self &&
            (teamId == TEAM_NEUTRAL || player->GetTeamId() == teamId))
        {
            player->SendDirectMessage(packet);
            foundPlayerToSend = true;
        }
    }
 
    return foundPlayerToSend;
}

References GetPlayers(), Player::GetSession(), Player::GetTeamId(), WorldObject::GetZoneId(), Object::IsInWorld(), Player::SendDirectMessage(), and TEAM_NEUTRAL.

Referenced by SendZoneText(), SetZoneMusic(), SetZoneOverrideLight(), SetZoneWeather(), and Weather::UpdateWeather().

◆ SendZoneText()

void Map::SendZoneText	(	uint32	zoneId,
		char const *	text,
		WorldSession const *	self = `nullptr`,
		TeamId	teamId = `TEAM_NEUTRAL`
	)		const

Send a System Message to all players in the zone (except self if mentioned)

{
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, text);
    SendZoneMessage(zoneId, &data, self, teamId);
}

References ChatHandler::BuildChatPacket(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, and SendZoneMessage().

Referenced by OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePointTF::ChangeState(), OPvPCapturePointZM_Beacon::ChangeState(), OPvPCapturePointNA::FactionTakeOver(), OutdoorPvPSI::HandleAreaTrigger(), OPvPCapturePointZM_Graveyard::HandleOpenGo(), and OPvPCapturePointNA::Update().

◆ SendZoneWeather() [1/2]

void Map::SendZoneWeather	(	uint32	zoneId,
		Player *	player
	)		const

{
    ZoneDynamicInfoMap::const_iterator itr = _zoneDynamicInfo.find(zoneId);
    if (itr == _zoneDynamicInfo.end())
        return;
 
    SendZoneWeather(itr->second, player);
}

References _zoneDynamicInfo, and SendZoneWeather().

Referenced by SendZoneDynamicInfo(), and SendZoneWeather().

◆ SendZoneWeather() [2/2]

void Map::SendZoneWeather	(	ZoneDynamicInfo const &	zoneDynamicInfo,
		Player *	player
	)		const

{
    if (WeatherState weatherId = zoneDynamicInfo.WeatherId)
    {
        WorldPackets::Misc::Weather weather(weatherId, zoneDynamicInfo.WeatherGrade);
        player->SendDirectMessage(weather.Write());
    }
    else if (zoneDynamicInfo.DefaultWeather)
        zoneDynamicInfo.DefaultWeather->SendWeatherUpdateToPlayer(player);
    else
        Weather::SendFineWeatherUpdateToPlayer(player);
}

References ZoneDynamicInfo::DefaultWeather, Player::SendDirectMessage(), Weather::SendFineWeatherUpdateToPlayer(), ZoneDynamicInfo::WeatherGrade, ZoneDynamicInfo::WeatherId, and WorldPackets::Misc::Weather::Write().

◆ SetVisibilityRange()

void Map::SetVisibilityRange ( float range )

inline

199{ 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
	)

{
    _zoneDynamicInfo[zoneId].MusicId = musicId;
 
    WorldPackets::Misc::PlayMusic playMusic(musicId);
    SendZoneMessage(zoneId, WorldPackets::Misc::PlayMusic(musicId).Write());
}

References _zoneDynamicInfo, and SendZoneMessage().

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
	)

{
    ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
    info.OverrideLightId = lightId;
    info.LightFadeInTime = static_cast<uint32>(fadeInTime.count());
 
    WorldPacket data(SMSG_OVERRIDE_LIGHT, 4 + 4 + 4);
    data << uint32(_defaultLight);
    data << uint32(lightId);
    data << uint32(static_cast<uint32>(fadeInTime.count()));
    SendZoneMessage(zoneId, &data);
}

References _defaultLight, _zoneDynamicInfo, ZoneDynamicInfo::LightFadeInTime, ZoneDynamicInfo::OverrideLightId, SendZoneMessage(), and SMSG_OVERRIDE_LIGHT.

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

◆ SetZoneWeather()

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

{
    ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
    info.WeatherId = weatherId;
    info.WeatherGrade = weatherGrade;
 
    SendZoneMessage(zoneId, WorldPackets::Misc::Weather(weatherId, weatherGrade).Write());
}

References _zoneDynamicInfo, SendZoneMessage(), ZoneDynamicInfo::WeatherGrade, and ZoneDynamicInfo::WeatherId.

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().

◆ SpawnGroupDespawn()

bool Map::SpawnGroupDespawn	(	uint32	groupId,
		bool	deleteRespawnTimes = `false`
	)

{
    SpawnGroupTemplateData const* groupData = sObjectMgr->GetSpawnGroupData(groupId);
    if (!groupData || (groupData->flags & SPAWNGROUP_FLAG_SYSTEM))
    {
        LOG_ERROR("maps", "Tried to despawn non-existing (or system) spawn group {}. Blocked.", groupId);
        return false;
    }
 
    if (groupData->mapId != SPAWNGROUP_MAP_UNSET && groupData->mapId != GetId())
    {
        LOG_ERROR("maps", "Tried to despawn group {} on map {}, but group has map {}. Blocked.",
            groupId, GetId(), groupData->mapId);
        return false;
    }
 
    // Mark group as inactive on this map (toggle to inactive state)
    if (groupData->flags & SPAWNGROUP_FLAG_MANUAL_SPAWN)
        _toggledSpawnGroupIds.erase(groupId);
    else
        _toggledSpawnGroupIds.insert(groupId);
 
    std::vector<WorldObject*> toUnload;
    auto range = sObjectMgr->GetSpawnDataForGroup(groupId);
    for (auto it = range.first; it != range.second; ++it)
    {
        SpawnData const* data = it->second;
        ObjectGuid::LowType spawnId = data->spawnId;
 
        if (deleteRespawnTimes)
            RemoveRespawnTime(data->type, spawnId);
 
        switch (data->type)
        {
            case SPAWN_TYPE_CREATURE:
            {
                auto bounds = _creatureBySpawnIdStore.equal_range(spawnId);
                for (auto itr = bounds.first; itr != bounds.second; ++itr)
                    toUnload.emplace_back(itr->second);
                break;
            }
            case SPAWN_TYPE_GAMEOBJECT:
            {
                auto bounds = _gameobjectBySpawnIdStore.equal_range(spawnId);
                for (auto itr = bounds.first; itr != bounds.second; ++itr)
                    toUnload.emplace_back(itr->second);
                break;
            }
            default:
                break;
        }
    }
 
    for (WorldObject* obj : toUnload)
        obj->AddObjectToRemoveList();
 
    return true;
}

References _creatureBySpawnIdStore, _gameobjectBySpawnIdStore, _toggledSpawnGroupIds, SpawnGroupTemplateData::flags, GetId(), LOG_ERROR, SpawnGroupTemplateData::mapId, RemoveRespawnTime(), sObjectMgr, SPAWN_TYPE_CREATURE, SPAWN_TYPE_GAMEOBJECT, SPAWNGROUP_FLAG_MANUAL_SPAWN, SPAWNGROUP_FLAG_SYSTEM, SPAWNGROUP_MAP_UNSET, SpawnData::spawnId, and SpawnData::type.

Referenced by gobject_commandscript::HandleGameObjectDespawnGroupCommand(), npc_commandscript::HandleNpcDespawnGroupCommand(), and SmartScript::ProcessAction().

◆ SpawnGroupSpawn()

bool Map::SpawnGroupSpawn	(	uint32	groupId,
		bool	ignoreRespawn = `false`,
		bool	force = `false`
	)

{
    SpawnGroupTemplateData const* groupData = sObjectMgr->GetSpawnGroupData(groupId);
    if (!groupData || (groupData->flags & SPAWNGROUP_FLAG_SYSTEM))
    {
        LOG_ERROR("maps", "Tried to spawn non-existing (or system) spawn group {}. Blocked.", groupId);
        return false;
    }
 
    if (groupData->mapId != SPAWNGROUP_MAP_UNSET && groupData->mapId != GetId())
    {
        LOG_ERROR("maps", "Tried to spawn group {} on map {}, but group has map {}. Blocked.",
            groupId, GetId(), groupData->mapId);
        return false;
    }
 
    // Mark group as active on this map (toggle to active state)
    if (groupData->flags & SPAWNGROUP_FLAG_MANUAL_SPAWN)
        _toggledSpawnGroupIds.insert(groupId);
    else
        _toggledSpawnGroupIds.erase(groupId);
 
    auto range = sObjectMgr->GetSpawnDataForGroup(groupId);
    for (auto it = range.first; it != range.second; ++it)
    {
        SpawnData const* data = it->second;
        ObjectGuid::LowType spawnId = data->spawnId;
 
        // Check if there's already an alive instance
        if (!force)
        {
            if (data->type == SPAWN_TYPE_CREATURE)
            {
                auto bounds = _creatureBySpawnIdStore.equal_range(spawnId);
                bool alive = false;
                for (auto itr = bounds.first; itr != bounds.second; ++itr)
                    if (itr->second->IsAlive())
                        alive = true;
                if (alive)
                    continue;
            }
            else if (data->type == SPAWN_TYPE_GAMEOBJECT)
            {
                if (_gameobjectBySpawnIdStore.count(spawnId))
                    continue;
            }
        }
 
        time_t respawnTime = GetRespawnTime(data->type, spawnId);
        if (respawnTime && respawnTime > GameTime::GetGameTime().count())
        {
            if (!force && !ignoreRespawn)
                continue;
            RemoveRespawnTime(data->type, spawnId);
        }
 
        // Don't spawn if grid isn't loaded (will be handled in grid loader)
        if (!IsGridLoaded(data->posX, data->posY))
            continue;
 
        switch (data->type)
        {
            case SPAWN_TYPE_CREATURE:
            {
                Creature* creature = new Creature();
                if (!creature->LoadCreatureFromDB(spawnId, this, true, true))
                    delete creature;
                break;
            }
            case SPAWN_TYPE_GAMEOBJECT:
            {
                GameObject* gameobject = new GameObject();
                if (!gameobject->LoadGameObjectFromDB(spawnId, this, true))
                    delete gameobject;
                break;
            }
            default:
                break;
        }
    }
 
    return true;
}

References _creatureBySpawnIdStore, _gameobjectBySpawnIdStore, _toggledSpawnGroupIds, SpawnGroupTemplateData::flags, GameTime::GetGameTime(), GetId(), GetRespawnTime(), IsGridLoaded(), Creature::LoadCreatureFromDB(), GameObject::LoadGameObjectFromDB(), LOG_ERROR, SpawnGroupTemplateData::mapId, SpawnData::posX, SpawnData::posY, RemoveRespawnTime(), sObjectMgr, SPAWN_TYPE_CREATURE, SPAWN_TYPE_GAMEOBJECT, SPAWNGROUP_FLAG_MANUAL_SPAWN, SPAWNGROUP_FLAG_SYSTEM, SPAWNGROUP_MAP_UNSET, SpawnData::spawnId, and SpawnData::type.

Referenced by gobject_commandscript::HandleGameObjectSpawnGroupCommand(), npc_commandscript::HandleNpcSpawnGroupCommand(), and SmartScript::ProcessAction().

◆ 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);
            break;
        case UNIT_MASK_GUARDIAN:
            summon = new Guardian(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty);
            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);
            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::VisitObjects(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::VisitObjects().

Referenced by instance_culling_of_stratholme::instance_culling_of_stratholme_InstanceMapScript::ChromieWhisper(), instance_trial_of_the_champion::instance_trial_of_the_champion_InstanceMapScript::DoSummonGrandChampion(), Spell::EffectSummonType(), instance_forge_of_souls::instance_forge_of_souls_InstanceScript::HandleOutro(), spell_temple_of_atal_hakkar_awaken_the_soulflayer::HandleSendEvent(), spell_halion_damage_aoe_summon::HandleSummon(), spell_putricide_mutated_transformation::HandleSummon(), spell_wintergrasp_create_vehicle::HandleSummon(), boss_varos::boss_varosAI::JustDied(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnCreatureCreate(), instance_forge_of_souls::instance_forge_of_souls_InstanceScript::OnPlayerEnter(), instance_ulduar::instance_ulduar_InstanceMapScript::OnPlayerEnter(), at_tyrannus_event_starter::OnTrigger(), instance_karazhan::instance_karazhan_InstanceMapScript::OnUnitDeath(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnUnitDeath(), spell_halion_twilight_phasing::Phase(), instance_magisters_terrace::instance_magisters_terrace_InstanceMapScript::ProcessEvent(), instance_sethekk_halls::instance_sethekk_halls_InstanceMapScript::ProcessEvent(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::ProcessEvent(), instance_stratholme::instance_stratholme_InstanceMapScript::ProcessSlaughterEvent(), instance_blackrock_depths::ReplaceMoiraIfSaved(), boss_ossirian::Reset(), ScheduleCreatureRespawn(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::ScheduleNextPortal(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetBossState(), instance_ulduar::instance_ulduar_InstanceMapScript::SetBossState(), instance_blackrock_depths::SetData(), instance_scholomance::instance_scholomance_InstanceMapScript::SetData(), instance_culling_of_stratholme::instance_culling_of_stratholme_InstanceMapScript::SetData(), instance_trial_of_the_crusader::instance_trial_of_the_crusader_InstanceMapScript::SetData(), instance_pit_of_saron::instance_pit_of_saron_InstanceScript::SetData(), instance_ulduar::instance_ulduar_InstanceMapScript::SpawnLeviathanEncounterVehicles(), instance_zulfarrak::instance_zulfarrak_InstanceMapScript::SpawnPyramidWave(), SummonCreatureGroup(), instance_violet_hold::instance_violet_hold_InstanceMapScript::SummonDefenseSystem(), Spell::SummonGuardian(), instance_zulaman::instance_zulaman_InstanceMapScript::SummonHostage(), instance_molten_core::SummonMajordomoExecutus(), WorldState::SummonMouth(), WorldState::SummonPallid(), instance_blackrock_spire::SummonSolakarWave(), instance_blackwing_lair::Update(), instance_stratholme::instance_stratholme_InstanceMapScript::Update(), instance_old_hillsbrad::instance_old_hillsbrad_InstanceMapScript::Update(), instance_trial_of_the_champion::instance_trial_of_the_champion_InstanceMapScript::Update(), instance_trial_of_the_crusader::instance_trial_of_the_crusader_InstanceMapScript::Update(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::Update(), boss_the_lich_king::boss_the_lich_kingAI::UpdateAI(), npc_brann_bronzebeard_algalon::UpdateAI(), and instance_culling_of_stratholme::instance_culling_of_stratholme_InstanceMapScript::UpdateEventState().

◆ 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 boss_four_horsemen::boss_four_horsemenAI::JustDied(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::OnGameObjectCreate(), SummonGameObject(), SummonGameObjectGroup(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::Update(), and npc_belnistrasz::npc_belnistraszAI::UpdateAI().

◆ 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().

◆ SummonGameObjectGroup()

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

{
    std::vector<GameObjectSummonData> const* data = sObjectMgr->GetGameObjectSummonGroup(GetId(), SUMMONER_TYPE_MAP, group);
    if (!data)
        return;
 
    for (std::vector<GameObjectSummonData>::const_iterator itr = data->begin(); itr != data->end(); ++itr)
        if (GameObject* go = SummonGameObject(itr->entry, itr->pos.GetPositionX(), itr->pos.GetPositionY(), itr->pos.GetPositionZ(), itr->pos.GetOrientation(), itr->rot.x, itr->rot.y, itr->rot.z, itr->rot.w, itr->respawnTime))
            if (list)
                list->push_back(go);
}

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

◆ ToBattlegroundMap() [1/2]

BattlegroundMap * Map::ToBattlegroundMap ( )

inline

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

BattlegroundMap

Definition Map.h:742

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

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

References IsBattlegroundOrArena().

◆ ToInstanceMap() [1/2]

InstanceMap * Map::ToInstanceMap ( )

inline

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

Map::IsDungeon

bool IsDungeon() const

Definition Map.h:297

References IsDungeon().

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), boss_flame_leviathan::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(), boss_sartharion_dragonAI::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(), AchievementMgr::UpdateAchievementCriteria(), and instance_halls_of_reflection::UpdateOutro().

◆ ToInstanceMap() [2/2]

InstanceMap const * Map::ToInstanceMap ( ) const

inline

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

References IsDungeon().

◆ ToMapInstanced() [1/2]

MapInstanced * Map::ToMapInstanced ( )

inline

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

MapInstanced

Definition MapInstanced.h:26

Map::Instanceable

bool Instanceable() const

Definition Map.h:296

References Instanceable().

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

◆ ToMapInstanced() [2/2]

MapInstanced const * Map::ToMapInstanced ( ) const

inline

379{ 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;
        if (grid)
            UnloadGrid(*grid);
    }
 
    // 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();)
    {
        Transport* transport = *itr;
        ++itr;
 
        RemoveFromMap<Transport>(transport, true);
    }
 
    _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(), 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< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::GetX(), MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_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 any due respawns (non-compatibility mode spawns)

Process necessary scripts

Reimplemented in InstanceMap, and MapInstanced.

{
    if (t_diff)
        _mapCollisionData.GetDynamicTree().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);
        }
    }
 
    Events.Update(t_diff);
 
    if (!t_diff)
    {
        HandleDelayedVisibility();
        return;
    }
 
    if (!sWorld->getBoolConfig(CONFIG_RESPAWN_FORCE_COMPATIBILITY_MODE))
    {
        if (_respawnCheckTimer <= t_diff)
        {
            ProcessRespawns();
            _respawnCheckTimer = 5000; // Check every 5 seconds
        }
        else
            _respawnCheckTimer -= t_diff;
    }
 
    _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);
            }
        }
    }
 
    UpdateNonPlayerObjects(t_diff);
 
    SendObjectUpdates();
 
    if (!m_scriptSchedule.empty())
    {
        i_scriptLock = true;
        ScriptsProcess();
        i_scriptLock = false;
    }
 
    MoveAllCreaturesInMoveList();
    MoveAllGameObjectsInMoveList();
    MoveAllDynamicObjectsInMoveList();
 
    HandleDelayedVisibility();
 
    UpdateWeather(t_diff);
    UpdateExpiredCorpses(t_diff);
 
    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 _mapCollisionData, _respawnCheckTimer, _updatableObjectListRecheckTimer, MapRefMgr::begin(), CONFIG_RESPAWN_FORCE_COMPATIBILITY_MODE, MapRefMgr::end(), MapCollisionData::GetDynamicTree(), GetId(), GetInstanceId(), GetObjectsStore(), Player::GetSession(), Reference< TO, FROM >::GetSource(), Player::GetViewpoint(), HandleDelayedVisibility(), i_scriptLock, Object::IsInWorld(), m_mapRefIter, m_mapRefMgr, m_scriptSchedule, MarkNearbyCellsOf(), METRIC_TAG, METRIC_VALUE, MoveAllCreaturesInMoveList(), MoveAllDynamicObjectsInMoveList(), MoveAllGameObjectsInMoveList(), IntervalTimer::Passed(), ProcessRespawns(), resetMarkedCells(), ScriptsProcess(), SendObjectUpdates(), sScriptMgr, sWorld, Object::ToCreature(), Object::ToDynObject(), IntervalTimer::Update(), DynamicMapTree::update(), WorldSession::Update(), Player::Update(), UpdateExpiredCorpses(), UpdateNonPlayerObjects(), and UpdateWeather().

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::SummonedCreatureDies(), and npc_grimstone::WaypointReached().

◆ UpdateExpiredCorpses()

void Map::UpdateExpiredCorpses ( uint32 const diff )

{
    _corpseUpdateTimer.Update(diff);
    if (!_corpseUpdateTimer.Passed())
        return;
 
    RemoveOldCorpses();
 
    _corpseUpdateTimer.Reset();
}

References _corpseUpdateTimer, IntervalTimer::Passed(), RemoveOldCorpses(), IntervalTimer::Reset(), and IntervalTimer::Update().

Referenced by Update().

◆ 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)
            --oldZoneCount;
    }
 
    if (newZone != MAP_INVALID_ZONE)
        ++_zonePlayerCountMap[newZone];
}

References _zonePlayerCountMap, and MAP_INVALID_ZONE.

Referenced by RemovePlayerFromMap(), and Player::UpdateZone().

◆ UpdateWeather()

void Map::UpdateWeather ( uint32 const diff )

{
    _weatherUpdateTimer.Update(diff);
    if (!_weatherUpdateTimer.Passed())
        return;
 
    for (auto&& zoneInfo : _zoneDynamicInfo)
        if (zoneInfo.second.DefaultWeather && !zoneInfo.second.DefaultWeather->Update(_weatherUpdateTimer.GetInterval()))
            zoneInfo.second.DefaultWeather.reset();
 
    _weatherUpdateTimer.Reset();
}

References _weatherUpdateTimer, _zoneDynamicInfo, IntervalTimer::GetInterval(), IntervalTimer::Passed(), IntervalTimer::Reset(), and IntervalTimer::Update().

Referenced by Update().

◆ 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< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::VisitCell().

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

Friends And Related Symbol Documentation

◆ GridObjectLoader

CreatureGroupHolderType Map::CreatureGroupHolder

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

◆ CustomData

DataMap Map::CustomData

◆ Events

EventProcessor Map::Events

◆ i_InstanceId

uint32 Map::i_InstanceId

protected

Referenced by GetInstanceId().

◆ i_mapEntry

MapEntry const* Map::i_mapEntry

protected

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

float Map::m_VisibleDistance

protected

Referenced by GetVisibilityRange(), InitVisibilityDistance(), InstanceMap::InitVisibilityDistance(), BattlegroundMap::InitVisibilityDistance(), and SetVisibilityRange().

◆ marked_cells

std::bitset<TOTAL_NUMBER_OF_CELLS_PER_MAP * TOTAL_NUMBER_OF_CELLS_PER_MAP> Map::marked_cells

private

Referenced by isCellMarked(), markCell(), and resetMarkedCells().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ 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()

◆ AddToGrid() [1/5]

◆ AddToGrid() [2/5]

◆ AddToGrid() [3/5]

◆ AddToGrid() [4/5]

◆ AddToGrid() [5/5]

◆ AddToMap() [1/2]

◆ AddToMap() [2/2]

◆ AddUpdateObject()

◆ AddWorldObjectToFarVisibleMap()

◆ AddWorldObjectToZoneWideVisibleMap()

◆ 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()

◆ EnsureGridCreated()

◆ EnsureGridLoaded()

◆ GameObjectRelocation()

◆ GenerateLowGuid()

◆ GetAllTransports()

◆ GetAreaId()