MapMgr Class Reference

#include "MapMgr.h"

Public Member Functions
Map *	CreateBaseMap (uint32 mapId)
Map *	FindBaseNonInstanceMap (uint32 mapId) const
Map *	CreateMap (uint32 mapId, Player *player)
Map *	FindMap (uint32 mapId, uint32 instanceId) const
Map *	FindBaseMap (uint32 mapId) const
uint32	GetAreaId (uint32 phaseMask, uint32 mapid, float x, float y, float z) const
uint32	GetAreaId (uint32 phaseMask, uint32 mapid, Position const &pos) const
uint32	GetAreaId (uint32 phaseMask, WorldLocation const &loc) const
uint32	GetZoneId (uint32 phaseMask, uint32 mapid, float x, float y, float z) const
uint32	GetZoneId (uint32 phaseMask, uint32 mapid, Position const &pos) const
uint32	GetZoneId (uint32 phaseMask, WorldLocation const &loc) const
void	GetZoneAndAreaId (uint32 phaseMask, uint32 &zoneid, uint32 &areaid, uint32 mapid, float x, float y, float z)
void	Initialize (void)
void	Update (uint32)
void	SetMapUpdateInterval (uint32 t)
void	UnloadAll ()

Static Public Member Functions
static MapMgr *	instance ()
static bool	ExistMapAndVMap (uint32 mapid, float x, float y)
static bool	IsValidMAP (uint32 mapid, bool startUp)
static bool	IsValidMapCoord (uint32 mapid, Position const &pos)
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)
static float	NormalizeOrientation (float o)

GetInstanceIDs
Returns vector of instance IDs
typedef std::unordered_map< uint32, Map * >	MapMapType
typedef std::vector< bool >	InstanceIds
std::mutex	Lock
MapMapType	i_maps
IntervalTimer	i_timer [4]
uint8	mapUpdateStep
InstanceIds	_instanceIds
uint32	_nextInstanceId
MapUpdater	m_updater
std::vector< bool >	GetInstanceIDs ()
void	DoDelayedMovesAndRemoves ()
Map::EnterState	PlayerCannotEnter (uint32 mapid, Player *player, bool loginCheck=false)
void	InitializeVisibilityDistanceInfo ()
void	GetNumInstances (uint32 &dungeons, uint32 &battlegrounds, uint32 &arenas)
void	GetNumPlayersInInstances (uint32 &dungeons, uint32 &battlegrounds, uint32 &arenas, uint32 &spectators)
void	InitInstanceIds ()
void	RegisterInstanceId (uint32 instanceId)
uint32	GenerateInstanceId ()
MapUpdater *	GetMapUpdater ()
template<typename Worker >
void	DoForAllMaps (Worker &&worker)
template<typename Worker >
void	DoForAllMapsWithMapId (uint32 mapId, Worker &&worker)
	MapMgr ()
	~MapMgr ()
	MapMgr (const MapMgr &)
MapMgr &	operator= (const MapMgr &)

Detailed Description

Member Typedef Documentation

InstanceIds

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

private

MapMapType

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

private

Constructor & Destructor Documentation

MapMgr() [1/2]

MapMgr::MapMgr ( )

private

{
    i_timer[3].SetInterval(sWorld->getIntConfig(CONFIG_INTERVAL_MAPUPDATE));
    mapUpdateStep = 0;
    _nextInstanceId = 0;
}

References _nextInstanceId, CONFIG_INTERVAL_MAPUPDATE, i_timer, mapUpdateStep, IntervalTimer::SetInterval(), and sWorld.

~MapMgr()

MapMgr::~MapMgr ( )

private

{
}

MapMgr() [2/2]

MapMgr::MapMgr ( const MapMgr &  )

private

Member Function Documentation

CreateBaseMap()

Map * MapMgr::CreateBaseMap

(

uint32

mapId

)

{
    Map* map = FindBaseMap(id);
 
    if (!map)
    {
        std::lock_guard<std::mutex> guard(Lock);
 
        map = FindBaseMap(id);
        if (!map) // pussywizard: check again after acquiring mutex
        {
            MapEntry const* entry = sMapStore.LookupEntry(id);
            ASSERT(entry);
 
            if (entry->Instanceable())
                map = new MapInstanced(id);
            else
                map = new Map(id, 0, REGULAR_DIFFICULTY);
 
            i_maps[id] = map;
 
            if (!entry->Instanceable())
            {
                map->LoadRespawnTimes();
                map->LoadCorpseData();
            }
 
            map->OnCreateMap();
        }
    }
 
    ASSERT(map);
    return map;
}

References ASSERT, FindBaseMap(), i_maps, MapEntry::Instanceable(), Map::LoadCorpseData(), Map::LoadRespawnTimes(), Lock, Map::OnCreateMap(), REGULAR_DIFFICULTY, and sMapStore.

Referenced by CreateMap(), GetAreaId(), GetZoneAndAreaId(), and GetZoneId().

CreateMap()

Map * MapMgr::CreateMap	(	uint32	mapId,
		Player *	player
	)

{
    Map* m = CreateBaseMap(id);
 
    if (m && m->Instanceable())
        m = ((MapInstanced*)m)->CreateInstanceForPlayer(id, player);
 
    return m;
}

References CreateBaseMap(), and Map::Instanceable().

DoDelayedMovesAndRemoves()

void MapMgr::DoDelayedMovesAndRemoves

(

)

{
}

DoForAllMaps()

template<typename Worker >

void MapMgr::DoForAllMaps

(

Worker &&

worker

)

{
    std::lock_guard<std::mutex> guard(Lock);
 
    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);
    }
}

References i_maps, Lock, and Map::ToMapInstanced().

DoForAllMapsWithMapId()

template<typename Worker >

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

inline

{
    std::lock_guard<std::mutex> guard(Lock);
 
    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);
    }
}

References i_maps, Lock, and Map::ToMapInstanced().

ExistMapAndVMap()

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

static

{
    GridCoord p = Acore::ComputeGridCoord(x, y);
    return GridTerrainLoader::ExistMap(mapid, p.x_coord, p.y_coord) && GridTerrainLoader::ExistVMap(mapid, p.x_coord, p.y_coord);
}

References Acore::ComputeGridCoord(), GridTerrainLoader::ExistMap(), GridTerrainLoader::ExistVMap(), CoordPair< LIMIT >::x_coord, and CoordPair< LIMIT >::y_coord.

Referenced by World::SetInitialWorldSettings().

FindBaseMap()

Map * MapMgr::FindBaseMap ( uint32  mapId ) const

inline

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

References i_maps.

Referenced by CreateBaseMap(), FindBaseNonInstanceMap(), and FindMap().

FindBaseNonInstanceMap()

Map * MapMgr::FindBaseNonInstanceMap

(

uint32

mapId

)

const

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

References FindBaseMap(), and Map::Instanceable().

FindMap()

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

{
    Map* map = FindBaseMap(mapid);
    if (!map)
        return nullptr;
 
    if (!map->Instanceable())
        return instanceId == 0 ? map : nullptr;
 
    return ((MapInstanced*)map)->FindInstanceMap(instanceId);
}

References FindBaseMap(), and Map::Instanceable().

GenerateInstanceId()

uint32 MapMgr::GenerateInstanceId

(

)

{
    uint32 newInstanceId = _nextInstanceId;
 
    // find the lowest available id starting from the current _nextInstanceId
    while (_nextInstanceId < 0xFFFFFFFF && ++_nextInstanceId < _instanceIds.size() && _instanceIds[_nextInstanceId]);
 
    if (_nextInstanceId == 0xFFFFFFFF)
    {
        LOG_ERROR("server.worldserver", "Instance ID overflow!! Can't continue, shutting down server. ");
        World::StopNow(ERROR_EXIT_CODE);
    }
 
    return newInstanceId;
}

References _instanceIds, _nextInstanceId, ERROR_EXIT_CODE, LOG_ERROR, and World::StopNow().

GetAreaId() [1/3]

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

inline

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

References CreateBaseMap(), and Map::GetAreaId().

GetAreaId() [2/3]

uint32 MapMgr::GetAreaId ( uint32  phaseMask, uint32  mapid, Position const &  pos  ) const

inline

{ return GetAreaId(phaseMask, mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()); }

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

Referenced by GetAreaId().

GetAreaId() [3/3]

uint32 MapMgr::GetAreaId ( uint32  phaseMask, WorldLocation const &  loc  ) const

inline

{ return GetAreaId(phaseMask, loc.GetMapId(), loc); }

References GetAreaId(), and WorldLocation::GetMapId().

Referenced by GetAreaId().

GetInstanceIDs()

std::vector< bool > MapMgr::GetInstanceIDs ( )

inline

    {
        return _instanceIds;
    }

References _instanceIds.

GetMapUpdater()

MapUpdater * MapMgr::GetMapUpdater ( )

inline

{ return &m_updater; }

References m_updater.

GetNumInstances()

void MapMgr::GetNumInstances	(	uint32 &	dungeons,
		uint32 &	battlegrounds,
		uint32 &	arenas
	)

{
    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()) dungeons++;
            else if (mitr->second->IsBattleground()) battlegrounds++;
            else if (mitr->second->IsBattleArena()) arenas++;
        }
    }
}

References i_maps, and Map::Instanceable().

GetNumPlayersInInstances()

void MapMgr::GetNumPlayersInInstances	(	uint32 &	dungeons,
		uint32 &	battlegrounds,
		uint32 &	arenas,
		uint32 &	spectators
	)

{
    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()) dungeons += ((InstanceMap*)mitr->second)->GetPlayers().getSize();
            else if (mitr->second->IsBattleground()) battlegrounds += ((InstanceMap*)mitr->second)->GetPlayers().getSize();
            else if (mitr->second->IsBattleArena())
            {
                uint32 spect = 0;
                if (BattlegroundMap* bgmap = mitr->second->ToBattlegroundMap())
                    if (Battleground* bg = bgmap->GetBG())
                        spect = bg->GetSpectators().size();
 
                arenas += ((InstanceMap*)mitr->second)->GetPlayers().getSize() - spect;
                spectators += spect;
            }
        }
    }
}

References i_maps, Map::Instanceable(), and Map::ToBattlegroundMap().

GetZoneAndAreaId()

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

inline

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

References CreateBaseMap(), and Map::GetZoneAndAreaId().

GetZoneId() [1/3]

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

inline

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

References CreateBaseMap(), and Map::GetZoneId().

GetZoneId() [2/3]

uint32 MapMgr::GetZoneId ( uint32  phaseMask, uint32  mapid, Position const &  pos  ) const

inline

{ return GetZoneId(phaseMask, mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()); }

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

Referenced by GetZoneId().

GetZoneId() [3/3]

uint32 MapMgr::GetZoneId ( uint32  phaseMask, WorldLocation const &  loc  ) const

inline

{ return GetZoneId(phaseMask, loc.GetMapId(), loc); }

References WorldLocation::GetMapId(), and GetZoneId().

Referenced by GetZoneId().

Initialize()

void MapMgr::Initialize

(

void

)

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

References MapUpdater::activate(), CONFIG_NUMTHREADS, m_updater, and sWorld.

InitializeVisibilityDistanceInfo()

void MapMgr::InitializeVisibilityDistanceInfo

(

)

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

References i_maps.

InitInstanceIds()

void MapMgr::InitInstanceIds

(

)

{
    _nextInstanceId = 1;
 
    QueryResult result = CharacterDatabase.Query("SELECT MAX(id) FROM instance");
    if (result)
    {
        uint32 maxId = (*result)[0].Get<uint32>();
        _instanceIds.resize(maxId + 1);
    }
}

References _instanceIds, _nextInstanceId, and CharacterDatabase.

instance()

MapMgr * MapMgr::instance ( )

static

{
    static MapMgr instance;
    return &instance;
}

References instance().

Referenced by instance(), and PlayerCannotEnter().

IsValidMAP()

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

static

Todo:

: add check for battleground template

{
    MapEntry const* mEntry = sMapStore.LookupEntry(mapid);
 
    if (startUp)
    {
        return mEntry != nullptr;
    }
    else
    {
        return mEntry && (!mEntry->IsDungeon() || sObjectMgr->GetInstanceTemplate(mapid));
    }
 
}

References MapEntry::IsDungeon(), sMapStore, and sObjectMgr.

Referenced by IsValidMapCoord(), IsValidMapCoord(), IsValidMapCoord(), and ObjectMgr::LoadInstanceTemplate().

IsValidMapCoord() [1/5]

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

inlinestatic

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

References IsValidMAP(), and Acore::IsValidMapCoord().

IsValidMapCoord() [2/5]

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

inlinestatic

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

References IsValidMAP(), and Acore::IsValidMapCoord().

IsValidMapCoord() [3/5]

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

inlinestatic

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

References IsValidMAP(), and Acore::IsValidMapCoord().

IsValidMapCoord() [4/5]

static bool MapMgr::IsValidMapCoord ( uint32  mapid, Position const &  pos  )

inlinestatic

    {
        return IsValidMapCoord(mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation());
    }

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

Referenced by Player::_LoadHomeBind(), tele_commandscript::DoNameTeleport(), go_commandscript::DoTeleport(), gobject_commandscript::HandleGameObjectMoveCommand(), go_commandscript::HandleGoGraveyardCommand(), go_commandscript::HandleGoGridCommand(), go_commandscript::HandleGoXYZCommand(), go_commandscript::HandleGoZoneXYCommand(), WorldSession::HandleMoveWorldportAck(), IsValidMapCoord(), IsValidMapCoord(), ObjectMgr::LoadGameobjects(), ObjectMgr::LoadGameTele(), ObjectMgr::LoadPlayerInfo(), and Player::TeleportTo().

IsValidMapCoord() [5/5]

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

inlinestatic

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

References WorldLocation::GetMapId(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), and IsValidMapCoord().

NormalizeOrientation()

static float MapMgr::NormalizeOrientation ( float  o )

inlinestatic

    {
        // fmod only supports positive numbers. Thus we have
        // to emulate negative numbers
        if (o < 0)
        {
            float mod = o * -1;
            mod = std::fmod(mod, 2.0f * static_cast<float>(M_PI));
            mod = -mod + 2.0f * static_cast<float>(M_PI);
            return mod;
        }
        return std::fmod(o, 2.0f * static_cast<float>(M_PI));
    }

operator=()

MapMgr & MapMgr::operator= ( const MapMgr &  )

private

PlayerCannotEnter()

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

Todo:

: this is not a good place to send the message

{
    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->GetDifficulty(entry->IsRaid());
    // Get the highest available difficulty if current setting is higher than the instance allows
    MapDifficulty const* mapDiff = GetDownscaledMapDifficultyData(entry->MapID, targetDifficulty);
    if (!mapDiff)
    {
        player->SendTransferAborted(mapid, TRANSFER_ABORT_DIFFICULTY, requestedDifficulty);
        return Map::CANNOT_ENTER_DIFFICULTY_UNAVAILABLE;
    }
 
    //Bypass checks for GMs
    if (player->IsGameMaster())
        return Map::CAN_ENTER;
 
    char const* mapName = entry->name[player->GetSession()->GetSessionDbcLocale()];
 
    if (!sScriptMgr->OnPlayerCanEnterMap(player, entry, instance, mapDiff, loginCheck))
        return Map::CANNOT_ENTER_UNSPECIFIED_REASON;
 
    Group* group = player->GetGroup();
    if (entry->IsRaid())
    {
        // can only enter in a raid group
        if ((!group || !group->isRaidGroup()) && !sWorld->getBoolConfig(CONFIG_INSTANCE_IGNORE_RAID))
        {
            // probably there must be special opcode, because client has this string constant in GlobalStrings.lua
            player->GetSession()->SendAreaTriggerMessage(LANG_INSTANCE_RAID_GROUP_ONLY, mapName);
            LOG_DEBUG("maps", "MAP: Player '{}' must be in a raid group to enter instance '{}'", player->GetName(), mapName);
            return Map::CANNOT_ENTER_NOT_IN_RAID;
        }
    }
 
    // xinef: dont allow LFG Group to enter other instance that is selected
    if (group)
        if (group->isLFGGroup())
            if (!sLFGMgr->inLfgDungeonMap(group->GetGUID(), mapid, targetDifficulty))
            {
                player->SendTransferAborted(mapid, TRANSFER_ABORT_MAP_NOT_ALLOWED);
                return Map::CANNOT_ENTER_UNSPECIFIED_REASON;
            }
 
    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)
            {
                WorldPacket data(SMSG_CORPSE_NOT_IN_INSTANCE, 0);
                player->GetSession()->SendPacket(&data);
                LOG_DEBUG("maps", "MAP: Player '{}' does not have a corpse in instance '{}' and cannot enter.", player->GetName(), mapName);
                return Map::CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE;
            }
            LOG_DEBUG("maps", "MAP: Player '{}' has corpse in instance '{}' and can enter.", player->GetName(), mapName);
        }
        else
        {
            LOG_DEBUG("maps", "Map::PlayerCannotEnter - player '{}' is dead but does not have a corpse!", player->GetName());
            return Map::CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE;
        }
    }
 
    // if map exists - check for being full, etc.
    if (!loginCheck) // for login this is done by the calling function
    {
        uint32 destInstId = sInstanceSaveMgr->PlayerGetDestinationInstanceId(player, mapid, targetDifficulty);
        if (destInstId)
            if (Map* boundMap = sMapMgr->FindMap(mapid, destInstId))
                if (Map::EnterState denyReason = boundMap->CannotEnter(player, loginCheck))
                    return denyReason;
    }
 
    // players are only allowed to enter 5 instances per hour
    if (entry->IsNonRaidDungeon() && (!group || !group->isLFGGroup() || !group->IsLfgRandomInstance()))
    {
        uint32 instaceIdToCheck = 0;
        if (InstanceSave* save = sInstanceSaveMgr->PlayerGetInstanceSave(player->GetGUID(), mapid, player->GetDifficulty(entry->IsRaid())))
            instaceIdToCheck = save->GetInstanceId();
 
        // instaceIdToCheck can be 0 if save not found - means no bind so the instance is new
        if (!player->CheckInstanceCount(instaceIdToCheck))
        {
            player->SendTransferAborted(mapid, TRANSFER_ABORT_TOO_MANY_INSTANCES);
            return Map::CANNOT_ENTER_TOO_MANY_INSTANCES;
        }
    }
 
    //Other requirements
    return player->Satisfy(sObjectMgr->GetAccessRequirement(mapid, targetDifficulty), mapid, true) ? Map::CAN_ENTER : Map::CANNOT_ENTER_UNSPECIFIED_REASON;
}

References Map::CAN_ENTER, Map::CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE, Map::CANNOT_ENTER_DIFFICULTY_UNAVAILABLE, Map::CANNOT_ENTER_NO_ENTRY, Map::CANNOT_ENTER_NOT_IN_RAID, Map::CANNOT_ENTER_TOO_MANY_INSTANCES, Map::CANNOT_ENTER_UNINSTANCED_DUNGEON, Map::CANNOT_ENTER_UNSPECIFIED_REASON, Player::CheckInstanceCount(), CONFIG_INSTANCE_IGNORE_RAID, Player::GetCorpseLocation(), Player::GetDifficulty(), GetDownscaledMapDifficultyData(), Player::GetGroup(), Group::GetGUID(), Object::GetGUID(), WorldLocation::GetMapId(), WorldObject::GetName(), Player::GetSession(), WorldSession::GetSessionDbcLocale(), Player::HasCorpse(), instance(), Unit::IsAlive(), MapEntry::IsDungeon(), Player::IsGameMaster(), Group::isLFGGroup(), Group::IsLfgRandomInstance(), MapEntry::IsNonRaidDungeon(), MapEntry::IsRaid(), Group::isRaidGroup(), LANG_INSTANCE_RAID_GROUP_ONLY, LOG_DEBUG, MapEntry::MapID, MapEntry::name, InstanceTemplate::Parent, Player::Satisfy(), WorldSession::SendAreaTriggerMessage(), WorldSession::SendPacket(), Player::SendTransferAborted(), sInstanceSaveMgr, sLFGMgr, sMapMgr, sMapStore, SMSG_CORPSE_NOT_IN_INSTANCE, sObjectMgr, sScriptMgr, sWorld, TRANSFER_ABORT_DIFFICULTY, TRANSFER_ABORT_MAP_NOT_ALLOWED, and TRANSFER_ABORT_TOO_MANY_INSTANCES.

RegisterInstanceId()

void MapMgr::RegisterInstanceId

(

uint32

instanceId

)

{
    // Allocation was done in InitInstanceIds()
    _instanceIds[instanceId] = true;
 
    // Instances are pulled in ascending order from db and _nextInstanceId is initialized with 1,
    // so if the instance id is used, increment
    if (_nextInstanceId == instanceId)
        ++_nextInstanceId;
}

References _instanceIds, and _nextInstanceId.

SetMapUpdateInterval()

void MapMgr::SetMapUpdateInterval ( uint32  t )

inline

    {
        if (t < MIN_MAP_UPDATE_DELAY)
            t = MIN_MAP_UPDATE_DELAY;
 
        i_timer[3].SetInterval(t);
        i_timer[3].Reset();
    }

References i_timer, MIN_MAP_UPDATE_DELAY, IntervalTimer::Reset(), and IntervalTimer::SetInterval().

UnloadAll()

void MapMgr::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();
}

References MapUpdater::activated(), MapUpdater::deactivate(), i_maps, and m_updater.

Update()

void MapMgr::Update

(

uint32

diff

)

{
    for (uint8 i = 0; i < 4; ++i)
        i_timer[i].Update(diff);
 
    // pussywizard: lfg compatibles update, schedule before maps so it is processed from the very beginning
    //if (mapUpdateStep == 0)
    {
        if (m_updater.activated())
        {
            m_updater.schedule_lfg_update(diff);
        }
        else
        {
            sLFGMgr->Update(diff, 1);
        }
    }
 
    MapMapType::iterator iter = i_maps.begin();
    for (; iter != i_maps.end(); ++iter)
    {
        bool full = mapUpdateStep < 3 && ((mapUpdateStep == 0 && !iter->second->IsBattlegroundOrArena() && !iter->second->IsDungeon()) || (mapUpdateStep == 1 && iter->second->IsBattlegroundOrArena()) || (mapUpdateStep == 2 && iter->second->IsDungeon()));
        if (m_updater.activated())
            m_updater.schedule_update(*iter->second, uint32(full ? i_timer[mapUpdateStep].GetCurrent() : 0), diff);
        else
            iter->second->Update(uint32(full ? i_timer[mapUpdateStep].GetCurrent() : 0), diff);
    }
 
    if (m_updater.activated())
        m_updater.wait();
 
    if (mapUpdateStep < 3)
    {
        for (iter = i_maps.begin(); iter != i_maps.end(); ++iter)
        {
            bool full = ((mapUpdateStep == 0 && !iter->second->IsBattlegroundOrArena() && !iter->second->IsDungeon()) || (mapUpdateStep == 1 && iter->second->IsBattlegroundOrArena()) || (mapUpdateStep == 2 && iter->second->IsDungeon()));
            if (full)
                iter->second->DelayedUpdate(uint32(i_timer[mapUpdateStep].GetCurrent()));
        }
 
        i_timer[mapUpdateStep].SetCurrent(0);
        ++mapUpdateStep;
    }
 
    if (mapUpdateStep == 3 && i_timer[3].Passed())
    {
        mapUpdateStep = 0;
        i_timer[3].SetCurrent(0);
    }
}

References MapUpdater::activated(), i_maps, i_timer, m_updater, mapUpdateStep, MapUpdater::schedule_lfg_update(), MapUpdater::schedule_update(), IntervalTimer::SetCurrent(), sLFGMgr, Update(), and MapUpdater::wait().

Referenced by Update().

Member Data Documentation

_instanceIds

InstanceIds MapMgr::_instanceIds

private

Referenced by GenerateInstanceId(), GetInstanceIDs(), InitInstanceIds(), and RegisterInstanceId().

_nextInstanceId

uint32 MapMgr::_nextInstanceId

private

Referenced by GenerateInstanceId(), InitInstanceIds(), MapMgr(), and RegisterInstanceId().

i_maps

MapMapType MapMgr::i_maps

private

Referenced by CreateBaseMap(), DoForAllMaps(), DoForAllMapsWithMapId(), FindBaseMap(), GetNumInstances(), GetNumPlayersInInstances(), InitializeVisibilityDistanceInfo(), UnloadAll(), and Update().

i_timer

IntervalTimer MapMgr::i_timer[4]

private

Referenced by MapMgr(), SetMapUpdateInterval(), and Update().

Lock

std::mutex MapMgr::Lock

private

Referenced by CreateBaseMap(), DoForAllMaps(), and DoForAllMapsWithMapId().

m_updater

MapUpdater MapMgr::m_updater

private

Referenced by GetMapUpdater(), Initialize(), UnloadAll(), and Update().

mapUpdateStep

uint8 MapMgr::mapUpdateStep

private

Referenced by MapMgr(), and Update().

---

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

• azerothcore-wotlk/src/server/game/Maps/MapMgr.h
• azerothcore-wotlk/src/server/game/Maps/MapMgr.cpp