MapManager Class Reference

#include <MapManager.h>

Public Member Functions
Map *	CreateBaseMap (uint32 mapId)
Map *	FindBaseNonInstanceMap (uint32 mapId) const
Map *	CreateMap (uint32 mapId, Player *player, uint32 loginInstanceId=0)
Map *	FindMap (uint32 mapId, uint32 instanceId) const
uint32	GetAreaId (uint32 mapid, float x, float y, float z) const
uint32	GetZoneId (uint32 mapid, float x, float y, float z) const
void	GetZoneAndAreaId (uint32 &zoneid, uint32 &areaid, uint32 mapid, float x, float y, float z)
void	Initialize (void)
void	Update (uint32)
void	SetGridCleanUpDelay (uint32 t)
void	SetMapUpdateInterval (uint32 t)
void	UnloadAll ()
void	DoDelayedMovesAndRemoves ()
Map::EnterState	PlayerCannotEnter (uint32 mapid, Player *player, bool loginCheck=false)
void	InitializeVisibilityDistanceInfo ()
uint32	GetNumInstances ()
uint32	GetNumPlayersInInstances ()
void	InitInstanceIds ()
uint32	GenerateInstanceId ()
void	RegisterInstanceId (uint32 instanceId)
void	FreeInstanceId (uint32 instanceId)
uint32	GetNextInstanceId () const
void	SetNextInstanceId (uint32 nextInstanceId)
MapUpdater *	GetMapUpdater ()
template<typename Worker >
void	DoForAllMaps (Worker &&worker)
template<typename Worker >
void	DoForAllMapsWithMapId (uint32 mapId, Worker &&worker)

Static Public Member Functions
static MapManager *	instance ()
static bool	ExistMapAndVMap (uint32 mapid, float x, float y)
static bool	IsValidMAP (uint32 mapid, bool startUp)
static bool	IsValidMapCoord (uint32 mapid, float x, float y)
static bool	IsValidMapCoord (uint32 mapid, float x, float y, float z)
static bool	IsValidMapCoord (uint32 mapid, float x, float y, float z, float o)
static bool	IsValidMapCoord (WorldLocation const &loc)

Private Types
typedef std::unordered_map < uint32, Map * >	MapMapType
typedef std::vector< bool >	InstanceIds

Private Member Functions
	MapManager ()
	~MapManager ()
Map *	FindBaseMap (uint32 mapId) const
	MapManager (const MapManager &)
MapManager &	operator= (const MapManager &)

Private Attributes
std::mutex	_mapsLock
uint32	i_gridCleanUpDelay
MapMapType	i_maps
IntervalTimer	i_timer
InstanceIds	_instanceIds
uint32	_nextInstanceId
MapUpdater	m_updater

Member Typedef Documentation

typedef std::vector<bool> MapManager::InstanceIds

private

typedef std::unordered_map<uint32, Map*> MapManager::MapMapType

private

Constructor & Destructor Documentation

MapManager::MapManager ( )

private

{
 i_gridCleanUpDelay = sWorld->getIntConfig(CONFIG_INTERVAL_GRIDCLEAN);
 i_timer.SetInterval(sWorld->getIntConfig(CONFIG_INTERVAL_MAPUPDATE));
 _nextInstanceId = 0;
}

Here is the call graph for this function:

MapManager::~MapManager ( )

private

{ }

MapManager::MapManager ( const MapManager &  )

private

Member Function Documentation

Map * MapManager::CreateBaseMap

(

uint32

mapId

)

{
 Map* map = FindBaseMap(id);

 if (map == NULL)
 {
 std::lock_guard<std::mutex> lock(_mapsLock);

 MapEntry const* entry = sMapStore.LookupEntry(id);
 ASSERT(entry);

 if (entry->Instanceable())
 map = new MapInstanced(id, i_gridCleanUpDelay);
 else
 {
 map = new Map(id, i_gridCleanUpDelay, 0, DIFFICULTY_NONE);
 map->LoadRespawnTimes();
 map->LoadCorpseData();
 }

 i_maps[id] = map;
 }

 ASSERT(map);
 return map;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map * MapManager::CreateMap	(	uint32	mapId,
		Player *	player,
		uint32	loginInstanceId = 0
	)

{
 Map* m = CreateBaseMap(id);

 if (m && m->Instanceable())
 m = ((MapInstanced*)m)->CreateInstanceForPlayer(id, player, loginInstanceId);

 return m;
}

Here is the call graph for this function:

void MapManager::DoDelayedMovesAndRemoves

(

)

{ }

template<typename Worker >

void MapManager::DoForAllMaps

(

Worker &&

worker

)

{
 std::lock_guard<std::mutex> lock(_mapsLock);

 for (auto& mapPair : i_maps)
 {
 Map* map = mapPair.second;
 if (MapInstanced* mapInstanced = map->ToMapInstanced())
 {
 MapInstanced::InstancedMaps& instances = mapInstanced->GetInstancedMaps();
 for (auto& instancePair : instances)
 worker(instancePair.second);
 }
 else
 worker(map);
 }
}

Here is the call graph for this function:

template<typename Worker >

void MapManager::DoForAllMapsWithMapId ( uint32  mapId, Worker &&  worker  )

inline

{
 std::lock_guard<std::mutex> lock(_mapsLock);

 auto itr = i_maps.find(mapId);
 if (itr != i_maps.end())
 {
 Map* map = itr->second;
 if (MapInstanced* mapInstanced = map->ToMapInstanced())
 {
 MapInstanced::InstancedMaps& instances = mapInstanced->GetInstancedMaps();
 for (auto& p : instances)
 worker(p.second);
 }
 else
 worker(map);
 }
}

Here is the call graph for this function:

bool MapManager::ExistMapAndVMap ( uint32  mapid, float  x, float  y  )

static

{
 GridCoord p = Trinity::ComputeGridCoord(x, y);

 int gx = (MAX_NUMBER_OF_GRIDS - 1) - p.x_coord;
 int gy = (MAX_NUMBER_OF_GRIDS - 1) - p.y_coord;

 return Map::ExistMap(mapid, gx, gy) && Map::ExistVMap(mapid, gx, gy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map* MapManager::FindBaseMap ( uint32  mapId ) const

inlineprivate

 {
 MapMapType::const_iterator iter = i_maps.find(mapId);
 return (iter == i_maps.end() ? NULL : iter->second);
 }

Here is the caller graph for this function:

Map * MapManager::FindBaseNonInstanceMap

(

uint32

mapId

)

const

{
 Map* map = FindBaseMap(mapId);
 if (map && map->Instanceable())
 return NULL;
 return map;
}

Here is the call graph for this function:

Map * MapManager::FindMap	(	uint32	mapId,
		uint32	instanceId
	)		const

{
 Map* map = FindBaseMap(mapid);
 if (!map)
 return NULL;

 if (!map->Instanceable())
 return instanceId == 0 ? map : NULL;

 return ((MapInstanced*)map)->FindInstanceMap(instanceId);
}

Here is the call graph for this function:

void MapManager::FreeInstanceId

(

uint32

instanceId

)

{
 // If freed instance id is lower than the next id available for new instances, use the freed one instead
 if (instanceId < _nextInstanceId)
 SetNextInstanceId(instanceId);

 _instanceIds[instanceId] = false;
 sAchievementMgr->OnInstanceDestroyed(instanceId);
}

Here is the call graph for this function:

uint32 MapManager::GenerateInstanceId

(

)

{
 uint32 newInstanceId = _nextInstanceId;

 // Find the lowest available id starting from the current NextInstanceId (which should be the lowest according to the logic in FreeInstanceId()
 for (uint32 i = ++_nextInstanceId; i < 0xFFFFFFFF; ++i)
 {
 if ((i < _instanceIds.size() && !_instanceIds[i]) || i >= _instanceIds.size())
 {
 _nextInstanceId = i;
 break;
 }
 }

 if (newInstanceId == _nextInstanceId)
 {
 TC_LOG_ERROR("maps", "Instance ID overflow!! Can't continue, shutting down server. ");
 World::StopNow(ERROR_EXIT_CODE);
 }

 // Allocate space if necessary
 if (newInstanceId >= uint32(_instanceIds.size()))
 {
 // Due to the odd memory allocation behavior of vector<bool> we match size to capacity before triggering a new allocation
 if (_instanceIds.size() < _instanceIds.capacity())
 {
 _instanceIds.resize(_instanceIds.capacity());
 }
 else
 _instanceIds.resize((newInstanceId / 32) * 32 + (newInstanceId % 32 > 0 ? 32 : 0));
 }

 _instanceIds[newInstanceId] = true;

 return newInstanceId;
}

Here is the call graph for this function:

uint32 MapManager::GetAreaId ( uint32  mapid, float  x, float  y, float  z  ) const

inline

 {
 Map const* m = const_cast<MapManager*>(this)->CreateBaseMap(mapid);
 return m->GetAreaId(x, y, z);
 }

Here is the call graph for this function:

MapUpdater* MapManager::GetMapUpdater ( )

inline

{ return &m_updater; }

uint32 MapManager::GetNextInstanceId ( ) const

inline

{ return _nextInstanceId; };

uint32 MapManager::GetNumInstances

(

)

{
 std::lock_guard<std::mutex> lock(_mapsLock);

 uint32 ret = 0;
 for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
 {
 Map* map = itr->second;
 if (!map->Instanceable())
 continue;
 MapInstanced::InstancedMaps &maps = ((MapInstanced*)map)->GetInstancedMaps();
 for (MapInstanced::InstancedMaps::iterator mitr = maps.begin(); mitr != maps.end(); ++mitr)
 if (mitr->second->IsDungeon()) ret++;
 }
 return ret;
}

Here is the call graph for this function:

uint32 MapManager::GetNumPlayersInInstances

(

)

{
 std::lock_guard<std::mutex> lock(_mapsLock);

 uint32 ret = 0;
 for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
 {
 Map* map = itr->second;
 if (!map->Instanceable())
 continue;
 MapInstanced::InstancedMaps &maps = ((MapInstanced*)map)->GetInstancedMaps();
 for (MapInstanced::InstancedMaps::iterator mitr = maps.begin(); mitr != maps.end(); ++mitr)
 if (mitr->second->IsDungeon())
 ret += ((InstanceMap*)mitr->second)->GetPlayers().getSize();
 }
 return ret;
}

Here is the call graph for this function:

void MapManager::GetZoneAndAreaId ( uint32 &  zoneid, uint32 &  areaid, uint32  mapid, float  x, float  y, float  z  )

inline

 {
 Map const* m = const_cast<MapManager*>(this)->CreateBaseMap(mapid);
 m->GetZoneAndAreaId(zoneid, areaid, x, y, z);
 }

Here is the call graph for this function:

uint32 MapManager::GetZoneId ( uint32  mapid, float  x, float  y, float  z  ) const

inline

 {
 Map const* m = const_cast<MapManager*>(this)->CreateBaseMap(mapid);
 return m->GetZoneId(x, y, z);
 }

Here is the call graph for this function:

void MapManager::Initialize

(

void

)

{
 Map::InitStateMachine();

 int num_threads(sWorld->getIntConfig(CONFIG_NUMTHREADS));
 // Start mtmaps if needed.
 if (num_threads > 0)
 m_updater.activate(num_threads);
}

Here is the call graph for this function:

void MapManager::InitializeVisibilityDistanceInfo

(

)

{
 for (MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
 (*iter).second->InitVisibilityDistance();
}

void MapManager::InitInstanceIds

(

)

{
 _nextInstanceId = 1;

 QueryResult result = CharacterDatabase.Query("SELECT MAX(id) FROM instance");
 if (result)
 {
 uint32 maxId = (*result)[0].GetUInt32();

 // Resize to multiples of 32 (vector<bool> allocates memory the same way)
 _instanceIds.resize((maxId / 32) * 32 + (maxId % 32 > 0 ? 32 : 0));
 }
}

Here is the call graph for this function:

MapManager * MapManager::instance ( )

static

{
 static MapManager instance;
 return &instance;
}

Here is the caller graph for this function:

bool MapManager::IsValidMAP ( uint32  mapid, bool  startUp  )

static

Todo:

add check for battleground template

{
 MapEntry const* mEntry = sMapStore.LookupEntry(mapid);

 if (startUp)
 return mEntry ? true : false;
 else
 return mEntry && (!mEntry->IsDungeon() || sObjectMgr->GetInstanceTemplate(mapid));

}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool MapManager::IsValidMapCoord ( uint32  mapid, float  x, float  y  )

inlinestatic

 {
 return IsValidMAP(mapid, false) && Trinity::IsValidMapCoord(x, y);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool MapManager::IsValidMapCoord ( uint32  mapid, float  x, float  y, float  z  )

inlinestatic

 {
 return IsValidMAP(mapid, false) && Trinity::IsValidMapCoord(x, y, z);
 }

Here is the call graph for this function:

static bool MapManager::IsValidMapCoord ( uint32  mapid, float  x, float  y, float  z, float  o  )

inlinestatic

 {
 return IsValidMAP(mapid, false) && Trinity::IsValidMapCoord(x, y, z, o);
 }

Here is the call graph for this function:

static bool MapManager::IsValidMapCoord ( WorldLocation const &  loc )

inlinestatic

 {
 return IsValidMapCoord(loc.GetMapId(), loc.GetPositionX(), loc.GetPositionY(), loc.GetPositionZ(), loc.GetOrientation());
 }

Here is the call graph for this function:

MapManager& MapManager::operator= ( const MapManager &  )

private

Map::EnterState MapManager::PlayerCannotEnter	(	uint32	mapid,
		Player *	player,
		bool	loginCheck = false
	)

{
 MapEntry const* entry = sMapStore.LookupEntry(mapid);
 if (!entry)
 return Map::CANNOT_ENTER_NO_ENTRY;

 if (!entry->IsDungeon())
 return Map::CAN_ENTER;

 InstanceTemplate const* instance = sObjectMgr->GetInstanceTemplate(mapid);
 if (!instance)
 return Map::CANNOT_ENTER_UNINSTANCED_DUNGEON;

 Difficulty targetDifficulty, requestedDifficulty;
 targetDifficulty = requestedDifficulty = player->GetDifficultyID(entry);
 // Get the highest available difficulty if current setting is higher than the instance allows
 MapDifficultyEntry const* mapDiff = GetDownscaledMapDifficultyData(entry->ID, targetDifficulty);
 if (!mapDiff)
 return Map::CANNOT_ENTER_DIFFICULTY_UNAVAILABLE;

 //Bypass checks for GMs
 if (player->IsGameMaster())
 return Map::CAN_ENTER;

 char const* mapName = entry->MapName_lang;

 Group* group = player->GetGroup();
 if (entry->IsRaid()) // can only enter in a raid group
 if ((!group || !group->isRaidGroup()) && !sWorld->getBoolConfig(CONFIG_INSTANCE_IGNORE_RAID))
 return Map::CANNOT_ENTER_NOT_IN_RAID;

 if (!player->IsAlive())
 {
 if (player->HasCorpse())
 {
 // let enter in ghost mode in instance that connected to inner instance with corpse
 uint32 corpseMap = player->GetCorpseLocation().GetMapId();
 do
 {
 if (corpseMap == mapid)
 break;

 InstanceTemplate const* corpseInstance = sObjectMgr->GetInstanceTemplate(corpseMap);
 corpseMap = corpseInstance ? corpseInstance->Parent : 0;
 } while (corpseMap);

 if (!corpseMap)
 return Map::CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE;

 TC_LOG_DEBUG("maps", "MAP: Player '%s' has corpse in instance '%s' and can enter.", player->GetName().c_str(), mapName);
 }
 else
 TC_LOG_DEBUG("maps", "Map::CanPlayerEnter - player '%s' is dead but does not have a corpse!", player->GetName().c_str());
 }

 //Get instance where player's group is bound & its map
 if (!loginCheck && group)
 {
 InstanceGroupBind* boundInstance = group->GetBoundInstance(entry);
 if (boundInstance && boundInstance->save)
 if (Map* boundMap = sMapMgr->FindMap(mapid, boundInstance->save->GetInstanceId()))
 if (Map::EnterState denyReason = boundMap->CannotEnter(player))
 return denyReason;
 }

 // players are only allowed to enter 5 instances per hour
 if (entry->IsDungeon() && (!player->GetGroup() || (player->GetGroup() && !player->GetGroup()->isLFGGroup())))
 {
 uint32 instanceIdToCheck = 0;
 if (InstanceSave* save = player->GetInstanceSave(mapid))
 instanceIdToCheck = save->GetInstanceId();

 // instanceId can never be 0 - will not be found
 if (!player->CheckInstanceCount(instanceIdToCheck) && !player->isDead())
 return Map::CANNOT_ENTER_TOO_MANY_INSTANCES;
 }

 //Other requirements
 if (player->Satisfy(sObjectMgr->GetAccessRequirement(mapid, targetDifficulty), mapid, true))
 return Map::CAN_ENTER;
 else
 return Map::CANNOT_ENTER_UNSPECIFIED_REASON;
}

Here is the call graph for this function:

void MapManager::RegisterInstanceId

(

uint32

instanceId

)

{
 // Allocation and sizing was done in InitInstanceIds()
 _instanceIds[instanceId] = true;
}

void MapManager::SetGridCleanUpDelay ( uint32  t )

inline

 {
 if (t < MIN_GRID_DELAY)
 i_gridCleanUpDelay = MIN_GRID_DELAY;
 else
 i_gridCleanUpDelay = t;
 }

void MapManager::SetMapUpdateInterval ( uint32  t )

inline

 {
 if (t < MIN_MAP_UPDATE_DELAY)
 t = MIN_MAP_UPDATE_DELAY;

 i_timer.SetInterval(t);
 i_timer.Reset();
 }

void MapManager::SetNextInstanceId ( uint32  nextInstanceId )

inline

{ _nextInstanceId = nextInstanceId; };

Here is the caller graph for this function:

void MapManager::UnloadAll

(

)

{
 for (MapMapType::iterator iter = i_maps.begin(); iter != i_maps.end();)
 {
 iter->second->UnloadAll();
 delete iter->second;
 i_maps.erase(iter++);
 }

 if (m_updater.activated())
 m_updater.deactivate();

 Map::DeleteStateMachine();
}

Here is the call graph for this function:

void MapManager::Update

(

uint32

diff

)

{
 i_timer.Update(diff);
 if (!i_timer.Passed())
 return;

 MapMapType::iterator iter = i_maps.begin();
 for (; iter != i_maps.end(); ++iter)
 {
 if (m_updater.activated())
 m_updater.schedule_update(*iter->second, uint32(i_timer.GetCurrent()));
 else
 iter->second->Update(uint32(i_timer.GetCurrent()));
 }
 if (m_updater.activated())
 m_updater.wait();

 for (iter = i_maps.begin(); iter != i_maps.end(); ++iter)
 iter->second->DelayedUpdate(uint32(i_timer.GetCurrent()));

 i_timer.SetCurrent(0);
}

Here is the call graph for this function:

Member Data Documentation

InstanceIds MapManager::_instanceIds

private

std::mutex MapManager::_mapsLock

private

uint32 MapManager::_nextInstanceId

private

uint32 MapManager::i_gridCleanUpDelay

private

MapMapType MapManager::i_maps

private

IntervalTimer MapManager::i_timer

private

MapUpdater MapManager::m_updater

private

---

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

• src/server/game/Maps/MapManager.h
• src/server/game/Maps/MapManager.cpp