#include "Map.h"

Inheritance diagram for Map:

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

typedef MapRefMgr	PlayerList

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

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

Public Types inherited from GridRefMgr< NGridType >
typedef LinkedListHead::Iterator< GridReference< NGridType > >	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	VisitNearbyCellsOf (WorldObject *obj, TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &gridVisitor, TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &worldVisitor, TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &largeGridVisitor, TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &largeWorldVisitor)

void	VisitNearbyCellsOfPlayer (Player *player, TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &gridVisitor, TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &worldVisitor, TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &largeGridVisitor, TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &largeWorldVisitor)

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

float	GetVisibilityRange () const

void	SetVisibilityRange (float range)

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	IsRemovalGrid (float x, float y) const

bool	IsGridLoaded (float x, float y) const

void	LoadGrid (float x, float y)

void	LoadAllCells ()

bool	UnloadGrid (NGridType &ngrid)

virtual void	UnloadAll ()

uint32	GetId () const

Map const *	GetParent () const

std::shared_mutex &	GetMMapLock () const

void	HandleDelayedVisibility ()

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

float	GetGridHeight (float x, float y) const

float	GetMinHeight (float x, float y) const

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

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

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

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

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

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

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

float	GetWaterLevel (float x, float y) const

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

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

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

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

void	MoveAllCreaturesInMoveList ()

void	MoveAllGameObjectsInMoveList ()

void	MoveAllDynamicObjectsInMoveList ()

void	RemoveAllObjectsInRemoveList ()

virtual void	RemoveAllPlayers ()

uint32	GetInstanceId () const

uint8	GetSpawnMode () const

virtual EnterState	CannotEnter (Player *, bool)

const char *	GetMapName () const

Difficulty	GetDifficulty () const

bool	IsRegularDifficulty () const

MapDifficulty const *	GetMapDifficulty () const

bool	Instanceable () const

bool	IsDungeon () const

bool	IsNonRaidDungeon () const

bool	IsRaid () const

bool	IsRaidOrHeroicDungeon () const

bool	IsHeroic () const

bool	Is25ManRaid () const

bool	IsBattleground () const

bool	IsBattleArena () const

bool	IsBattlegroundOrArena () const

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

void	AddObjectToRemoveList (WorldObject *obj)

void	AddObjectToSwitchList (WorldObject *obj, bool on)

virtual void	DelayedUpdate (const uint32 diff)

void	resetMarkedCells ()

bool	isCellMarked (uint32 pCellId)

void	markCell (uint32 pCellId)

void	resetMarkedCellsLarge ()

bool	isCellMarkedLarge (uint32 pCellId)

void	markCellLarge (uint32 pCellId)

bool	HavePlayers () const

uint32	GetPlayersCountExceptGMs () const

void	AddWorldObject (WorldObject *obj)

void	RemoveWorldObject (WorldObject *obj)

void	SendToPlayers (WorldPacket const *data) const

PlayerList const &	GetPlayers () const

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

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

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

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

template<class T >
void	SwitchGridContainers (T *obj, bool on)

void	UpdateIteratorBack (Player *player)

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

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

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

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

Corpse *	GetCorpse (ObjectGuid const guid)

Creature *	GetCreature (ObjectGuid const guid)

GameObject *	GetGameObject (ObjectGuid const guid)

Transport *	GetTransport (ObjectGuid const guid)

DynamicObject *	GetDynamicObject (ObjectGuid const guid)

Pet *	GetPet (ObjectGuid const guid)

MapStoredObjectTypesContainer &	GetObjectsStore ()

CreatureBySpawnIdContainer &	GetCreatureBySpawnIdStore ()

GameObjectBySpawnIdContainer &	GetGameObjectBySpawnIdStore ()

std::unordered_set< Corpse * > const *	GetCorpsesInCell (uint32 cellId) const

Corpse *	GetCorpseByPlayer (ObjectGuid const &ownerGuid) const

MapInstanced *	ToMapInstanced ()

MapInstanced const *	ToMapInstanced () const

InstanceMap *	ToInstanceMap ()

InstanceMap const *	ToInstanceMap () const

BattlegroundMap *	ToBattlegroundMap ()

BattlegroundMap const *	ToBattlegroundMap () const

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

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

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

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

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

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

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

void	Balance ()

void	RemoveGameObjectModel (const GameObjectModel &model)

void	InsertGameObjectModel (const GameObjectModel &model)

bool	ContainsGameObjectModel (const GameObjectModel &model) const

DynamicMapTree const &	GetDynamicMapTree () const

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

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

time_t	GetLinkedRespawnTime (ObjectGuid guid) const

time_t	GetCreatureRespawnTime (ObjectGuid::LowType dbGuid) const

time_t	GetGORespawnTime (ObjectGuid::LowType dbGuid) const

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

void	RemoveCreatureRespawnTime (ObjectGuid::LowType dbGuid)

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

void	RemoveGORespawnTime (ObjectGuid::LowType dbGuid)

void	LoadRespawnTimes ()

void	DeleteRespawnTimes ()

time_t	GetInstanceResetPeriod () const

void	ScheduleCreatureRespawn (ObjectGuid, Milliseconds)

void	LoadCorpseData ()

void	DeleteCorpseData ()

void	AddCorpse (Corpse *corpse)

void	RemoveCorpse (Corpse *corpse)

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

void	RemoveOldCorpses ()

void	SendInitTransports (Player *player)

void	SendRemoveTransports (Player *player)

void	SendZoneDynamicInfo (Player *player)

void	SendInitSelf (Player *player)

void	PlayDirectSoundToMap (uint32 soundId, uint32 zoneId=0)

void	SetZoneMusic (uint32 zoneId, uint32 musicId)

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

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

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

void	LogEncounterFinished (EncounterCreditType type, uint32 creditEntry)

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

GridMap *	GetGrid (float x, float y)

void	EnsureGridCreated (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	GetActiveNonPlayersCount () const

virtual std::string	GetDebugInfo () const

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

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

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

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

template<>
void	SwitchGridContainers (Creature *obj, bool on)

template<>
void	SwitchGridContainers (GameObject *obj, bool on)

template<>
void	DeleteFromWorld (Player *player)

template<>
void	InitializeObject (Creature *)

template<>
void	InitializeObject (GameObject *)

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

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

template<>
void	AddToActive (Creature *c)

template<>
void	AddToActive (DynamicObject *d)

template<>
void	AddToActive (GameObject *d)

template<>
void	RemoveFromActive (Creature *c)

template<>
void	RemoveFromActive (DynamicObject *obj)

template<>
void	RemoveFromActive (GameObject *obj)

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

GridReference< NGridType > *	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 bool	ExistMap (uint32 mapid, int gx, int gy)

static bool	ExistVMap (uint32 mapid, int gx, int gy)

static void	DeleteRespawnTimesInDB (uint16 mapId, uint32 instanceId)

Public Attributes
std::unordered_set< Unit * >	i_objectsForDelayedVisibility

CreatureGroupHolderType	CreatureGroupHolder

TaskScheduler	_creatureRespawnScheduler

DataMap	CustomData

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

Protected Attributes
std::mutex	Lock

std::mutex	GridLock

std::shared_mutex	MMapLock

MapEntry const *	i_mapEntry

uint8	i_spawnMode

uint32	i_InstanceId

uint32	m_unloadTimer

float	m_VisibleDistance

DynamicMapTree	_dynamicTree

time_t	_instanceResetPeriod

MapRefMgr	m_mapRefMgr

MapRefMgr::iterator	m_mapRefIter

ActiveNonPlayers	m_activeNonPlayers

ActiveNonPlayers::iterator	m_activeNonPlayersIter

TransportsContainer	_transports

TransportsContainer::iterator	_transportsUpdateIter

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

Private Member Functions
void	LoadMapAndVMap (int gx, int gy)

void	LoadVMap (int gx, int gy)

void	LoadMap (int gx, int gy, bool reload=false)

void	LoadMMap (int gx, int gy)

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	IsGridLoaded (const GridCoord &) const

void	EnsureGridCreated_i (const GridCoord &)

void	buildNGridLinkage (NGridType *pNGridType)

NGridType *	getNGrid (uint32 x, uint32 y) const

bool	EnsureGridLoaded (Cell const &)

bool	isGridObjectDataLoaded (uint32 x, uint32 y) const

void	setGridObjectDataLoaded (bool pLoaded, uint32 x, uint32 y)

void	setNGrid (NGridType *grid, uint32 x, uint32 y)

void	ScriptsProcess ()
	Process queued scripts.

void	UpdateActiveCells (const float &x, const float &y, const uint32 t_diff)

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	AddToGrid (T *object, Cell const &cell)

template<class T >
void	DeleteFromWorld (T *)

void	AddToActiveHelper (WorldObject *obj)

void	RemoveFromActiveHelper (WorldObject *obj)

template<HighGuid high>
ObjectGuidGeneratorBase &	GetGuidSequenceGenerator ()

Private Attributes
std::vector< Creature * >	_creaturesToMove

std::vector< GameObject * >	_gameObjectsToMove

std::vector< DynamicObject * >	_dynamicObjectsToMove

Map *	m_parentMap

NGridType *	i_grids [MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS]

GridMap *	GridMaps [MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS]

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP >	marked_cells

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP >	marked_cells_large

bool	i_scriptLock

std::unordered_set< WorldObject * >	i_objectsToRemove

std::map< WorldObject *, bool >	i_objectsToSwitch

std::unordered_set< WorldObject * >	i_worldObjects

ScriptScheduleMap	m_scriptSchedule

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

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

ZoneDynamicInfoMap	_zoneDynamicInfo

uint32	_defaultLight

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

MapStoredObjectTypesContainer	_objectsStore

CreatureBySpawnIdContainer	_creatureBySpawnIdStore

GameObjectBySpawnIdContainer	_gameobjectBySpawnIdStore

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

std::unordered_map< ObjectGuid, Corpse * >	_corpsesByPlayer

std::unordered_set< Corpse * >	_corpseBones

std::unordered_set< Object * >	_updateObjects

Friends
class	MapReference

Detailed Description

Member Typedef Documentation

◆ ActiveNonPlayers

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

protected

◆ CreatureBySpawnIdContainer

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

◆ GameObjectBySpawnIdContainer

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

◆ PlayerList

typedef MapRefMgr Map::PlayerList

◆ ScriptScheduleMap

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

private

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

                                                                    :
    i_mapEntry(sMapStore.LookupEntry(id)), i_spawnMode(SpawnMode), i_InstanceId(InstanceId),
    m_unloadTimer(0), m_VisibleDistance(DEFAULT_VISIBILITY_DISTANCE),
    _instanceResetPeriod(0), m_activeNonPlayersIter(m_activeNonPlayers.end()),
    _transportsUpdateIter(_transports.end()), i_scriptLock(false), _defaultLight(GetDefaultMapLight(id))
{
    m_parentMap = (_parent ? _parent : this);
    for (unsigned int idx = 0; idx < MAX_NUMBER_OF_GRIDS; ++idx)
    {
        for (unsigned int j = 0; j < MAX_NUMBER_OF_GRIDS; ++j)
        {
            //z code
            GridMaps[idx][j] = nullptr;
            setNGrid(nullptr, idx, j);
        }
    }
 
    //lets initialize visibility distance for map
    Map::InitVisibilityDistance();
 
    sScriptMgr->OnCreateMap(this);
}

References GridMaps, InitVisibilityDistance(), m_parentMap, MAX_NUMBER_OF_GRIDS, setNGrid(), and sScriptMgr.

◆ ~Map()

Map::~Map ( )

override

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

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

Member Function Documentation

◆ _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->isType(TYPEMASK_UNIT))
        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::isType(), LOG_ERROR, ObjectGuid::ToString(), Object::ToUnit(), and TYPEMASK_UNIT.

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

◆ _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->isType(TYPEMASK_UNIT))
        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(), LOG_ERROR, ScriptInfo::ResetDelay, SCRIPT_COMMAND_CLOSE_DOOR, SCRIPT_COMMAND_OPEN_DOOR, Object::ToGameObject(), ScriptInfo::ToggleDoor, ObjectGuid::ToString(), TYPEMASK_GAMEOBJECT, TYPEMASK_UNIT, and GameObject::UseDoorOrButton().

Referenced by ScriptsProcess().

◆ AddCorpse()

void Map::AddCorpse ( Corpse * corpse )

{
    corpse->SetMap(this);
 
    _corpsesByCell[corpse->GetCellCoord().GetId()].insert(corpse);
    if (corpse->GetType() != CORPSE_BONES)
        _corpsesByPlayer[corpse->GetOwnerGUID()] = corpse;
    else
        _corpseBones.insert(corpse);
}

References _corpseBones, _corpsesByCell, _corpsesByPlayer, CORPSE_BONES, Corpse::GetCellCoord(), CoordPair< LIMIT >::GetId(), Corpse::GetOwnerGUID(), 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().

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

◆ AddObjectToSwitchList()

void Map::AddObjectToSwitchList	(	WorldObject *	obj,
		bool	on
	)

{
    ASSERT(obj->GetMapId() == GetId() && obj->GetInstanceId() == GetInstanceId());
    // i_objectsToSwitch is iterated only in Map::RemoveAllObjectsInRemoveList() and it uses
    // the contained objects only if GetTypeId() == TYPEID_UNIT , so we can return in all other cases
    if (obj->GetTypeId() != TYPEID_UNIT && obj->GetTypeId() != TYPEID_GAMEOBJECT)
        return;
 
    std::map<WorldObject*, bool>::iterator itr = i_objectsToSwitch.find(obj);
    if (itr == i_objectsToSwitch.end())
        i_objectsToSwitch.insert(itr, std::make_pair(obj, on));
    else if (itr->second != on)
        i_objectsToSwitch.erase(itr);
    else
        ABORT();
}

References ABORT, ASSERT, GetId(), WorldObject::GetInstanceId(), GetInstanceId(), WorldLocation::GetMapId(), Object::GetTypeId(), i_objectsToSwitch, TYPEID_GAMEOBJECT, and TYPEID_UNIT.

Referenced by WorldObject::SetWorldObject().

◆ 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);
    EnsureGridLoaded(cell);
    AddToGrid(player, cell);
 
    // Check if we are adding to correct map
    ASSERT (player->GetMap() == this);
    player->SetMap(this);
    player->AddToWorld();
 
    SendInitTransports(player);
    SendInitSelf(player);
    SendZoneDynamicInfo(player);
 
    player->m_clientGUIDs.clear();
    player->UpdateObjectVisibility(false);
 
    if (player->IsAlive())
        ConvertCorpseToBones(player->GetGUID());
 
    sScriptMgr->OnPlayerEnterMap(this, player);
    return true;
}

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

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

◆ AddToActive() [1/4]

template<>

void Map::AddToActive ( Creature * c )

{
    AddToActiveHelper(c);
}

References AddToActiveHelper().

◆ AddToActive() [2/4]

template<>

void Map::AddToActive ( DynamicObject * d )

{
    AddToActiveHelper(d);
}

References AddToActiveHelper().

◆ AddToActive() [3/4]

template<>

void Map::AddToActive ( GameObject * d )

{
    AddToActiveHelper(d);
}

References AddToActiveHelper().

◆ AddToActive() [4/4]

template<class T >

void Map::AddToActive ( T * obj )

{
    AddToActiveHelper(obj);
}

References AddToActiveHelper().

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

◆ AddToActiveHelper()

void Map::AddToActiveHelper ( WorldObject * obj )

inlineprivate

    {
        m_activeNonPlayers.insert(obj);
    }

References m_activeNonPlayers.

Referenced by AddToActive().

◆ AddToGrid() [1/5]

template<>

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

{
    NGridType* grid = getNGrid(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->isGridObjectDataLoaded())
    {
        if (obj->IsWorldObject())
            grid->GetGridType(cell.CellX(), cell.CellY()).AddWorldObject(obj);
        else
            grid->GetGridType(cell.CellX(), cell.CellY()).AddGridObject(obj);
    }
}

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), getNGrid(), Cell::GridX(), Cell::GridY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::isGridObjectDataLoaded(), and WorldObject::IsWorldObject().

◆ AddToGrid() [2/5]

template<>

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

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

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), getNGrid(), Cell::GridX(), Cell::GridY(), WorldObject::IsWorldObject(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [3/5]

template<>

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

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

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), Cell::CellX(), Cell::CellY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), getNGrid(), Cell::GridX(), Cell::GridY(), WorldObject::IsWorldObject(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [4/5]

template<>

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

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

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Cell::CellX(), Cell::CellY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), getNGrid(), Cell::GridX(), Cell::GridY(), and MovableMapObject::SetCurrentCell().

◆ AddToGrid() [5/5]

template<class T >

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

private

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

References Cell::CellX(), Cell::CellY(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), getNGrid(), Cell::GridX(), and Cell::GridY().

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

◆ AddToMap() [1/2]

template<>

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

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

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

◆ AddToMap() [2/2]

template<class T >

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

{
    //TODO: Needs clean up. An object should not be added to map twice.
    if (obj->IsInWorld())
    {
        ASSERT(obj->IsInGrid());
        obj->UpdateObjectVisibility(true);
        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->GetTypeId() == TYPEID_GAMEOBJECT && obj->ToGameObject()->IsTransport())) // dont add transport to transport ;d
            if (Transport* transport = GetTransportForPos(obj->GetPhaseMask(), obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), obj))
                transport->AddPassenger(obj, true);
 
    InitializeObject(obj);
 
    if (obj->isActiveObject())
        AddToActive(obj);
 
    //something, such as vehicle, needs to be update immediately
    //also, trigger needs to cast spell, if not update, cannot see visual
    obj->UpdateObjectVisibility(true);
 
    // Xinef: little hack for vehicles, accessories have to be added after visibility update so they wont fall off the vehicle, moved from Creature::AIM_Initialize
    // Initialize vehicle, this is done only for summoned npcs, DB creatures are handled by grid loaders
    if (obj->GetTypeId() == TYPEID_UNIT)
        if (Vehicle* vehicle = obj->ToCreature()->GetVehicleKit())
            vehicle->Reset();
    return true;
}

References AddToActive(), AddToGrid(), ASSERT, Acore::ComputeCellCoord(), EnsureGridCreated(), EnsureGridLoaded(), GetTransportForPos(), Cell::GridX(), Cell::GridY(), InitializeObject(), CoordPair< LIMIT >::IsCoordValid(), LOG_ERROR, TYPEID_GAMEOBJECT, TYPEID_UNIT, 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(), 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(), PoolGroup< T >::Spawn1Object(), Battlefield::SpawnCreature(), Battlefield::SpawnGameObject(), SummonCreature(), SummonGameObject(), WorldObject::SummonGameObject(), Player::SummonPet(), and GameObject::Update().

◆ AddUpdateObject()

void Map::AddUpdateObject ( Object * obj )

inline

    {
        _updateObjects.insert(obj);
    }

References _updateObjects.

Referenced by WorldObject::AddToObjectUpdate().

◆ AddWorldObject()

void Map::AddWorldObject ( WorldObject * obj )

inline

479{ i_worldObjects.insert(obj); }

References i_worldObjects.

Referenced by WorldObject::SetMap(), and SwitchGridContainers().

◆ AfterPlayerUnlinkFromMap()

void Map::AfterPlayerUnlinkFromMap ( )

virtual

Reimplemented in InstanceMap.

938{

939}

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

◆ Balance()

void Map::Balance ( )

inline

558{ _dynamicTree.balance(); }

DynamicMapTree::balance

void balance()

Definition: DynamicTree.cpp:132

Map::_dynamicTree

DynamicMapTree _dynamicTree

Definition: Map.h:712

References _dynamicTree, and DynamicMapTree::balance().

Referenced by EnsureGridLoaded().

◆ buildNGridLinkage()

void Map::buildNGridLinkage ( NGridType * pNGridType )

inlineprivate

683{ pNGridType->link(this); }

NGrid::link

void link(GridRefMgr< NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES > > *pTo)

Definition: NGrid.h:61

References NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::link().

Referenced by EnsureGridCreated_i().

◆ CannotEnter()

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

inlinevirtual

Reimplemented in InstanceMap, BattlegroundMap, and MapInstanced.

438{ 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(), MotionMaster::MoveBackwards(), and MotionMaster::MoveForwards().

◆ CanUnload()

bool Map::CanUnload ( uint32 diff )

inline

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

References m_unloadTimer.

◆ CheckCollisionAndGetValidCoords()

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

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

Returns: true if the destination is valid, false otherwise

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

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

Referenced by CanReachPositionAndGetValidCoords().

◆ ContainsGameObjectModel()

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

inline

561{ return _dynamicTree.contains(model);}

DynamicMapTree::contains

bool contains(const GameObjectModel &) const

Definition: DynamicTree.cpp:127

References _dynamicTree, and DynamicMapTree::contains().

◆ ConvertCorpseToBones()

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

{
    Corpse* corpse = GetCorpseByPlayer(ownerGuid);
    if (!corpse)
        return nullptr;
 
    RemoveCorpse(corpse);
 
    // remove corpse from DB
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    corpse->DeleteFromDB(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    Corpse* bones = NULL;
 
    // create the bones only if the map and the grid is loaded at the corpse's location
    // ignore bones creating option in case insignia
    if ((insignia ||
        (IsBattlegroundOrArena() ? sWorld->getBoolConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld->getBoolConfig(CONFIG_DEATH_BONES_WORLD))) &&
        !IsRemovalGrid(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(), IsRemovalGrid(), OBJECT_FIELD_TYPE, Position::Relocate(), RemoveCorpse(), Corpse::SetCellCoord(), Object::SetGuidValue(), WorldObject::SetPhaseMask(), Object::SetUInt32Value(), sWorld, and WorldObject::UpdatePositionData().

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

◆ CreatureRelocation()

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

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

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

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

◆ DelayedUpdate()

void Map::DelayedUpdate ( const uint32 diff )

virtual

Reimplemented in MapInstanced.

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

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

Referenced by MapInstanced::DelayedUpdate().

◆ DeleteCorpseData()

void Map::DeleteCorpseData ( )

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

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

Referenced by InstanceMap::UnloadAll().

◆ DeleteFromWorld() [1/2]

template<>

void Map::DeleteFromWorld ( Player * player )

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

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

◆ DeleteFromWorld() [2/2]

template<class T >

void Map::DeleteFromWorld ( T * obj )

private

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

Referenced by RemoveFromMap(), and RemovePlayerFromMap().

◆ DeleteRespawnTimes()

void Map::DeleteRespawnTimes ( )

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

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

Referenced by InstanceMap::UnloadAll().

◆ DeleteRespawnTimesInDB()

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

static

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

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

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

◆ DoForAllPlayers()

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

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

References GetPlayers().

Referenced by npc_thrall_warchief::npc_thrall_warchiefAI::DoAction(), InstanceScript::DoCastSpellOnPlayers(), InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), InstanceScript::DoSendNotifyToInstance(), InstanceScript::DoStartTimedAchievement(), InstanceScript::DoStopTimedAchievement(), InstanceScript::DoUpdateAchievementCriteria(), boss_azuregos::boss_azuregosAI::JustDied(), boss_rajaxx::JustDied(), boss_ahune::JustDied(), boss_azuregos::boss_azuregosAI::Reset(), boss_yoggsaron_sara::boss_yoggsaron_saraAI::Reset(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::SetBossState(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetData(), and boss_nefarian::UpdateAI().

◆ 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 ( const GridCoord & p )

{
    if (getNGrid(p.x_coord, p.y_coord)) // pussywizard
        return;
    std::lock_guard<std::mutex> guard(GridLock);
    EnsureGridCreated_i(p);
}

References EnsureGridCreated_i(), getNGrid(), GridLock, CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by AddToMap(), EnsureGridLoaded(), GetGrid(), and LoadMap().

◆ EnsureGridCreated_i()

void Map::EnsureGridCreated_i ( const GridCoord & p )

private

{
    if (!getNGrid(p.x_coord, p.y_coord))
    {
        // pussywizard: moved setNGrid to the end of the function
        NGridType* ngt = new NGridType(p.x_coord * MAX_NUMBER_OF_GRIDS + p.y_coord, p.x_coord, p.y_coord);
 
        // build a linkage between this map and NGridType
        buildNGridLinkage(ngt); // pussywizard: getNGrid(x, y) changed to: ngt
 
        //z coord
        int gx = (MAX_NUMBER_OF_GRIDS - 1) - p.x_coord;
        int gy = (MAX_NUMBER_OF_GRIDS - 1) - p.y_coord;
 
        if (!GridMaps[gx][gy])
        {
            LoadMapAndVMap(gx, gy);
        }
 
        // pussywizard: moved here
        setNGrid(ngt, p.x_coord, p.y_coord);
    }
}

References buildNGridLinkage(), getNGrid(), GridMaps, LoadMapAndVMap(), MAX_NUMBER_OF_GRIDS, setNGrid(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by EnsureGridCreated().

◆ EnsureGridLoaded()

bool Map::EnsureGridLoaded ( Cell const & cell )

private

{
    EnsureGridCreated(GridCoord(cell.GridX(), cell.GridY()));
    NGridType* grid = getNGrid(cell.GridX(), cell.GridY());
 
    ASSERT(grid);
    if (!isGridObjectDataLoaded(cell.GridX(), cell.GridY()))
    {
        //if (!isGridObjectDataLoaded(cell.GridX(), cell.GridY()))
        //{
        LOG_DEBUG("maps", "Loading grid[{}, {}] for map {} instance {}", cell.GridX(), cell.GridY(), GetId(), i_InstanceId);
 
        setGridObjectDataLoaded(true, cell.GridX(), cell.GridY());
 
        ObjectGridLoader loader(*grid, this, cell);
        loader.LoadN();
 
        Balance();
        return true;
        //}
    }
 
    return false;
}

References ASSERT, Balance(), EnsureGridCreated(), GetId(), getNGrid(), Cell::GridX(), Cell::GridY(), i_InstanceId, isGridObjectDataLoaded(), ObjectGridLoader::LoadN(), LOG_DEBUG, and setGridObjectDataLoaded().

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

◆ ExistMap()

bool Map::ExistMap	(	uint32	mapid,
		int	gx,
		int	gy
	)

static

{
    int len = sWorld->GetDataPath().length() + strlen("maps/%03u%02u%02u.map") + 1;
    char* tmp = new char[len];
    snprintf(tmp, len, (char*)(sWorld->GetDataPath() + "maps/%03u%02u%02u.map").c_str(), mapid, gx, gy);
 
    bool ret = false;
    FILE* pf = fopen(tmp, "rb");
 
    if (!pf)
        LOG_ERROR("maps", "Map file '{}': does not exist!", tmp);
    else
    {
        map_fileheader header;
        if (fread(&header, sizeof(header), 1, pf) == 1)
        {
            if (header.mapMagic != MapMagic.asUInt || header.versionMagic != MapVersionMagic)
            {
                LOG_ERROR("maps", "Map file '{}' is from an incompatible map version (%.*u v{}), %.*s v{} is expected. Please pull your source, recompile tools and recreate maps using the updated mapextractor, then replace your old map files with new files.",
                    tmp, 4, header.mapMagic, header.versionMagic, 4, MapMagic.asChar, MapVersionMagic);
            }
 
            else
                ret = true;
        }
        fclose(pf);
    }
    delete [] tmp;
    return ret;
}

References u_map_magic::asChar, u_map_magic::asUInt, LOG_ERROR, MapMagic, map_fileheader::mapMagic, MapVersionMagic, sWorld, and map_fileheader::versionMagic.

Referenced by MapMgr::ExistMapAndVMap(), and misc_commandscript::HandleGPSCommand().

◆ ExistVMap()

bool Map::ExistVMap	(	uint32	mapid,
		int	gx,
		int	gy
	)

static

{
    if (VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr())
    {
        if (vmgr->isMapLoadingEnabled())
        {
            VMAP::LoadResult result = vmgr->existsMap((sWorld->GetDataPath() + "vmaps").c_str(), mapid, gx, gy);
            std::string name = vmgr->getDirFileName(mapid, gx, gy);
            switch (result)
            {
                case VMAP::LoadResult::Success:
                    break;
                case VMAP::LoadResult::FileNotFound:
                    LOG_ERROR("maps", "VMap file '{}' does not exist", (sWorld->GetDataPath() + "vmaps/" + name));
                    LOG_ERROR("maps", "Please place VMAP files (*.vmtree and *.vmtile) in the vmap directory ({}), or correct the DataDir setting in your worldserver.conf file.", (sWorld->GetDataPath() + "vmaps/"));
                    return false;
                case VMAP::LoadResult::VersionMismatch:
                    LOG_ERROR("maps", "VMap file '{}' couldn't be loaded", (sWorld->GetDataPath() + "vmaps/" + name));
                    LOG_ERROR("maps", "This is because the version of the VMap file and the version of this module are different, please re-extract the maps with the tools compiled with this module.");
                    return false;
            }
        }
    }
 
    return true;
}

References VMAP::VMapFactory::createOrGetVMapMgr(), VMAP::FileNotFound, LOG_ERROR, VMAP::Success, sWorld, and VMAP::VersionMismatch.

Referenced by MapMgr::ExistMapAndVMap(), and misc_commandscript::HandleGPSCommand().

◆ GameObjectRelocation()

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

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

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

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

◆ GenerateLowGuid()

template<HighGuid high>

ObjectGuid::LowType Map::GenerateLowGuid ( )

inline

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

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

◆ GetActiveNonPlayersCount()

size_t Map::GetActiveNonPlayersCount ( ) const

inline

    {
        return m_activeNonPlayers.size();
    }

References m_activeNonPlayers.

Referenced by debug_commandscript::HandleDebugObjectCountMap().

◆ GetAllTransports()

TransportsContainer const & Map::GetAllTransports ( ) const

inline

632{ return _transports; }

References _transports.

Referenced by npc_preparations_for_war_vehicle::UpdateAI().

◆ GetAreaId()

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

{
    uint32 mogpFlags;
    int32 adtId, rootId, groupId;
    float vmapZ = z;
    bool hasVmapArea = GetAreaInfo(phaseMask, x, y, vmapZ, mogpFlags, adtId, rootId, groupId);
 
    uint32 gridAreaId    = 0;
    float  gridMapHeight = INVALID_HEIGHT;
    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(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(), GetGrid(), GetWMOAreaTableEntryByTripple(), GROUND_HEIGHT_TOLERANCE, i_mapEntry, INVALID_HEIGHT, and MapEntry::linked_zone.

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

◆ GetAreaInfo()

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

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

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

Referenced by GetAreaId().

◆ GetCorpse()

Corpse * Map::GetCorpse ( ObjectGuid const guid )

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

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

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

◆ GetCorpseByPlayer()

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

inline

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

References _corpsesByPlayer.

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

◆ GetCorpsesInCell()

std::unordered_set< Corpse * > const * Map::GetCorpsesInCell ( uint32 cellId ) const

inline

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

References _corpsesByCell.

Referenced by ObjectWorldLoader::Visit().

◆ 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

519{ return _creatureBySpawnIdStore; }

Map::_creatureBySpawnIdStore

CreatureBySpawnIdContainer _creatureBySpawnIdStore

Definition: Map.h:799

References _creatureBySpawnIdStore.

Referenced by Creature::AddToWorld(), OPvPCapturePoint::DelCreature(), PoolGroup< T >::Despawn1Object(), SmartScript::FindCreatureNear(), OPvPCapturePointNA::GetAliveGuardsCount(), ChatHandler::GetCreatureFromPlayerMapByDbGuid(), list_commandscript::HandleListCreatureCommand(), and Creature::LoadCreatureFromDB().

◆ GetCreatureRespawnTime()

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

inline

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

References _creatureRespawnTimes.

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

◆ GetDebugInfo()

std::string Map::GetDebugInfo ( ) const

virtual

Reimplemented in InstanceMap.

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

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

Referenced by InstanceMap::GetDebugInfo().

◆ GetDifficulty()

Difficulty Map::GetDifficulty ( ) const

inline

443{ return Difficulty(GetSpawnMode()); }

Difficulty

Definition: DBCEnums.h:274

Map::GetSpawnMode

uint8 GetSpawnMode() const

Definition: Map.h:420

References GetSpawnMode().

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), npc_ritual_channeler::npc_ritual_channelerAI::AttackStart(), InstanceMap::CannotEnter(), Player::CanRollForItemInLFG(), Spell::CheckCast(), MapInstanced::CreateInstanceForPlayer(), boss_twin_valkyrAI::DoAction(), GetDebugInfo(), GetMapDifficulty(), spell_four_horsemen_consumption::HandleDamageCalc(), 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::OnMapChanged(), spell_valkyr_touch::spell_valkyr_touchAuraScript::PrepareAuraScript(), 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

562{ return _dynamicTree; }

References _dynamicTree.

Referenced by BattlegroundRV::CheckPositionForUnit(), and MysticBuffetTargetFilter::operator()().

◆ 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

319{ return i_mapEntry; }

References i_mapEntry.

Referenced by anonymous_namespace{AllMapScript.cpp}::ForeachMaps(), InstanceMap::GetMaxPlayers(), misc_commandscript::HandleSkirmishCommand(), and LogEncounterFinished().

◆ GetFullTerrainStatusForPosition()

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

{
    GridMap* gmap = GetGrid(x, y);
 
    VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr();
    VMAP::AreaAndLiquidData vmapData;
    // VMAP::AreaAndLiquidData dynData;
    VMAP::AreaAndLiquidData* wmoData = nullptr;
    vmgr->GetAreaAndLiquidData(GetId(), x, y, z, reqLiquidType, vmapData);
    // _dynamicTree.GetAreaAndLiquidData(x, y, z, phaseMask, reqLiquidType, dynData);
 
    uint32 gridAreaId = 0;
    float gridMapHeight = INVALID_HEIGHT;
    if (gmap)
    {
        gridAreaId = gmap->getArea(x, y);
        gridMapHeight = gmap->getHeight(x, y);
    }
 
    bool useGridLiquid = true;
 
    // floor is the height we are closer to (but only if above)
    data.floorZ = VMAP_INVALID_HEIGHT;
    if (gridMapHeight > INVALID_HEIGHT && G3D::fuzzyGe(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE))
        data.floorZ = gridMapHeight;
 
    if (vmapData.floorZ > VMAP_INVALID_HEIGHT && G3D::fuzzyGe(z, vmapData.floorZ - GROUND_HEIGHT_TOLERANCE) &&
        (G3D::fuzzyLt(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE) || vmapData.floorZ > gridMapHeight))
    {
        data.floorZ = vmapData.floorZ;
        wmoData = &vmapData;
    }
 
    // NOTE: Objects will not detect a case when a wmo providing area/liquid despawns from under them
    // but this is fine as these kind of objects are not meant to be spawned and despawned a lot
    // example: Lich King platform
    /*
    if (dynData.floorZ > VMAP_INVALID_HEIGHT && G3D::fuzzyGe(z, dynData.floorZ - GROUND_HEIGHT_TOLERANCE) &&
        (G3D::fuzzyLt(z, gridMapHeight - GROUND_HEIGHT_TOLERANCE) || dynData.floorZ > gridMapHeight) &&
        (G3D::fuzzyLt(z, vmapData.floorZ - GROUND_HEIGHT_TOLERANCE) || dynData.floorZ > vmapData.floorZ))
    {
        data.floorZ = dynData.floorZ;
        wmoData = &dynData;
    }
    */
 
    if (wmoData)
    {
        if (wmoData->areaInfo)
        {
            // wmo found
            WMOAreaTableEntry const* wmoEntry = GetWMOAreaTableEntryByTripple(wmoData->areaInfo->rootId, wmoData->areaInfo->adtId, wmoData->areaInfo->groupId);
            data.outdoors = (wmoData->areaInfo->mogpFlags & 0x8) != 0;
            if (wmoEntry)
            {
                data.areaId = wmoEntry->areaId;
                if (wmoEntry->Flags & 4)
                    data.outdoors = true;
                else if (wmoEntry->Flags & 2)
                    data.outdoors = false;
            }
 
            if (!data.areaId)
                data.areaId = gridAreaId;
 
            useGridLiquid = !IsInWMOInterior(wmoData->areaInfo->mogpFlags);
        }
    }
    else
    {
        data.outdoors = true;
        data.areaId = gridAreaId;
        if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(data.areaId))
            data.outdoors = (areaEntry->flags & (AREA_FLAG_INSIDE | AREA_FLAG_OUTSIDE)) != AREA_FLAG_INSIDE;
    }
 
    if (!data.areaId)
        data.areaId = i_mapEntry->linked_zone;
 
    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(data.areaId);
 
    // liquid processing
    if (wmoData && wmoData->liquidInfo && wmoData->liquidInfo->level > wmoData->floorZ)
    {
        uint32 liquidType = wmoData->liquidInfo->type;
        if (GetId() == 530 && 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() == 530 && liquidEntry == 2)
                liquidEntry = 15;
 
            data.liquidInfo = gridLiquidData;
            data.liquidInfo.Entry = liquidEntry;
        }
    }
}

References AREA_FLAG_INSIDE, AREA_FLAG_OUTSIDE, PositionFullTerrainStatus::areaId, WMOAreaTableEntry::areaId, VMAP::AreaAndLiquidData::areaInfo, VMAP::VMapFactory::createOrGetVMapMgr(), LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, WMOAreaTableEntry::Flags, VMAP::AreaAndLiquidData::floorZ, PositionFullTerrainStatus::floorZ, GridMap::getArea(), VMAP::IVMapMgr::GetAreaAndLiquidData(), GetGrid(), GridMap::getHeight(), GetId(), GridMap::GetLiquidData(), GetWMOAreaTableEntryByTripple(), GROUND_HEIGHT_TOLERANCE, i_mapEntry, INVALID_HEIGHT, IsInWMOInterior(), LiquidData::Level, MapEntry::linked_zone, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_IN_WATER, LIQUID_MAP_NO_WATER, LIQUID_MAP_UNDER_WATER, LIQUID_MAP_WATER_WALK, VMAP::AreaAndLiquidData::liquidInfo, PositionFullTerrainStatus::liquidInfo, AreaTableEntry::LiquidTypeOverride, 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

522{ return _gameobjectBySpawnIdStore; }

Map::_gameobjectBySpawnIdStore

GameObjectBySpawnIdContainer _gameobjectBySpawnIdStore

Definition: Map.h:800

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(), PoolGroup< T >::Despawn1Object(), SmartScript::FindGameObjectNear(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), list_commandscript::HandleListObjectCommand(), Player::LoadFromDB(), and OPvPCapturePointEP_NPT::SummonGO().

◆ GetGameObjectFloor()

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

inline

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

References _dynamicTree, and DynamicMapTree::getHeight().

◆ GetGORespawnTime()

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

inline

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

References _goRespawnTimes.

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

◆ GetGrid()

GridMap * Map::GetGrid	(	float	x,
		float	y
	)

{
    // half opt method
    int gx = (int)(32 - x / SIZE_OF_GRIDS);                 //grid x
    int gy = (int)(32 - y / SIZE_OF_GRIDS);                 //grid y
 
    // ensure GridMap is loaded
    EnsureGridCreated(GridCoord(63 - gx, 63 - gy));
 
    return GridMaps[gx][gy];
}

References EnsureGridCreated(), GridMaps, and SIZE_OF_GRIDS.

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

◆ GetGridHeight()

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

{
    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
        return gmap->getHeight(x, y);
 
    return VMAP_INVALID_HEIGHT_VALUE;
}

References GetGrid(), and VMAP_INVALID_HEIGHT_VALUE.

Referenced by CheckCollisionAndGetValidCoords(), and GetHeight().

◆ GetGuidSequenceGenerator()

template<HighGuid high>

ObjectGuidGeneratorBase & Map::GetGuidSequenceGenerator ( )

inlineprivate

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

References _guidGenerators.

◆ GetHeight() [1/2]

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

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

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

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

◆ GetHeight() [2/2]

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

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

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

◆ GetId()

uint32 Map::GetId ( ) const

inline

379{ return i_mapEntry->MapID; }

MapEntry::MapID

uint32 MapID

Definition: DBCStructure.h:1324

References i_mapEntry, and MapEntry::MapID.

Referenced by Group::_cancelHomebindIfInstance(), AddObjectToRemoveList(), AddObjectToSwitchList(), InstanceMap::AddPlayerToMap(), MapUpdateRequest::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(), CreatureAI::DoZoneInCombat(), EnsureGridLoaded(), anonymous_namespace{AllMapScript.cpp}::ForeachMaps(), GetAreaInfo(), GetDebugInfo(), GetFullTerrainStatusForPosition(), GetHeight(), GetLiquidData(), GetMapDifficulty(), debug_commandscript::HandleDebugObjectCountMap(), gobject_commandscript::HandleGameObjectAddCommand(), go_commandscript::HandleGoZoneXYCommand(), WorldSession::HandleMoveWorldportAck(), npc_commandscript::HandleNpcAddCommand(), WorldSession::HandlePlayerLoginFromDB(), WorldSession::HandlePlayerLoginToCharInWorld(), WorldSession::HandleSetRaidDifficultyOpcode(), wp_commandscript::HandleWpModifyCommand(), wp_commandscript::HandleWpShowCommand(), InitVisibilityDistance(), InstanceMap::InitVisibilityDistance(), Player::inRandomLfgDungeon(), isInLineOfSight(), DisableMgr::IsPathfindingEnabled(), LoadCorpseData(), LoadMap(), LoadMMap(), ObjectGridLoader::LoadN(), LoadRespawnTimes(), LoadVMap(), LogEncounterFinished(), AchievementCriteriaData::Meets(), MotionMaster::MoveFall(), lfg::LFGPlayerScript::OnMapChanged(), InstanceMap::PermBindAllPlayers(), spell_valkyr_touch::spell_valkyr_touchAuraScript::PrepareAuraScript(), RemoveAllPlayers(), RemoveCreatureRespawnTime(), RemoveGORespawnTime(), InstanceMap::Reset(), Player::RewardReputation(), SaveCreatureRespawnTime(), SaveGORespawnTime(), InstanceMap::SendResetWarnings(), World::SetInitialWorldSettings(), WorldObject::SetMap(), Player::SetMover(), SummonCreatureGroup(), MotionTransport::TeleportTransport(), UnloadGrid(), Update(), UpdateEncounterState(), ObjectGridLoader::Visit(), and ~Map().

◆ GetInstanceId()

uint32 Map::GetInstanceId ( ) const

inline

◆ GetInstanceResetPeriod()

time_t Map::GetInstanceResetPeriod ( ) const

inline

596{ 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 ObjectGuid::GetCounter(), GetCreatureRespawnTime(), GetGORespawnTime(), ObjectGuid::GetHigh(), and sObjectMgr.

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

◆ GetLiquidData()

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

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

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

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

◆ GetMapDifficulty()

MapDifficulty const * Map::GetMapDifficulty ( ) const

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

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

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

◆ 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 InstanceMap::CannotEnter(), debug_commandscript::HandleDebugObjectCountMap(), go_commandscript::HandleGoZoneXYCommand(), LoadMMap(), LoadVMap(), LogCommandUsage(), and InstanceMap::PermBindAllPlayers().

◆ GetMinHeight()

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

{
    if (GridMap const* grid = const_cast<Map*>(this)->GetGrid(x, y))
        return grid->getMinHeight(x, y);
 
    return -500.0f;
}

References GetGrid().

Referenced by WorldSession::HandleMovementOpcodes().

◆ GetMMapLock()

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

inline

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

Map::MMapLock

std::shared_mutex MMapLock

Definition: Map.h:705

References MMapLock.

◆ getNGrid()

NGridType * Map::getNGrid	(	uint32	x,
		uint32	y
	)		const

inlineprivate

    {
        ASSERT(x < MAX_NUMBER_OF_GRIDS && y < MAX_NUMBER_OF_GRIDS);
        return i_grids[x][y];
    }

References ASSERT, i_grids, and MAX_NUMBER_OF_GRIDS.

Referenced by AddToGrid(), EnsureGridCreated(), EnsureGridCreated_i(), EnsureGridLoaded(), IsGridLoaded(), isGridObjectDataLoaded(), IsRemovalGrid(), setGridObjectDataLoaded(), SwitchGridContainers(), and Visit().

◆ GetObjectHitPos()

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

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

References _dynamicTree, and DynamicMapTree::GetObjectHitPos().

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

◆ GetObjectsStore()

MapStoredObjectTypesContainer & Map::GetObjectsStore ( )

inline

516{ return _objectsStore; }

References _objectsStore.

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

◆ GetParent()

Map const * Map::GetParent ( ) const

inline

384{ return m_parentMap; }

References m_parentMap.

◆ GetPet()

Pet * Map::GetPet ( ObjectGuid const guid )

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

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

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

◆ GetPlayers()

PlayerList const & Map::GetPlayers ( ) const

inline

485{ return m_mapRefMgr; }

Map::m_mapRefMgr

MapRefMgr m_mapRefMgr

Definition: Map.h:715

References m_mapRefMgr.

◆ GetPlayersCountExceptGMs()

uint32 Map::GetPlayersCountExceptGMs ( ) const

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

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

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

◆ GetSpawnMode()

uint8 Map::GetSpawnMode ( ) const

inline

420{ return (i_spawnMode); }

References i_spawnMode.

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

◆ 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(), and GameObject::ToTransport().

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

◆ GetTransportForPos()

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

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

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

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

◆ GetVisibilityRange()

float Map::GetVisibilityRange ( ) const

inline

351{ return m_VisibleDistance; }

References m_VisibleDistance.

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

◆ GetWaterLevel()

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

{
    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
        return gmap->getLiquidLevel(x, y);
    else
        return 0;
}

References GetGrid().

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

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

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

Referenced by WorldObject::GetMapWaterOrGroundLevel().

◆ GetZoneAndAreaId()

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

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

References GetAreaId(), and sAreaTableStore.

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

◆ GetZoneId()

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

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

References GetAreaId(), and sAreaTableStore.

Referenced by MapMgr::GetZoneId().

◆ HandleDelayedVisibility()

void Map::HandleDelayedVisibility ( )

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

References i_objectsForDelayedVisibility.

Referenced by Update().

◆ HasEnoughWater() [1/2]

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

{
    LiquidData const& liquidData = const_cast<Map*>(this)->GetLiquidData(searcher->GetPhaseMask(), x, y, z, searcher->GetCollisionHeight(), MAP_ALL_LIQUIDS);
    return (liquidData.Status & MAP_LIQUID_STATUS_SWIMMING) != 0 && HasEnoughWater(searcher, liquidData);
}

References WorldObject::GetCollisionHeight(), GetLiquidData(), WorldObject::GetPhaseMask(), HasEnoughWater(), MAP_ALL_LIQUIDS, MAP_LIQUID_STATUS_SWIMMING, and LiquidData::Status.

Referenced by CanReachPositionAndGetValidCoords(), and HasEnoughWater().

◆ HasEnoughWater() [2/2]

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

{
    float minHeightInWater = searcher->GetMinHeightInWater();
    return liquidData.Level > INVALID_HEIGHT && liquidData.Level > liquidData.DepthLevel && liquidData.Level - liquidData.DepthLevel >= minHeightInWater;
}

References LiquidData::DepthLevel, WorldObject::GetMinHeightInWater(), INVALID_HEIGHT, and LiquidData::Level.

◆ HavePlayers()

bool Map::HavePlayers ( ) const

inline

476{ return !m_mapRefMgr.IsEmpty(); }

References LinkedListHead::IsEmpty(), and m_mapRefMgr.

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

◆ InitializeObject() [1/3]

template<>

void Map::InitializeObject ( Creature * )

{
    //obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
}

◆ InitializeObject() [2/3]

template<>

void Map::InitializeObject ( GameObject * )

{
    //obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
}

◆ InitializeObject() [3/3]

template<class T >

void Map::InitializeObject ( T * obj )

private

539{

540}

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 609: // Scarlet Enclave (DK starting zone)
            m_VisibleDistance = 125.0f;
            break;
        case 25: // Scott Test (box map)
            m_VisibleDistance = 200.0f;
            break;
    }
}

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

Referenced by Map().

◆ InsertGameObjectModel()

void Map::InsertGameObjectModel ( const GameObjectModel & model )

inline

560{ _dynamicTree.insert(model); }

DynamicMapTree::insert

void insert(const GameObjectModel &)

Definition: DynamicTree.cpp:117

References _dynamicTree, and DynamicMapTree::insert().

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

◆ Instanceable()

bool Map::Instanceable ( ) const

inline

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

MapEntry::Instanceable

bool Instanceable() const

Definition: DBCStructure.h:1351

References i_mapEntry, and MapEntry::Instanceable().

Referenced by ObjectMgr::AddCreData(), ObjectMgr::AddGOData(), Vehicle::ApplyAllImmunities(), MapMgr::CreateMap(), PoolGroup< T >::Despawn1Object(), 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(), PoolGroup< T >::Spawn1Object(), and ToMapInstanced().

◆ Is25ManRaid()

bool Map::Is25ManRaid ( ) const

inline

453{ 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:287

Map::IsRaid

bool IsRaid() const

Definition: Map.h:450

References i_spawnMode, IsRaid(), and RAID_DIFFICULTY_MASK_25MAN.

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

◆ IsBattleArena()

bool Map::IsBattleArena ( ) const

inline

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

MapEntry::IsBattleArena

bool IsBattleArena() const

Definition: DBCStructure.h:1354

References i_mapEntry, and MapEntry::IsBattleArena().

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

◆ IsBattleground()

bool Map::IsBattleground ( ) const

inline

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

MapEntry::IsBattleground

bool IsBattleground() const

Definition: DBCStructure.h:1353

References i_mapEntry, and MapEntry::IsBattleground().

Referenced by AuraEffect::HandleAuraDummy().

◆ IsBattlegroundOrArena()

bool Map::IsBattlegroundOrArena ( ) const

inline

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

MapEntry::IsBattlegroundOrArena

bool IsBattlegroundOrArena() const

Definition: DBCStructure.h:1355

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(), and ToBattlegroundMap().

◆ isCellMarked()

bool Map::isCellMarked ( uint32 pCellId )

inline

470{ 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:742

References marked_cells.

Referenced by VisitNearbyCellsOf().

◆ isCellMarkedLarge()

bool Map::isCellMarkedLarge ( uint32 pCellId )

inline

473{ return marked_cells_large.test(pCellId); }

Map::marked_cells_large

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP > marked_cells_large

Definition: Map.h:743

References marked_cells_large.

Referenced by VisitNearbyCellsOf(), and VisitNearbyCellsOfPlayer().

◆ IsDungeon()

bool Map::IsDungeon ( ) const

inline

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

MapEntry::IsDungeon

bool IsDungeon() const

Definition: DBCStructure.h:1349

References i_mapEntry, and MapEntry::IsDungeon().

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

◆ IsGridLoaded() [1/2]

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

private

{
    return (getNGrid(p.x_coord, p.y_coord) && isGridObjectDataLoaded(p.x_coord, p.y_coord));
}

References getNGrid(), isGridObjectDataLoaded(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

◆ IsGridLoaded() [2/2]

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

inline

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

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

Referenced by ObjectMgr::AddGOData(), GameEventMgr::GameEventSpawn(), IsGridLoaded(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::SetData(), PoolGroup< T >::Spawn1Object(), SwitchGridContainers(), and Visit().

◆ isGridObjectDataLoaded()

bool Map::isGridObjectDataLoaded	(	uint32	x,
		uint32	y
	)		const

inlineprivate

692{ return getNGrid(x, y)->isGridObjectDataLoaded(); }

References getNGrid(), and NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::isGridObjectDataLoaded().

Referenced by EnsureGridLoaded(), and IsGridLoaded().

◆ IsHeroic()

bool Map::IsHeroic ( ) const

inline

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

DUNGEON_DIFFICULTY_HEROIC

@ DUNGEON_DIFFICULTY_HEROIC

Definition: DBCEnums.h:278

RAID_DIFFICULTY_10MAN_HEROIC

@ RAID_DIFFICULTY_10MAN_HEROIC

Definition: DBCEnums.h:283

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

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

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

◆ IsInWater()

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

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

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

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

◆ IsNonRaidDungeon()

bool Map::IsNonRaidDungeon ( ) const

inline

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

MapEntry::IsNonRaidDungeon

bool IsNonRaidDungeon() const

Definition: DBCStructure.h:1350

References i_mapEntry, and MapEntry::IsNonRaidDungeon().

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

◆ IsRaid()

bool Map::IsRaid ( ) const

inline

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

MapEntry::IsRaid

bool IsRaid() const

Definition: DBCStructure.h:1352

References i_mapEntry, and MapEntry::IsRaid().

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

◆ IsRaidOrHeroicDungeon()

bool Map::IsRaidOrHeroicDungeon ( ) const

inline

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

DUNGEON_DIFFICULTY_NORMAL

@ DUNGEON_DIFFICULTY_NORMAL

Definition: DBCEnums.h:277

References DUNGEON_DIFFICULTY_NORMAL, i_spawnMode, and IsRaid().

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

◆ IsRegularDifficulty()

bool Map::IsRegularDifficulty ( ) const

inline

444{ return GetDifficulty() == REGULAR_DIFFICULTY; }

REGULAR_DIFFICULTY

@ REGULAR_DIFFICULTY

Definition: DBCEnums.h:275

References GetDifficulty(), and REGULAR_DIFFICULTY.

◆ IsRemovalGrid()

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

inline

    {
        GridCoord p = Acore::ComputeGridCoord(x, y);
        return !getNGrid(p.x_coord, p.y_coord);
    }

References Acore::ComputeGridCoord(), getNGrid(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by ObjectMgr::AddCreData(), and ConvertCorpseToBones().

◆ IsUnderWater()

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

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

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

Referenced by WorldSession::HandleMovementOpcodes().

◆ LoadAllCells()

void Map::LoadAllCells ( )

{
    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 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(), and MapInstanced::CreateInstance().

◆ LoadGrid()

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

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

References EnsureGridLoaded().

Referenced by at_zulgurub_entrance_speech::_OnTrigger(), at_zulgurub_bridge_speech::_OnTrigger(), at_zulgurub_temple_speech::_OnTrigger(), at_zulgurub_bloodfire_pit_speech::_OnTrigger(), at_zulgurub_edge_of_madness_speech::_OnTrigger(), CinematicMgr::BeginCinematic(), instance_stratholme::instance_stratholme_InstanceMapScript::CheckZiggurats(), instance_the_black_morass::instance_the_black_morass_InstanceMapScript::CleanupInstance(), MotionTransport::DelayedTeleportTransport(), npc_thrall_warchief::npc_thrall_warchiefAI::DoAction(), npc_crok_scourgebane::npc_crok_scourgebaneAI::DoAction(), instance_culling_of_stratholme::instance_culling_of_stratholme_InstanceMapScript::EnsureGridLoaded(), instance_old_hillsbrad::instance_old_hillsbrad_InstanceMapScript::EnsureGridLoaded(), WorldSession::HandleMoveWorldportAck(), boss_kelidan_the_breaker::JustDied(), boss_kurinnaxx::JustDied(), LoadAllCells(), npc_akama_illidan::npc_akama_illidanAI::npc_akama_illidanAI(), instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::OnCreatureCreate(), instance_ulduar::instance_ulduar_InstanceMapScript::OnGameObjectCreate(), instance_ruby_sanctum::instance_ruby_sanctum_InstanceMapScript::OnPlayerEnter(), instance_pit_of_saron::instance_pit_of_saron_InstanceScript::OnPlayerEnter(), instance_sunwell_plateau::instance_sunwell_plateau_InstanceMapScript::OnPlayerEnter(), instance_ruins_of_ahnqiraj::instance_ruins_of_ahnqiraj_InstanceMapScript::OnPlayerEnter(), instance_ulduar::instance_ulduar_InstanceMapScript::OnPlayerEnter(), at_sindragosa_lair::OnTrigger(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnUnitDeath(), FlightPathMovementGenerator::PreloadEndGrid(), instance_naxxramas::instance_naxxramas_InstanceMapScript::SetBossState(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetBossState(), instance_stratholme::instance_stratholme_InstanceMapScript::SetData(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::SetData(), instance_dire_maul::instance_dire_maul_InstanceMapScript::SetData(), instance_wailing_caverns::instance_wailing_caverns_InstanceMapScript::SetData(), instance_halls_of_reflection::instance_halls_of_reflection_InstanceMapScript::SetData(), instance_ulduar::instance_ulduar_InstanceMapScript::SetData(), instance_shattered_halls::instance_shattered_halls_InstanceMapScript::SetData(), Vehicle::TeleportVehicle(), instance_stratholme::instance_stratholme_InstanceMapScript::Update(), instance_old_hillsbrad::instance_old_hillsbrad_InstanceMapScript::Update(), instance_naxxramas::instance_naxxramas_InstanceMapScript::Update(), MotionTransport::UpdatePosition(), and StaticTransport::UpdatePosition().

◆ LoadMap()

void Map::LoadMap	(	int	gx,
		int	gy,
		bool	reload = `false`
	)

private

{
    if (i_InstanceId != 0)
    {
        if (GridMaps[gx][gy])
            return;
 
        // load grid map for base map
        m_parentMap->EnsureGridCreated(GridCoord(63 - gx, 63 - gy));
 
        GridMaps[gx][gy] = m_parentMap->GridMaps[gx][gy];
        return;
    }
 
    if (GridMaps[gx][gy] && !reload)
        return;
 
    //map already load, delete it before reloading (Is it necessary? Do we really need the ability the reload maps during runtime?)
    if (GridMaps[gx][gy])
    {
        LOG_DEBUG("maps", "Unloading previously loaded map {} before reloading.", GetId());
        sScriptMgr->OnUnloadGridMap(this, GridMaps[gx][gy], gx, gy);
 
        delete (GridMaps[gx][gy]);
        GridMaps[gx][gy] = nullptr;
    }
 
    // map file name
    char* tmp = nullptr;
    int len = sWorld->GetDataPath().length() + strlen("maps/%03u%02u%02u.map") + 1;
    tmp = new char[len];
    snprintf(tmp, len, (char*)(sWorld->GetDataPath() + "maps/%03u%02u%02u.map").c_str(), GetId(), gx, gy);
    LOG_DEBUG("maps", "Loading map {}", tmp);
    // loading data
    GridMaps[gx][gy] = new GridMap();
    if (!GridMaps[gx][gy]->loadData(tmp))
    {
        LOG_ERROR("maps", "Error loading map file: \n {}\n", tmp);
    }
    delete [] tmp;
 
    sScriptMgr->OnLoadGridMap(this, GridMaps[gx][gy], gx, gy);
}

References EnsureGridCreated(), GetId(), GridMaps, i_InstanceId, LOG_DEBUG, LOG_ERROR, m_parentMap, sScriptMgr, and sWorld.

Referenced by LoadMapAndVMap().

◆ LoadMapAndVMap()

void Map::LoadMapAndVMap	(	int	gx,
		int	gy
	)

private

{
    LoadMap(gx, gy);
    if (i_InstanceId == 0)
    {
        LoadVMap(gx, gy);                                   // Only load the data for the base map
        LoadMMap(gx, gy);
    }
}

References i_InstanceId, LoadMap(), LoadMMap(), and LoadVMap().

Referenced by EnsureGridCreated_i().

◆ LoadMMap()

void Map::LoadMMap	(	int	gx,
		int	gy
	)

private

{
    if (!DisableMgr::IsPathfindingEnabled(this)) // pussywizard
        return;
 
    int mmapLoadResult = MMAP::MMapFactory::createOrGetMMapMgr()->loadMap(GetId(), gx, gy);
    switch (mmapLoadResult)
    {
        case MMAP::MMAP_LOAD_RESULT_OK:
            LOG_DEBUG("maps", "MMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
        case MMAP::MMAP_LOAD_RESULT_ERROR:
            LOG_DEBUG("maps", "Could not load MMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
        case MMAP::MMAP_LOAD_RESULT_IGNORED:
            LOG_DEBUG("maps", "Ignored MMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
    }
}

References MMAP::MMapFactory::createOrGetMMapMgr(), GetId(), GetMapName(), DisableMgr::IsPathfindingEnabled(), MMAP::MMapMgr::loadMap(), LOG_DEBUG, MMAP::MMAP_LOAD_RESULT_ERROR, MMAP::MMAP_LOAD_RESULT_IGNORED, and MMAP::MMAP_LOAD_RESULT_OK.

Referenced by LoadMapAndVMap().

◆ LoadRespawnTimes()

void Map::LoadRespawnTimes ( )

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

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

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

◆ LoadVMap()

void Map::LoadVMap	(	int	gx,
		int	gy
	)

private

{
    // x and y are swapped !!
    int vmapLoadResult = VMAP::VMapFactory::createOrGetVMapMgr()->loadMap((sWorld->GetDataPath() + "vmaps").c_str(), GetId(), gx, gy);
    switch (vmapLoadResult)
    {
        case VMAP::VMAP_LOAD_RESULT_OK:
            LOG_DEBUG("maps", "VMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
        case VMAP::VMAP_LOAD_RESULT_ERROR:
            LOG_DEBUG("maps", "Could not load VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
        case VMAP::VMAP_LOAD_RESULT_IGNORED:
            LOG_DEBUG("maps", "Ignored VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
            break;
    }
}

References VMAP::VMapFactory::createOrGetVMapMgr(), GetId(), GetMapName(), VMAP::VMapMgr2::loadMap(), LOG_DEBUG, sWorld, VMAP::VMAP_LOAD_RESULT_ERROR, VMAP::VMAP_LOAD_RESULT_IGNORED, and VMAP::VMAP_LOAD_RESULT_OK.

Referenced by LoadMapAndVMap().

◆ 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

471{ marked_cells.set(pCellId); }

References marked_cells.

Referenced by VisitNearbyCellsOf().

◆ markCellLarge()

void Map::markCellLarge ( uint32 pCellId )

inline

474{ marked_cells_large.set(pCellId); }

References marked_cells_large.

Referenced by VisitNearbyCellsOf(), and VisitNearbyCellsOfPlayer().

◆ MoveAllCreaturesInMoveList()

void Map::MoveAllCreaturesInMoveList ( )

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

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

Referenced by Update().

◆ MoveAllDynamicObjectsInMoveList()

void Map::MoveAllDynamicObjectsInMoveList ( )

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

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

Referenced by Update().

◆ MoveAllGameObjectsInMoveList()

void Map::MoveAllGameObjectsInMoveList ( )

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

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

Referenced by Update().

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

◆ PlayerRelocation()

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

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

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

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

◆ RemoveAllObjectsInRemoveList()

void Map::RemoveAllObjectsInRemoveList ( )

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

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

Referenced by DelayedUpdate(), and 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->m_homebindO);
            }
        }
    }
}

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

◆ RemoveCorpse()

void Map::RemoveCorpse ( Corpse * corpse )

{
    ASSERT(corpse);
 
    corpse->DestroyForNearbyPlayers();
    if (corpse->IsInGrid())
        RemoveFromMap(corpse, false);
    else
    {
        corpse->RemoveFromWorld();
        corpse->ResetMap();
    }
 
    _corpsesByCell[corpse->GetCellCoord().GetId()].erase(corpse);
    if (corpse->GetType() != CORPSE_BONES)
        _corpsesByPlayer.erase(corpse->GetOwnerGUID());
    else
        _corpseBones.erase(corpse);
}

References _corpseBones, _corpsesByCell, _corpsesByPlayer, ASSERT, CORPSE_BONES, WorldObject::DestroyForNearbyPlayers(), Corpse::GetCellCoord(), CoordPair< LIMIT >::GetId(), Corpse::GetOwnerGUID(), Corpse::GetType(), GridObject< T >::IsInGrid(), RemoveFromMap(), Corpse::RemoveFromWorld(), and WorldObject::ResetMap().

Referenced by ConvertCorpseToBones(), and RemoveOldCorpses().

◆ RemoveCreatureFromMoveList()

void Map::RemoveCreatureFromMoveList ( Creature * c )

private

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

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by CreatureRelocation().

◆ RemoveCreatureRespawnTime()

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

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

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

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

◆ RemoveDynamicObjectFromMoveList()

void Map::RemoveDynamicObjectFromMoveList ( DynamicObject * go )

private

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

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by DynamicObjectRelocation().

◆ RemoveFromActive() [1/4]

template<>

void Map::RemoveFromActive ( Creature * c )

{
    RemoveFromActiveHelper(c);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [2/4]

template<>

void Map::RemoveFromActive ( DynamicObject * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [3/4]

template<>

void Map::RemoveFromActive ( GameObject * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

◆ RemoveFromActive() [4/4]

template<class T >

void Map::RemoveFromActive ( T * obj )

{
    RemoveFromActiveHelper(obj);
}

References RemoveFromActiveHelper().

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

◆ RemoveFromActiveHelper()

void Map::RemoveFromActiveHelper ( WorldObject * obj )

inlineprivate

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

References m_activeNonPlayers, and m_activeNonPlayersIter.

Referenced by RemoveFromActive().

◆ RemoveFromMap() [1/2]

template<>

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

{
    obj->RemoveFromWorld();
    if (obj->isActiveObject())
        RemoveFromActive(obj);
 
    Map::PlayerList const& players = GetPlayers();
    if (!players.IsEmpty())
    {
        UpdateData data;
        obj->BuildOutOfRangeUpdateBlock(&data);
        WorldPacket packet;
        data.BuildPacket(&packet);
        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
            if (itr->GetSource()->GetTransport() != obj)
                itr->GetSource()->SendDirectMessage(&packet);
    }
 
    if (_transportsUpdateIter != _transports.end())
    {
        TransportsContainer::iterator itr = _transports.find(obj);
        if (itr == _transports.end())
            return;
        if (itr == _transportsUpdateIter)
            ++_transportsUpdateIter;
        _transports.erase(itr);
    }
    else
        _transports.erase(obj);
 
    obj->ResetMap();
 
    if (remove)
    {
        // if option set then object already saved at this moment
        if (!sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY))
            obj->SaveRespawnTime();
        DeleteFromWorld(obj);
    }
}

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

◆ RemoveFromMap() [2/2]

template<class T >

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

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

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

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

◆ RemoveGameObjectFromMoveList()

void Map::RemoveGameObjectFromMoveList ( GameObject * go )

private

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

References MovableMapObject::_moveState, MAP_OBJECT_CELL_MOVE_ACTIVE, and MAP_OBJECT_CELL_MOVE_INACTIVE.

Referenced by GameObjectRelocation().

◆ RemoveGameObjectModel()

void Map::RemoveGameObjectModel ( const GameObjectModel & model )

inline

559{ _dynamicTree.remove(model); }

DynamicMapTree::remove

void remove(const GameObjectModel &)

Definition: DynamicTree.cpp:122

References _dynamicTree, and DynamicMapTree::remove().

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

◆ RemoveGORespawnTime()

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

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

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

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

◆ RemoveOldCorpses()

void Map::RemoveOldCorpses ( )

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

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

Referenced by World::Update().

◆ RemovePlayerFromMap()

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

virtual

Reimplemented in InstanceMap, and BattlegroundMap.

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

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

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

◆ RemoveUpdateObject()

void Map::RemoveUpdateObject ( Object * obj )

inline

    {
        _updateObjects.erase(obj);
    }

References _updateObjects.

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

◆ RemoveWorldObject()

void Map::RemoveWorldObject ( WorldObject * obj )

inline

480{ i_worldObjects.erase(obj); }

References i_worldObjects.

Referenced by WorldObject::ResetMap(), and SwitchGridContainers().

◆ resetMarkedCells()

void Map::resetMarkedCells ( )

inline

469{ marked_cells.reset(); }

References marked_cells.

Referenced by Update().

◆ resetMarkedCellsLarge()

void Map::resetMarkedCellsLarge ( )

inline

472{ marked_cells_large.reset(); }

References marked_cells_large.

Referenced by Update().

◆ SaveCreatureRespawnTime()

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

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

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

Referenced by Creature::SaveRespawnTime().

◆ SaveGORespawnTime()

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

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

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

Referenced by GameObject::SaveRespawnTime().

◆ ScheduleCreatureRespawn()

void Map::ScheduleCreatureRespawn	(	ObjectGuid	creatureGuid,
		Milliseconds	respawnTimer
	)

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

References _creatureRespawnScheduler, GetCreature(), and TaskScheduler::Schedule().

Referenced by 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->GetTypeId() == TYPEID_ITEM) ? ((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(), Object::GetTypeId(), i_scriptLock, m_scriptSchedule, ScriptAction::ownerGUID, ScriptAction::script, ScriptsProcess(), ScriptAction::sourceGUID, sScriptMgr, ScriptAction::targetGUID, and TYPEID_ITEM.

◆ ScriptsProcess()

void Map::ScriptsProcess ( )

private

Process queued scripts.

Process overdue queued scripts

Todo:
: Allow gameobjects to be targets and casters

{
    if (m_scriptSchedule.empty())
        return;
 
    ScriptScheduleMap::iterator iter = m_scriptSchedule.begin();
    // ok as multimap is a *sorted* associative container
    while (!m_scriptSchedule.empty() && (iter->first <= GameTime::GetGameTime().count()))
    {
        ScriptAction const& step = iter->second;
 
        Object* source = nullptr;
        if (step.sourceGUID)
        {
            switch (step.sourceGUID.GetHigh())
            {
                case HighGuid::Item: // as well as HIGHGUID_CONTAINER
                    if (Player* player = ObjectAccessor::GetPlayer(this, step.ownerGUID))
                        source = player->GetItemByGuid(step.sourceGUID);
                    break;
                case HighGuid::Unit:
                case HighGuid::Vehicle:
                    source = GetCreature(step.sourceGUID);
                    break;
                case HighGuid::Pet:
                    source = GetPet(step.sourceGUID);
                    break;
                case HighGuid::Player:
                    source = HashMapHolder<Player>::Find(step.sourceGUID);
                    break;
                case HighGuid::Transport:
                case HighGuid::GameObject:
                    source = GetGameObject(step.sourceGUID);
                    break;
                case HighGuid::Corpse:
                    source = GetCorpse(step.sourceGUID);
                    break;
                case HighGuid::Mo_Transport:
                    source = GetTransport(step.sourceGUID);
                    break;
                default:
                    LOG_ERROR("maps.script", "{} source with unsupported high guid ({}).",
                                   step.script->GetDebugInfo(), step.sourceGUID.ToString());
                    break;
            }
        }
 
        WorldObject* target = nullptr;
        if (step.targetGUID)
        {
            switch (step.targetGUID.GetHigh())
            {
                case HighGuid::Unit:
                case HighGuid::Vehicle:
                    target = GetCreature(step.targetGUID);
                    break;
                case HighGuid::Pet:
                    target = GetPet(step.targetGUID);
                    break;
                case HighGuid::Player:                       // empty GUID case also
                    target = HashMapHolder<Player>::Find(step.targetGUID);
                    break;
                case HighGuid::Transport:
                case HighGuid::GameObject:
                    target = GetGameObject(step.targetGUID);
                    break;
                case HighGuid::Corpse:
                    target = GetCorpse(step.targetGUID);
                    break;
                case HighGuid::Mo_Transport:
                    target = GetTransport(step.targetGUID);
                    break;
                default:
                    LOG_ERROR("maps.script", "{} target with unsupported high guid ({}).",
                                   step.script->GetDebugInfo(), step.targetGUID.ToString());
                    break;
            }
        }
 
        switch (step.script->command)
        {
            case SCRIPT_COMMAND_TALK:
            {
                if (step.script->Talk.ChatType > CHAT_TYPE_WHISPER && step.script->Talk.ChatType != CHAT_MSG_RAID_BOSS_WHISPER)
                {
                    LOG_ERROR("maps.script", "{} invalid chat type ({}) specified, skipping.", step.script->GetDebugInfo(), step.script->Talk.ChatType);
                    break;
                }
 
                if (step.script->Talk.Flags & SF_TALK_USE_PLAYER)
                {
                    source = _GetScriptPlayerSourceOrTarget(source, target, step.script);
                }
                else
                {
                    source = _GetScriptCreatureSourceOrTarget(source, target, step.script);
                }
 
                if (source)
                {
                    Unit* sourceUnit = source->ToUnit();
                    if (!sourceUnit)
                    {
                        LOG_ERROR("scripts", "{} source object ({}) is not an unit, skipping.", step.script->GetDebugInfo(), source->GetGUID().ToString());
                        break;
                    }
 
                    switch (step.script->Talk.ChatType)
                    {
                        case CHAT_TYPE_SAY:
                            sourceUnit->Say(step.script->Talk.TextID, target);
                            break;
                        case CHAT_TYPE_YELL:
                            sourceUnit->Yell(step.script->Talk.TextID, target);
                            break;
                        case CHAT_TYPE_TEXT_EMOTE:
                        case CHAT_TYPE_BOSS_EMOTE:
                            sourceUnit->TextEmote(step.script->Talk.TextID, target, step.script->Talk.ChatType == CHAT_TYPE_BOSS_EMOTE);
                            break;
                        case CHAT_TYPE_WHISPER:
                        case CHAT_MSG_RAID_BOSS_WHISPER:
                        {
                            Player* receiver = target ? target->ToPlayer() : nullptr;
                            if (!receiver)
                                LOG_ERROR("scripts", "{} attempt to whisper to non-player unit, skipping.", step.script->GetDebugInfo());
                            else
                                sourceUnit->Whisper(step.script->Talk.TextID, receiver, step.script->Talk.ChatType == CHAT_MSG_RAID_BOSS_WHISPER);
                            break;
                        }
                        default:
                            break;                              // must be already checked at load
                    }
                }
                break;
            }
            case SCRIPT_COMMAND_EMOTE:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    if (step.script->Emote.Flags & SF_EMOTE_USE_STATE)
                        cSource->SetUInt32Value(UNIT_NPC_EMOTESTATE, step.script->Emote.EmoteID);
                    else
                        cSource->HandleEmoteCommand(step.script->Emote.EmoteID);
                }
                break;
 
            case SCRIPT_COMMAND_FIELD_SET:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FieldSet.FieldID <= OBJECT_FIELD_ENTRY || step.script->FieldSet.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FieldSet.FieldID, cSource->GetValuesCount(), cSource->GetGUID().ToString());
                    else
                        cSource->SetUInt32Value(step.script->FieldSet.FieldID, step.script->FieldSet.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_MOVE_TO:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    Unit* unit = (Unit*)cSource;
                    if (step.script->MoveTo.TravelTime != 0)
                    {
                        float speed = unit->GetDistance(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ) / ((float)step.script->MoveTo.TravelTime * 0.001f);
                        unit->MonsterMoveWithSpeed(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, speed);
                    }
                    else
                        unit->NearTeleportTo(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, unit->GetOrientation());
                }
                break;
 
            case SCRIPT_COMMAND_FLAG_SET:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FlagToggle.FieldID, cSource->GetValuesCount(), cSource->GetGUID().ToString());
                    else
                        cSource->SetFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_FLAG_REMOVE:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    // Validate field number.
                    if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                        LOG_ERROR("maps.script", "{} wrong field {} (max count: {}) in object ({}) specified, skipping.",
                                       step.script->GetDebugInfo(), step.script->FlagToggle.FieldID, cSource->GetValuesCount(),  cSource->GetGUID().ToString());
                    else
                        cSource->RemoveFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                }
                break;
 
            case SCRIPT_COMMAND_TELEPORT_TO:
                if (step.script->TeleportTo.Flags & SF_TELEPORT_USE_CREATURE)
                {
                    // Source or target must be Creature.
                    if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                        cSource->NearTeleportTo(step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                }
                else
                {
                    // Source or target must be Player.
                    if (Player* player = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                        player->TeleportTo(step.script->TeleportTo.MapID, step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                }
                break;
 
            case SCRIPT_COMMAND_QUEST_EXPLORED:
                {
                    if (!source)
                    {
                        LOG_ERROR("maps.script", "{} source object is nullptr.", step.script->GetDebugInfo());
                        break;
                    }
                    if (!target)
                    {
                        LOG_ERROR("maps.script", "{} target object is nullptr.", step.script->GetDebugInfo());
                        break;
                    }
 
                    // when script called for item spell casting then target == (unit or GO) and source is player
                    WorldObject* worldObject;
                    Player* player = target->ToPlayer();
                    if (player)
                    {
                        if (source->GetTypeId() != TYPEID_UNIT && source->GetTypeId() != TYPEID_GAMEOBJECT && source->GetTypeId() != TYPEID_PLAYER)
                        {
                            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->GetTypeId() != TYPEID_UNIT && target->GetTypeId() != TYPEID_GAMEOBJECT && target->GetTypeId() != TYPEID_PLAYER)
                            {
                                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->GetTypeId() != TYPEID_UNIT || ((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->GetTypeId() != TYPEID_GAMEOBJECT)
                    {
                        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->isType(TYPEMASK_UNIT))
                    {
                        LOG_ERROR("maps.script", "{} no source unit found for spell {}", step.script->GetDebugInfo(), step.script->CastSpell.SpellID);
                        break;
                    }
 
                    if (!uTarget || !uTarget->isType(TYPEMASK_UNIT))
                    {
                        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=without/with distance dependent
                    if (step.script->Playsound.Flags & SF_PLAYSOUND_DISTANCE_SOUND)
                        object->PlayDistanceSound(step.script->Playsound.SoundID, player);
                    else
                        object->PlayDirectSound(step.script->Playsound.SoundID, player);
                }
                break;
 
            case SCRIPT_COMMAND_CREATE_ITEM:
                // Target or source must be Player.
                if (Player* pReceiver = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                {
                    ItemPosCountVec dest;
                    InventoryResult msg = pReceiver->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, step.script->CreateItem.ItemEntry, step.script->CreateItem.Amount);
                    if (msg == EQUIP_ERR_OK)
                    {
                        if (Item* item = pReceiver->StoreNewItem(dest, step.script->CreateItem.ItemEntry, true))
                            pReceiver->SendNewItem(item, step.script->CreateItem.Amount, false, true);
                    }
                    else
                        pReceiver->SendEquipError(msg, nullptr, nullptr, step.script->CreateItem.ItemEntry);
                }
                break;
 
            case SCRIPT_COMMAND_DESPAWN_SELF:
                // Target or source must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                    cSource->DespawnOrUnsummon(step.script->DespawnSelf.DespawnDelay);
                break;
 
            case SCRIPT_COMMAND_LOAD_PATH:
                // Source must be Unit.
                if (Unit* unit = _GetScriptUnit(source, true, step.script))
                {
                    if (!sWaypointMgr->GetPath(step.script->LoadPath.PathID))
                        LOG_ERROR("maps.script", "{} source object has an invalid path ({}), skipping.", step.script->GetDebugInfo(), step.script->LoadPath.PathID);
                    else
                        unit->GetMotionMaster()->MovePath(step.script->LoadPath.PathID, step.script->LoadPath.IsRepeatable);
                }
                break;
 
            case SCRIPT_COMMAND_CALLSCRIPT_TO_UNIT:
                {
                    if (!step.script->CallScript.CreatureEntry)
                    {
                        LOG_ERROR("maps.script", "{} creature entry is not specified, skipping.", step.script->GetDebugInfo());
                        break;
                    }
                    if (!step.script->CallScript.ScriptID)
                    {
                        LOG_ERROR("maps.script", "{} script id is not specified, skipping.", step.script->GetDebugInfo());
                        break;
                    }
 
                    Creature* cTarget = nullptr;
                    auto creatureBounds = _creatureBySpawnIdStore.equal_range(step.script->CallScript.CreatureEntry);
                    if (creatureBounds.first != creatureBounds.second)
                    {
                        // Prefer alive (last respawned) creature
                        auto creatureItr = std::find_if(creatureBounds.first, creatureBounds.second, [](Map::CreatureBySpawnIdContainer::value_type const& pair)
                        {
                            return pair.second->IsAlive();
                        });
                        cTarget = creatureItr != creatureBounds.second ? creatureItr->second : creatureBounds.first->second;
                    }
 
                    if (!cTarget)
                    {
                        LOG_ERROR("maps.script", "{} target was not found (entry: {})", step.script->GetDebugInfo(), step.script->CallScript.CreatureEntry);
                        break;
                    }
 
                    //Lets choose our ScriptMap map
                    ScriptMapMap* datamap = GetScriptsMapByType(ScriptsType(step.script->CallScript.ScriptType));
                    //if no scriptmap present...
                    if (!datamap)
                    {
                        LOG_ERROR("maps.script", "{} unknown scriptmap ({}) specified, skipping.", step.script->GetDebugInfo(), step.script->CallScript.ScriptType);
                        break;
                    }
 
                    // Insert script into schedule but do not start it
                    ScriptsStart(*datamap, step.script->CallScript.ScriptID, cTarget, nullptr);
                    break;
                }
 
            case SCRIPT_COMMAND_KILL:
                // Source or target must be Creature.
                if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                {
                    if (cSource->isDead())
                        LOG_ERROR("maps.script", "{} creature is already dead ({})", step.script->GetDebugInfo(), cSource->GetGUID().ToString());
                    else
                    {
                        cSource->setDeathState(DeathState::JustDied);
                        if (step.script->Kill.RemoveCorpse == 1)
                            cSource->RemoveCorpse();
                    }
                }
                break;
 
            case SCRIPT_COMMAND_ORIENTATION:
                // Source must be Unit.
                if (Unit* sourceUnit = _GetScriptUnit(source, true, step.script))
                {
                    if (step.script->Orientation.Flags & SF_ORIENTATION_FACE_TARGET)
                    {
                        // Target must be Unit.
                        Unit* targetUnit = _GetScriptUnit(target, false, step.script);
                        if (!targetUnit)
                            break;
 
                        sourceUnit->SetFacingToObject(targetUnit);
                    }
                    else
                        sourceUnit->SetFacingTo(step.script->Orientation.Orientation);
                }
                break;
 
            case SCRIPT_COMMAND_EQUIP:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                    cSource->LoadEquipment(step.script->Equip.EquipmentID);
                break;
 
            case SCRIPT_COMMAND_MODEL:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                    cSource->SetDisplayId(step.script->Model.ModelID);
                break;
 
            case SCRIPT_COMMAND_CLOSE_GOSSIP:
                // Source must be Player.
                if (Player* player = _GetScriptPlayer(source, true, step.script))
                    player->PlayerTalkClass->SendCloseGossip();
                break;
 
            case SCRIPT_COMMAND_PLAYMOVIE:
                // Source must be Player.
                if (Player* player = _GetScriptPlayer(source, true, step.script))
                    player->SendMovieStart(step.script->PlayMovie.MovieID);
                break;
 
            case SCRIPT_COMMAND_MOVEMENT:
                // Source must be Creature.
                if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                {
                    if (!cSource->IsAlive())
                        return;
 
                    cSource->GetMotionMaster()->MovementExpired();
                    cSource->GetMotionMaster()->MoveIdle();
 
                    switch (step.script->Movement.MovementType)
                    {
                        case RANDOM_MOTION_TYPE:
                            cSource->GetMotionMaster()->MoveRandom((float)step.script->Movement.MovementDistance);
                            break;
                        case WAYPOINT_MOTION_TYPE:
                            cSource->GetMotionMaster()->MovePath(step.script->Movement.Path, false);
                            break;
                    }
                }
                break;
 
            default:
                LOG_ERROR("maps.script", "Unknown script command {}.", step.script->GetDebugInfo());
                break;
        }
 
        m_scriptSchedule.erase(iter);
        iter = m_scriptSchedule.begin();
        sScriptMgr->DecreaseScheduledScriptCount();
    }
}

References _creatureBySpawnIdStore, _FindGameObject(), _GetScriptCreature(), _GetScriptCreatureSourceOrTarget(), _GetScriptPlayer(), _GetScriptPlayerSourceOrTarget(), _GetScriptUnit(), _GetScriptWorldObject(), _ScriptProcessDoor(), AddToMap(), ScriptInfo::Amount, ScriptInfo::CallScript, Unit::CastSpell(), ScriptInfo::CastSpell, CHAT_MSG_RAID_BOSS_WHISPER, CHAT_TYPE_BOSS_EMOTE, CHAT_TYPE_SAY, CHAT_TYPE_TEXT_EMOTE, CHAT_TYPE_WHISPER, CHAT_TYPE_YELL, ScriptInfo::ChatType, ScriptInfo::CheckIfExists, ScriptInfo::command, ScriptInfo::CreateItem, ScriptInfo::CreatureEntry, ScriptInfo::DespawnDelay, ScriptInfo::DespawnSelf, ScriptInfo::DestX, ScriptInfo::DestY, ScriptInfo::DestZ, ScriptInfo::Distance, ScriptInfo::Emote, ScriptInfo::EmoteID, ScriptInfo::Equip, EQUIP_ERR_OK, ScriptInfo::EquipmentID, Player::FailQuest(), ScriptInfo::FieldID, ScriptInfo::FieldSet, ScriptInfo::FieldValue, HashMapHolder< T >::Find(), ScriptInfo::Flags, ScriptInfo::FlagToggle, GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_FISHINGNODE, GAMEOBJECT_TYPE_TRAP, GetClosestCreatureWithEntry(), GetCorpse(), GetCreature(), ScriptInfo::GetDebugInfo(), WorldObject::GetDistance(), GetGameObject(), GameTime::GetGameTime(), GameObject::GetGoType(), Object::GetGUID(), ObjectGuid::GetHigh(), WorldObject::GetMap(), Position::GetOrientation(), GetPet(), ObjectAccessor::GetPlayer(), GetScriptsMapByType(), GetTransport(), Object::GetTypeId(), GO_READY, ScriptInfo::GOGuid, Player::GroupEventHappens(), ScriptInfo::IsRepeatable, GameObject::isSpawned(), Object::isType(), WorldObject::IsWithinDistInMap(), ScriptInfo::ItemEntry, ScriptInfo::Kill, ScriptInfo::KillCredit, ScriptInfo::LoadPath, LOG_ERROR, m_scriptSchedule, ScriptInfo::MapID, ScriptInfo::Model, ScriptInfo::ModelID, Unit::MonsterMoveWithSpeed(), ScriptInfo::Movement, ScriptInfo::MovementDistance, ScriptInfo::MovementType, ScriptInfo::MoveTo, ScriptInfo::MovieID, Unit::NearTeleportTo(), NULL_BAG, NULL_SLOT, OBJECT_FIELD_ENTRY, ScriptInfo::Orientation, ScriptAction::ownerGUID, ScriptInfo::Path, ScriptInfo::PathID, ScriptInfo::PlayMovie, ScriptInfo::Playsound, ScriptInfo::PosX, ScriptInfo::PosY, ScriptInfo::PosZ, ScriptInfo::QuestExplored, ScriptInfo::QuestID, 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_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(), ScriptInfo::TravelTime, TYPEID_GAMEOBJECT, TYPEID_PLAYER, TYPEID_UNIT, TYPEMASK_UNIT, UNIT_NPC_EMOTESTATE, 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->GetTypeId() == TYPEID_ITEM) ? ((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(), Object::GetTypeId(), i_scriptLock, m_scriptSchedule, ScriptAction::ownerGUID, ScriptAction::script, ScriptsProcess(), ScriptAction::sourceGUID, sScriptMgr, ScriptAction::targetGUID, and TYPEID_ITEM.

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

◆ SendInitSelf()

void Map::SendInitSelf ( Player * player )

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

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

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

◆ SendInitTransports()

void Map::SendInitTransports ( Player * player )

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

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

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

◆ SendObjectUpdates()

void Map::SendObjectUpdates ( )

private

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

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

Referenced by Update().

◆ SendRemoveTransports()

void Map::SendRemoveTransports ( Player * player )

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

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

Referenced by RemovePlayerFromMap().

◆ SendToPlayers()

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

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

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

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

◆ SendZoneDynamicInfo()

void Map::SendZoneDynamicInfo ( Player * player )

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

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

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

◆ setGridObjectDataLoaded()

void Map::setGridObjectDataLoaded	(	bool	pLoaded,
		uint32	x,
		uint32	y
	)

inlineprivate

693{ getNGrid(x, y)->setGridObjectDataLoaded(pLoaded); }

NGrid::setGridObjectDataLoaded

void setGridObjectDataLoaded(bool pLoaded)

Definition: NGrid.h:66

References getNGrid(), and NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::setGridObjectDataLoaded().

Referenced by EnsureGridLoaded().

◆ setNGrid()

void Map::setNGrid	(	NGridType *	grid,
		uint32	x,
		uint32	y
	)

inlineprivate

{
    if (x >= MAX_NUMBER_OF_GRIDS || y >= MAX_NUMBER_OF_GRIDS)
    {
        LOG_ERROR("maps", "map::setNGrid() Invalid grid coordinates found: {}, {}!", x, y);
        ABORT();
    }
    i_grids[x][y] = grid;
}

References ABORT, i_grids, LOG_ERROR, and MAX_NUMBER_OF_GRIDS.

Referenced by EnsureGridCreated_i(), Map(), and UnloadGrid().

◆ SetVisibilityRange()

void Map::SetVisibilityRange ( float range )

inline

352{ m_VisibleDistance = range; }

References m_VisibleDistance.

Referenced by instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::SetBossState().

◆ SetZoneMusic()

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

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

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

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

◆ SetZoneOverrideLight()

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

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

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

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

◆ SetZoneWeather()

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

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

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

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

◆ SummonCreature()

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

{
    uint32 mask = UNIT_MASK_SUMMON;
    if (properties)
    {
        switch (properties->Category)
        {
            case SUMMON_CATEGORY_PET:
                mask = UNIT_MASK_GUARDIAN;
                break;
            case SUMMON_CATEGORY_PUPPET:
                mask = UNIT_MASK_PUPPET;
                break;
            case SUMMON_CATEGORY_VEHICLE:
                mask = UNIT_MASK_MINION;
                break;
            case SUMMON_CATEGORY_WILD:
            case SUMMON_CATEGORY_ALLY:
            case SUMMON_CATEGORY_UNK:
                {
                    switch (properties->Type)
                    {
                        case SUMMON_TYPE_MINION:
                        case SUMMON_TYPE_GUARDIAN:
                        case SUMMON_TYPE_GUARDIAN2:
                            mask = UNIT_MASK_GUARDIAN;
                            break;
                        case SUMMON_TYPE_TOTEM:
                        case SUMMON_TYPE_LIGHTWELL:
                            mask = UNIT_MASK_TOTEM;
                            break;
                        case SUMMON_TYPE_VEHICLE:
                        case SUMMON_TYPE_VEHICLE2:
                            mask = UNIT_MASK_SUMMON;
                            break;
                        case SUMMON_TYPE_MINIPET:
                        case SUMMON_TYPE_JEEVES:
                            mask = UNIT_MASK_MINION;
                            break;
                        default:
                            if (properties->Flags & 512) // Mirror Image, Summon Gargoyle
                                mask = UNIT_MASK_GUARDIAN;
                            break;
                    }
                    break;
                }
            default:
                return nullptr;
        }
    }
 
    uint32 phase = PHASEMASK_NORMAL;
    if (summoner)
        phase = summoner->GetPhaseMask();
 
    TempSummon* summon = nullptr;
    switch (mask)
    {
        case UNIT_MASK_SUMMON:
            summon = new TempSummon(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        case UNIT_MASK_GUARDIAN:
            summon = new Guardian(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        case UNIT_MASK_PUPPET:
            summon = new Puppet(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty);
            break;
        case UNIT_MASK_TOTEM:
            summon = new Totem(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty);
            break;
        case UNIT_MASK_MINION:
            summon = new Minion(properties, summoner ? summoner->GetGUID() : ObjectGuid::Empty, false);
            break;
        default:
            return nullptr;
    }
 
    EnsureGridLoaded(Cell(pos.GetPositionX(), pos.GetPositionY()));
    if (!summon->Create(GenerateLowGuid<HighGuid::Unit>(), this, phase, entry, vehId, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()))
    {
        delete summon;
        return nullptr;
    }
 
    summon->SetUInt32Value(UNIT_CREATED_BY_SPELL, spellId);
 
    summon->SetHomePosition(pos);
 
    summon->InitStats(duration);
 
    summon->SetVisibleBySummonerOnly(visibleBySummonerOnly);
 
    if (!AddToMap(summon->ToCreature(), summon->GetOwnerGUID().IsPlayer() || (summoner && summoner->GetTransport())))
    {
        delete summon;
        return nullptr;
    }
 
    summon->InitSummon();
 
    //ObjectAccessor::UpdateObjectVisibility(summon);
 
    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(), TempSummon::InitStats(), TempSummon::InitSummon(), ObjectGuid::IsPlayer(), PHASEMASK_NORMAL, Creature::SetHomePosition(), Object::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(), SummonPropertiesEntry::Type, UNIT_CREATED_BY_SPELL, UNIT_MASK_GUARDIAN, UNIT_MASK_MINION, UNIT_MASK_PUPPET, UNIT_MASK_SUMMON, and UNIT_MASK_TOTEM.

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

◆ SummonGameObject() [1/2]

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

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

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

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

◆ SummonGameObject() [2/2]

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

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

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

◆ SwitchGridContainers() [1/3]

template<>

void Map::SwitchGridContainers	(	Creature *	obj,
		bool	on
	)

{
    ASSERT(!obj->IsPermanentWorldObject());
    CellCoord p = Acore::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
    if (!p.IsCoordValid())
    {
        LOG_ERROR("maps", "Map::SwitchGridContainers: Object {} has invalid coordinates X:{} Y:{} grid cell [{}:{}]",
            obj->GetGUID().ToString(), obj->GetPositionX(), obj->GetPositionY(), p.x_coord, p.y_coord);
        return;
    }
 
    Cell cell(p);
    if (!IsGridLoaded(GridCoord(cell.data.Part.grid_x, cell.data.Part.grid_y)))
        return;
 
    LOG_DEBUG("maps", "Switch object {} from grid[{}, {}] {}", obj->GetGUID().ToString(), cell.GridX(), cell.GridY(), on);
    NGridType* ngrid = getNGrid(cell.GridX(), cell.GridY());
    ASSERT(ngrid);
 
    GridType& grid = ngrid->GetGridType(cell.CellX(), cell.CellY());
 
    obj->RemoveFromGrid(); //This step is not really necessary but we want to do ASSERT in remove/add
 
    if (on)
    {
        grid.AddWorldObject(obj);
        AddWorldObject(obj);
    }
    else
    {
        grid.AddGridObject(obj);
        RemoveWorldObject(obj);
    }
 
    obj->m_isTempWorldObject = on;
}

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), AddWorldObject(), ASSERT, Cell::CellX(), Cell::CellY(), Acore::ComputeCellCoord(), Cell::data, NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), Object::GetGUID(), getNGrid(), Position::GetPositionX(), Position::GetPositionY(), Cell::grid_x, Cell::grid_y, Cell::GridX(), Cell::GridY(), CoordPair< LIMIT >::IsCoordValid(), IsGridLoaded(), WorldObject::IsPermanentWorldObject(), LOG_DEBUG, LOG_ERROR, Creature::m_isTempWorldObject, Cell::Part, GridObject< T >::RemoveFromGrid(), RemoveWorldObject(), ObjectGuid::ToString(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

◆ SwitchGridContainers() [2/3]

template<>

void Map::SwitchGridContainers	(	GameObject *	obj,
		bool	on
	)

{
    ASSERT(!obj->IsPermanentWorldObject());
    CellCoord p = Acore::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
    if (!p.IsCoordValid())
    {
        LOG_ERROR("maps", "Map::SwitchGridContainers: Object {} has invalid coordinates X:{} Y:{} grid cell [{}:{}]",
            obj->GetGUID().ToString(), obj->GetPositionX(), obj->GetPositionY(), p.x_coord, p.y_coord);
        return;
    }
 
    Cell cell(p);
    if (!IsGridLoaded(GridCoord(cell.data.Part.grid_x, cell.data.Part.grid_y)))
        return;
 
    //LOG_DEBUG(LOG_FILTER_MAPS, "Switch object {} from grid[{}, {}] {}", obj->GetGUID().ToString(), cell.data.Part.grid_x, cell.data.Part.grid_y, on);
    NGridType* ngrid = getNGrid(cell.GridX(), cell.GridY());
    ASSERT(ngrid);
 
    GridType& grid = ngrid->GetGridType(cell.CellX(), cell.CellY());
 
    obj->RemoveFromGrid(); //This step is not really necessary but we want to do ASSERT in remove/add
 
    if (on)
    {
        grid.AddWorldObject(obj);
        AddWorldObject(obj);
    }
    else
    {
        grid.AddGridObject(obj);
        RemoveWorldObject(obj);
    }
}

References Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddGridObject(), Grid< ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::AddWorldObject(), AddWorldObject(), ASSERT, Cell::CellX(), Cell::CellY(), Acore::ComputeCellCoord(), Cell::data, NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetGridType(), Object::GetGUID(), getNGrid(), Position::GetPositionX(), Position::GetPositionY(), Cell::grid_x, Cell::grid_y, Cell::GridX(), Cell::GridY(), CoordPair< LIMIT >::IsCoordValid(), IsGridLoaded(), WorldObject::IsPermanentWorldObject(), LOG_ERROR, Cell::Part, GridObject< T >::RemoveFromGrid(), RemoveWorldObject(), ObjectGuid::ToString(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

◆ SwitchGridContainers() [3/3]

template<class T >

void Map::SwitchGridContainers	(	T *	obj,
		bool	on
	)

339{

340}

◆ ToBattlegroundMap() [1/2]

BattlegroundMap * Map::ToBattlegroundMap ( )

inline

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

BattlegroundMap

Definition: Map.h:852

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

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

References IsBattlegroundOrArena().

◆ ToInstanceMap() [1/2]

InstanceMap * Map::ToInstanceMap ( )

inline

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

Map::IsDungeon

bool IsDungeon() const

Definition: Map.h:448

References IsDungeon().

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

◆ ToInstanceMap() [2/2]

InstanceMap const * Map::ToInstanceMap ( ) const

inline

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

References IsDungeon().

◆ ToMapInstanced() [1/2]

MapInstanced * Map::ToMapInstanced ( )

inline

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

Map::Instanceable

bool Instanceable() const

Definition: Map.h:447

MapInstanced

Definition: MapInstanced.h:26

References Instanceable().

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

◆ ToMapInstanced() [2/2]

MapInstanced const * Map::ToMapInstanced ( ) const

inline

543{ 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<NGridType>::iterator i = GridRefMgr<NGridType>::begin(); i != GridRefMgr<NGridType>::end();)
    {
        NGridType& grid(*i->GetSource());
        ++i;
        UnloadGrid(grid); // deletes the grid and removes it from the GridRefMgr
    }
 
    // pussywizard: crashfix, some npc can be left on transport (not a default passenger)
    if (!AllTransportsEmpty())
        AllTransportsRemovePassengers();
 
    for (TransportsContainer::iterator itr = _transports.begin(); itr != _transports.end();)
    {
        MotionTransport* transport = *itr;
        ++itr;
 
        transport->RemoveFromWorld();
        delete transport;
    }
 
    _transports.clear();
 
    for (auto& cellCorpsePair : _corpsesByCell)
    {
        for (Corpse* corpse : cellCorpsePair.second)
        {
            corpse->RemoveFromWorld();
            corpse->ResetMap();
            delete corpse;
        }
    }
 
    _corpsesByCell.clear();
    _corpsesByPlayer.clear();
    _corpseBones.clear();
}

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

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

◆ UnloadGrid()

bool Map::UnloadGrid ( NGridType & ngrid )

{
    // pussywizard: UnloadGrid only done when whole map is unloaded, no need to worry about moving npcs between grids, etc.
 
    const uint32 x = ngrid.getX();
    const uint32 y = ngrid.getY();
 
    {
        ObjectGridCleaner worker;
        TypeContainerVisitor<ObjectGridCleaner, GridTypeMapContainer> visitor(worker);
        ngrid.VisitAllGrids(visitor);
    }
 
    RemoveAllObjectsInRemoveList();
 
    {
        ObjectGridUnloader worker;
        TypeContainerVisitor<ObjectGridUnloader, GridTypeMapContainer> visitor(worker);
        ngrid.VisitAllGrids(visitor);
    }
 
    ASSERT(i_objectsToRemove.empty());
 
    delete &ngrid;
    setNGrid(nullptr, x, y);
 
    int gx = (MAX_NUMBER_OF_GRIDS - 1) - x;
    int gy = (MAX_NUMBER_OF_GRIDS - 1) - y;
 
    if (i_InstanceId == 0)
    {
        if (GridMaps[gx][gy])
        {
            GridMaps[gx][gy]->unloadData();
            delete GridMaps[gx][gy];
        }
        // x and y are swapped
        VMAP::VMapFactory::createOrGetVMapMgr()->unloadMap(GetId(), gx, gy);
        MMAP::MMapFactory::createOrGetMMapMgr()->unloadMap(GetId(), gx, gy);
    }
 
    GridMaps[gx][gy] = nullptr;
 
    LOG_DEBUG("maps", "Unloading grid[{}, {}] for map {} finished", x, y, GetId());
    return true;
}

References ASSERT, MMAP::MMapFactory::createOrGetMMapMgr(), VMAP::VMapFactory::createOrGetVMapMgr(), GetId(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::getX(), NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::getY(), GridMaps, i_InstanceId, i_objectsToRemove, LOG_DEBUG, MAX_NUMBER_OF_GRIDS, RemoveAllObjectsInRemoveList(), setNGrid(), GridMap::unloadData(), MMAP::MMapMgr::unloadMap(), VMAP::VMapMgr2::unloadMap(), and NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::VisitAllGrids().

Referenced by UnloadAll().

◆ Update()

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

virtual

update worldsessions for existing players

update active cells around players and active objects

Process necessary scripts

Reimplemented in InstanceMap, and MapInstanced.

{
    if (t_diff)
        _dynamicTree.update(t_diff);
 
    for (m_mapRefIter = m_mapRefMgr.begin(); m_mapRefIter != m_mapRefMgr.end(); ++m_mapRefIter)
    {
        Player* player = m_mapRefIter->GetSource();
        if (player && player->IsInWorld())
        {
            //player->Update(t_diff);
            WorldSession* session = player->GetSession();
            MapSessionFilter updater(session);
            session->Update(s_diff, updater);
        }
    }
 
    _creatureRespawnScheduler.Update(t_diff);
 
    if (!t_diff)
    {
        for (m_mapRefIter = m_mapRefMgr.begin(); m_mapRefIter != m_mapRefMgr.end(); ++m_mapRefIter)
        {
            Player* player = m_mapRefIter->GetSource();
 
            if (!player || !player->IsInWorld())
                continue;
 
            // update players at tick
            player->Update(s_diff);
        }
 
        HandleDelayedVisibility();
        return;
    }
 
    resetMarkedCells();
    resetMarkedCellsLarge();
 
    Acore::ObjectUpdater updater(t_diff, false);
 
    // for creature
    TypeContainerVisitor<Acore::ObjectUpdater, GridTypeMapContainer  > grid_object_update(updater);
    // for pets
    TypeContainerVisitor<Acore::ObjectUpdater, WorldTypeMapContainer > world_object_update(updater);
 
    // for large creatures
    Acore::ObjectUpdater largeObjectUpdater(t_diff, true);
    TypeContainerVisitor<Acore::ObjectUpdater, GridTypeMapContainer  > grid_large_object_update(largeObjectUpdater);
    TypeContainerVisitor<Acore::ObjectUpdater, WorldTypeMapContainer  > world_large_object_update(largeObjectUpdater);
 
    // pussywizard: container for far creatures in combat with players
    std::vector<Creature*> updateList;
    updateList.reserve(10);
 
    // non-player active objects, increasing iterator in the loop in case of object removal
    for (m_activeNonPlayersIter = m_activeNonPlayers.begin(); m_activeNonPlayersIter != m_activeNonPlayers.end();)
    {
        WorldObject* obj = *m_activeNonPlayersIter;
        ++m_activeNonPlayersIter;
 
        if (!obj || !obj->IsInWorld())
            continue;
 
        VisitNearbyCellsOf(obj, grid_object_update, world_object_update, grid_large_object_update, world_large_object_update);
    }
 
    // the player iterator is stored in the map object
    // to make sure calls to Map::Remove don't invalidate it
    for (m_mapRefIter = m_mapRefMgr.begin(); m_mapRefIter != m_mapRefMgr.end(); ++m_mapRefIter)
    {
        Player* player = m_mapRefIter->GetSource();
 
        if (!player || !player->IsInWorld())
            continue;
 
        // update players at tick
        player->Update(s_diff);
 
        VisitNearbyCellsOfPlayer(player, grid_object_update, world_object_update, grid_large_object_update, world_large_object_update);
 
        // If player is using far sight, visit that object too
        if (WorldObject* viewPoint = player->GetViewpoint())
        {
            if (Creature* viewCreature = viewPoint->ToCreature())
            {
                VisitNearbyCellsOf(viewCreature, grid_object_update, world_object_update, grid_large_object_update, world_large_object_update);
            }
            else if (DynamicObject* viewObject = viewPoint->ToDynObject())
            {
                VisitNearbyCellsOf(viewObject, grid_object_update, world_object_update, grid_large_object_update, world_large_object_update);
            }
        }
 
        // handle updates for creatures in combat with player and are more than X yards away
        if (player->IsInCombat())
        {
            updateList.clear();
            float rangeSq = player->GetGridActivationRange() - 1.0f;
            rangeSq = rangeSq * rangeSq;
            HostileReference* ref = player->getHostileRefMgr().getFirst();
            while (ref)
            {
                if (Unit* unit = ref->GetSource()->GetOwner())
                    if (Creature* cre = unit->ToCreature())
                        if (cre->FindMap() == player->FindMap() && cre->GetExactDist2dSq(player) > rangeSq)
                            updateList.push_back(cre);
                ref = ref->next();
            }
            for (std::vector<Creature*>::const_iterator itr = updateList.begin(); itr != updateList.end(); ++itr)
                VisitNearbyCellsOf(*itr, grid_object_update, world_object_update, grid_large_object_update, world_large_object_update);
        }
    }
 
    for (_transportsUpdateIter = _transports.begin(); _transportsUpdateIter != _transports.end();) // pussywizard: transports updated after VisitNearbyCellsOf, grids around are loaded, everything ok
    {
        MotionTransport* transport = *_transportsUpdateIter;
        ++_transportsUpdateIter;
 
        if (!transport->IsInWorld())
            continue;
 
        transport->Update(t_diff);
    }
 
    SendObjectUpdates();
 
    if (!m_scriptSchedule.empty())
    {
        i_scriptLock = true;
        ScriptsProcess();
        i_scriptLock = false;
    }
 
    MoveAllCreaturesInMoveList();
    MoveAllGameObjectsInMoveList();
    MoveAllDynamicObjectsInMoveList();
 
    HandleDelayedVisibility();
 
    sScriptMgr->OnMapUpdate(this, t_diff);
 
    METRIC_VALUE("map_creatures", uint64(GetObjectsStore().Size<Creature>()),
        METRIC_TAG("map_id", std::to_string(GetId())),
        METRIC_TAG("map_instanceid", std::to_string(GetInstanceId())));
 
    METRIC_VALUE("map_gameobjects", uint64(GetObjectsStore().Size<GameObject>()),
        METRIC_TAG("map_id", std::to_string(GetId())),
        METRIC_TAG("map_instanceid", std::to_string(GetInstanceId())));
}

References _creatureRespawnScheduler, _dynamicTree, _transports, _transportsUpdateIter, MapRefMgr::begin(), MapRefMgr::end(), WorldObject::FindMap(), HostileRefMgr::getFirst(), WorldObject::GetGridActivationRange(), Unit::getHostileRefMgr(), GetId(), GetInstanceId(), GetObjectsStore(), ThreatMgr::GetOwner(), Player::GetSession(), Reference< TO, FROM >::GetSource(), Player::GetViewpoint(), HandleDelayedVisibility(), i_scriptLock, Unit::IsInCombat(), Object::IsInWorld(), m_activeNonPlayers, m_activeNonPlayersIter, m_mapRefIter, m_mapRefMgr, m_scriptSchedule, METRIC_TAG, METRIC_VALUE, MoveAllCreaturesInMoveList(), MoveAllDynamicObjectsInMoveList(), MoveAllGameObjectsInMoveList(), HostileReference::next(), resetMarkedCells(), resetMarkedCellsLarge(), ScriptsProcess(), SendObjectUpdates(), sScriptMgr, Object::ToCreature(), Object::ToDynObject(), TaskScheduler::Update(), DynamicMapTree::update(), MotionTransport::Update(), WorldSession::Update(), Player::Update(), VisitNearbyCellsOf(), and VisitNearbyCellsOfPlayer().

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

◆ UpdateActiveCells()

void Map::UpdateActiveCells	(	const float &	x,
		const float &	y,
		const uint32	t_diff
	)

private

◆ 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(), Spell::finish(), instance_karazhan::instance_karazhan_InstanceMapScript::SetBossState(), boss_majordomo::boss_majordomoAI::SummonedCreatureDies(), and npc_grimstone::npc_grimstoneAI::WaypointReached().

◆ UpdateIteratorBack()

void Map::UpdateIteratorBack ( Player * player )

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

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

Referenced by Player::ResetMap().

◆ Visit()

template<class T , class CONTAINER >

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

inline

{
    const uint32 x = cell.GridX();
    const uint32 y = cell.GridY();
    const uint32 cell_x = cell.CellX();
    const uint32 cell_y = cell.CellY();
 
    if (!cell.NoCreate() || IsGridLoaded(GridCoord(x, y)))
    {
        EnsureGridLoaded(cell);
        getNGrid(x, y)->VisitGrid(cell_x, cell_y, visitor);
    }
}

References Cell::CellX(), Cell::CellY(), EnsureGridLoaded(), getNGrid(), Cell::GridX(), Cell::GridY(), IsGridLoaded(), Cell::NoCreate(), and NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::VisitGrid().

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

◆ VisitNearbyCellsOf()

void Map::VisitNearbyCellsOf	(	WorldObject *	obj,
		TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &	gridVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &	worldVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &	largeGridVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &	largeWorldVisitor
	)

{
    // Check for valid position
    if (!obj->IsPositionValid())
        return;
 
    if (obj->GetGridActivationRange() <= 0.0f) // pussywizard: gameobjects for example are on active lists, but range is equal to 0 (they just prevent grid unloading)
        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
            // don't visit the same cell twice
            uint32 cell_id = (y * TOTAL_NUMBER_OF_CELLS_PER_MAP) + x;
            if (isCellMarked(cell_id))
                continue;
 
            markCell(cell_id);
            CellCoord pair(x, y);
            Cell cell(pair);
            //cell.SetNoCreate(); // in mmaps this is missing
 
            Visit(cell, gridVisitor);
            Visit(cell, worldVisitor);
 
            if (!isCellMarkedLarge(cell_id))
            {
                markCellLarge(cell_id);
                Visit(cell, largeGridVisitor);
                Visit(cell, largeWorldVisitor);
            }
        }
    }
}

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

Referenced by Update(), and VisitNearbyCellsOfPlayer().

◆ VisitNearbyCellsOfPlayer()

void Map::VisitNearbyCellsOfPlayer	(	Player *	player,
		TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &	gridVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &	worldVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, GridTypeMapContainer > &	largeGridVisitor,
		TypeContainerVisitor< Acore::ObjectUpdater, WorldTypeMapContainer > &	largeWorldVisitor
	)

{
    // check for valid position
    if (!player->IsPositionValid())
        return;
 
    // check normal grid activation range of the player
    VisitNearbyCellsOf(player, gridVisitor, worldVisitor, largeGridVisitor, largeWorldVisitor);
 
    // check maximum visibility distance for large creatures
    CellArea area = Cell::CalculateCellArea(player->GetPositionX(), player->GetPositionY(), MAX_VISIBILITY_DISTANCE);
 
    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
            // don't visit the same cell twice
            uint32 cell_id = (y * TOTAL_NUMBER_OF_CELLS_PER_MAP) + x;
            if (isCellMarkedLarge(cell_id))
                continue;
 
            markCellLarge(cell_id);
            CellCoord pair(x, y);
            Cell cell(pair);
 
            Visit(cell, largeGridVisitor);
            Visit(cell, largeWorldVisitor);
        }
    }
}

References Cell::CalculateCellArea(), Position::GetPositionX(), Position::GetPositionY(), CellArea::high_bound, isCellMarkedLarge(), Position::IsPositionValid(), CellArea::low_bound, markCellLarge(), MAX_VISIBILITY_DISTANCE, TOTAL_NUMBER_OF_CELLS_PER_MAP, Visit(), VisitNearbyCellsOf(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by Update().

Friends And Related Function Documentation

◆ MapReference

friend class MapReference

friend

Member Data Documentation

◆ _corpseBones

std::unordered_set<Corpse*> Map::_corpseBones

private

Referenced by AddCorpse(), RemoveCorpse(), RemoveOldCorpses(), and UnloadAll().

◆ _corpsesByCell

std::unordered_map<uint32, std::unordered_set<Corpse*> > Map::_corpsesByCell

private

Referenced by AddCorpse(), GetCorpsesInCell(), RemoveCorpse(), and UnloadAll().

◆ _corpsesByPlayer

std::unordered_map<ObjectGuid, Corpse*> Map::_corpsesByPlayer

private

Referenced by AddCorpse(), GetCorpseByPlayer(), RemoveCorpse(), RemoveOldCorpses(), and UnloadAll().

◆ _creatureBySpawnIdStore

CreatureBySpawnIdContainer Map::_creatureBySpawnIdStore

private

Referenced by GetCreatureBySpawnIdStore(), and ScriptsProcess().

ZoneDynamicInfoMap Map::_zoneDynamicInfo

private

Referenced by SendZoneDynamicInfo(), SetZoneMusic(), SetZoneOverrideLight(), and SetZoneWeather().

◆ CreatureGroupHolder

CreatureGroupHolderType Map::CreatureGroupHolder

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ActiveNonPlayers

◆ CreatureBySpawnIdContainer

◆ GameObjectBySpawnIdContainer

◆ PlayerList

◆ ScriptScheduleMap

Member Enumeration Documentation

◆ EnterState

Constructor & Destructor Documentation

◆ Map()

◆ ~Map()

Member Function Documentation

◆ _FindGameObject()

◆ _GetScriptCreature()

◆ _GetScriptCreatureSourceOrTarget()

◆ _GetScriptPlayer()

◆ _GetScriptPlayerSourceOrTarget()

◆ _GetScriptUnit()

◆ _GetScriptWorldObject()

◆ _ScriptProcessDoor()

◆ AddCorpse()

◆ AddCreatureToMoveList()

◆ AddDynamicObjectToMoveList()

◆ AddGameObjectToMoveList()

◆ AddObjectToRemoveList()

◆ AddObjectToSwitchList()

◆ AddPlayerToMap()

◆ AddToActive() [1/4]

◆ AddToActive() [2/4]

◆ AddToActive() [3/4]

◆ AddToActive() [4/4]

◆ AddToActiveHelper()

◆ AddToGrid() [1/5]

◆ AddToGrid() [2/5]

◆ AddToGrid() [3/5]

◆ AddToGrid() [4/5]

◆ AddToGrid() [5/5]

◆ AddToMap() [1/2]

◆ AddToMap() [2/2]

◆ AddUpdateObject()

◆ AddWorldObject()

◆ AfterPlayerUnlinkFromMap()

◆ AllTransportsEmpty()

◆ AllTransportsRemovePassengers()

◆ Balance()

◆ buildNGridLinkage()

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

◆ EnsureGridCreated_i()

◆ EnsureGridLoaded()

◆ ExistMap()

◆ ExistVMap()

◆ GameObjectRelocation()