#include "MapInstanced.h"

Inheritance diagram for MapInstanced:

Public Types
using	InstancedMaps = std::unordered_map< uint32, Map * >

Public Types inherited from Map
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
	MapInstanced (uint32 id)

	~MapInstanced () override

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

void	DelayedUpdate (const uint32 diff) override

void	UnloadAll () override

EnterState	CannotEnter (Player *player, bool loginCheck=false) override

Map *	CreateInstanceForPlayer (const uint32 mapId, Player *player)

Map *	FindInstanceMap (uint32 instanceId) const

bool	DestroyInstance (InstancedMaps::iterator &itr)

InstancedMaps &	GetInstancedMaps ()

void	InitVisibilityDistance () override

Public Member Functions inherited from Map
	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	IsWorldMap () 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. More...

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

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

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

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)

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

Private Member Functions
InstanceMap *	CreateInstance (uint32 InstanceId, InstanceSave *save, Difficulty difficulty)

BattlegroundMap *	CreateBattleground (uint32 InstanceId, Battleground *bg)

Private Attributes
InstancedMaps	m_InstancedMaps

Friends
class	MapMgr

Additional Inherited Members
Static Public Member Functions inherited from Map
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 inherited from Map
std::unordered_set< Unit * >	i_objectsForDelayedVisibility

CreatureGroupHolderType	CreatureGroupHolder

TaskScheduler	_creatureRespawnScheduler

DataMap	CustomData

Protected Types inherited from Map
typedef std::set< WorldObject * >	ActiveNonPlayers

Protected Attributes inherited from Map
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

Detailed Description

Member Typedef Documentation

◆ InstancedMaps

using MapInstanced::InstancedMaps = std::unordered_map<uint32, Map*>

Constructor & Destructor Documentation

◆ MapInstanced()

MapInstanced::MapInstanced ( uint32 id )

                                    : Map(id, 0, DUNGEON_DIFFICULTY_NORMAL)
{
    // initialize instanced maps list
    m_InstancedMaps.clear();
}

References m_InstancedMaps.

◆ ~MapInstanced()

MapInstanced::~MapInstanced ( )

inlineoverride

32{}

Member Function Documentation

◆ CannotEnter()

Map::EnterState MapInstanced::CannotEnter	(	Player *	player,
		bool	loginCheck = `false`
	)

overridevirtual

Reimplemented from Map.

{
    //ABORT();
    return CAN_ENTER;
}

References Map::CAN_ENTER.

◆ CreateBattleground()

BattlegroundMap * MapInstanced::CreateBattleground	(	uint32	InstanceId,
		Battleground *	bg
	)

private

{
    // load/create a map
    std::lock_guard<std::mutex> guard(Lock);
 
    LOG_DEBUG("maps", "MapInstanced::CreateBattleground: map bg {} for {} created.", InstanceId, GetId());
 
    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), bg->GetMinLevel());
 
    uint8 spawnMode;
 
    if (bracketEntry)
        spawnMode = bracketEntry->difficulty;
    else
        spawnMode = REGULAR_DIFFICULTY;
 
    BattlegroundMap* map = new BattlegroundMap(GetId(), InstanceId, this, spawnMode);
    ASSERT(map->IsBattlegroundOrArena());
    map->SetBG(bg);
    bg->SetBgMap(map);
 
    m_InstancedMaps[InstanceId] = map;
    return map;
}

References ASSERT, PvPDifficultyEntry::difficulty, GetBattlegroundBracketByLevel(), Map::GetId(), Battleground::GetMapId(), Battleground::GetMinLevel(), Map::IsBattlegroundOrArena(), Map::Lock, LOG_DEBUG, m_InstancedMaps, REGULAR_DIFFICULTY, BattlegroundMap::SetBG(), and Battleground::SetBgMap().

Referenced by CreateInstanceForPlayer().

◆ CreateInstance()

InstanceMap * MapInstanced::CreateInstance	(	uint32	InstanceId,
		InstanceSave *	save,
		Difficulty	difficulty
	)

private

{
    // load/create a map
    std::lock_guard<std::mutex> guard(Lock);
 
    // make sure we have a valid map id
    MapEntry const* entry = sMapStore.LookupEntry(GetId());
    if (!entry)
    {
        LOG_ERROR("maps", "CreateInstance: no entry for map {}", GetId());
        ABORT();
    }
    InstanceTemplate const* iTemplate = sObjectMgr->GetInstanceTemplate(GetId());
    if (!iTemplate)
    {
        LOG_ERROR("maps", "CreateInstance: no instance template for map {}", GetId());
        ABORT();
    }
 
    // some instances only have one difficulty
    GetDownscaledMapDifficultyData(GetId(), difficulty);
 
    LOG_DEBUG("maps", "MapInstanced::CreateInstance: {} map instance {} for {} created with difficulty {}", save ? "" : "new ", InstanceId, GetId(), difficulty ? "heroic" : "normal");
 
    InstanceMap* map = new InstanceMap(GetId(), InstanceId, difficulty, this);
    ASSERT(map->IsDungeon());
 
    map->LoadRespawnTimes();
    map->LoadCorpseData();
 
    if (save)
        map->CreateInstanceScript(true, save->GetInstanceData(), save->GetCompletedEncounterMask());
    else
        map->CreateInstanceScript(false, "", 0);
 
    if (!save) // this is for sure a dungeon (assert above), no need to check here
        sInstanceSaveMgr->AddInstanceSave(GetId(), InstanceId, difficulty);
 
    m_InstancedMaps[InstanceId] = map;
    return map;
}

References ABORT, ASSERT, InstanceMap::CreateInstanceScript(), InstanceSave::GetCompletedEncounterMask(), GetDownscaledMapDifficultyData(), Map::GetId(), InstanceSave::GetInstanceData(), Map::IsDungeon(), Map::LoadCorpseData(), Map::LoadRespawnTimes(), Map::Lock, LOG_DEBUG, LOG_ERROR, m_InstancedMaps, sInstanceSaveMgr, sMapStore, and sObjectMgr.

Referenced by CreateInstanceForPlayer().

◆ CreateInstanceForPlayer()

Map * MapInstanced::CreateInstanceForPlayer	(	const uint32	mapId,
		Player *	player
	)

{
    if (GetId() != mapId || !player)
        return nullptr;
 
    Map* map = nullptr;
 
    if (IsBattlegroundOrArena())
    {
        // instantiate or find existing bg map for player
        // the instance id is set in battlegroundid
        uint32 newInstanceId = player->GetBattlegroundId();
        if (!newInstanceId)
            return nullptr;
 
        map = sMapMgr->FindMap(mapId, newInstanceId);
        if (!map)
        {
            Battleground* bg = player->GetBattleground(true);
            if (bg && bg->GetStatus() < STATUS_WAIT_LEAVE)
                map = CreateBattleground(newInstanceId, bg);
            else
            {
                player->TeleportToEntryPoint();
                return nullptr;
            }
        }
    }
    else
    {
        Difficulty realdiff = player->GetDifficulty(IsRaid());
        uint32 destInstId = sInstanceSaveMgr->PlayerGetDestinationInstanceId(player, GetId(), realdiff);
 
        if (destInstId)
        {
            InstanceSave* pSave = sInstanceSaveMgr->GetInstanceSave(destInstId);
            ASSERT(pSave); // pussywizard: must exist
 
            map = FindInstanceMap(destInstId);
            if (!map)
                map = CreateInstance(destInstId, pSave, realdiff);
            else if (IsSharedDifficultyMap(mapId) && !map->HavePlayers() && map->GetDifficulty() != realdiff)
            {
                if (player->isBeingLoaded()) // pussywizard: crashfix (assert(passengers.empty) fail in ~transport), could be added to a transport during loading from db
                    return nullptr;
 
                if (!map->AllTransportsEmpty())
                    map->AllTransportsRemovePassengers(); // pussywizard: gameobjects / summons (assert(passengers.empty) fail in ~transport)
 
                for (InstancedMaps::iterator i = m_InstancedMaps.begin(); i != m_InstancedMaps.end(); ++i)
                    if (i->first == destInstId)
                    {
                        DestroyInstance(i);
                        map = CreateInstance(destInstId, pSave, realdiff);
                        break;
                    }
            }
        }
        else
        {
            uint32 newInstanceId = sMapMgr->GenerateInstanceId();
            ASSERT(!FindInstanceMap(newInstanceId)); // pussywizard: instance with new id can't exist
            Difficulty diff = player->GetGroup() ? player->GetGroup()->GetDifficulty(IsRaid()) : player->GetDifficulty(IsRaid());
            map = CreateInstance(newInstanceId, nullptr, diff);
        }
    }
 
    return map;
}

References Map::AllTransportsEmpty(), Map::AllTransportsRemovePassengers(), ASSERT, CreateBattleground(), CreateInstance(), DestroyInstance(), FindInstanceMap(), Player::GetBattleground(), Player::GetBattlegroundId(), Map::GetDifficulty(), Player::GetDifficulty(), Group::GetDifficulty(), Player::GetGroup(), Map::GetId(), Battleground::GetStatus(), Map::HavePlayers(), Map::IsBattlegroundOrArena(), Player::isBeingLoaded(), Map::IsRaid(), IsSharedDifficultyMap(), m_InstancedMaps, sInstanceSaveMgr, sMapMgr, STATUS_WAIT_LEAVE, and Player::TeleportToEntryPoint().

◆ DelayedUpdate()

void MapInstanced::DelayedUpdate ( const uint32 diff )

overridevirtual

Reimplemented from Map.

{
    for (InstancedMaps::iterator i = m_InstancedMaps.begin(); i != m_InstancedMaps.end(); ++i)
        i->second->DelayedUpdate(diff);
 
    Map::DelayedUpdate(diff); // this may be removed
}

References Map::DelayedUpdate(), and m_InstancedMaps.

◆ DestroyInstance()

bool MapInstanced::DestroyInstance ( InstancedMaps::iterator & itr )

{
    itr->second->RemoveAllPlayers();
 
    if (itr->second->HavePlayers())
    {
        ++itr;
        return false;
    }
 
    sScriptMgr->OnDestroyInstance(this, itr->second);
 
    itr->second->UnloadAll();
 
    // erase map
    delete itr->second;
    m_InstancedMaps.erase(itr++);
 
    return true;
}

References m_InstancedMaps, and sScriptMgr.

Referenced by CreateInstanceForPlayer(), and Update().

◆ FindInstanceMap()

Map * MapInstanced::FindInstanceMap ( uint32 instanceId ) const

inline

    {
        InstancedMaps::const_iterator i = m_InstancedMaps.find(instanceId);
        return(i == m_InstancedMaps.end() ? nullptr : i->second);
    }

References m_InstancedMaps.

Referenced by CreateInstanceForPlayer().

◆ GetInstancedMaps()

InstancedMaps & MapInstanced::GetInstancedMaps ( )

inline

49{ return m_InstancedMaps; }

References m_InstancedMaps.

◆ InitVisibilityDistance()

void MapInstanced::InitVisibilityDistance ( )

overridevirtual

Reimplemented from Map.

{
    if (m_InstancedMaps.empty())
        return;
    //initialize visibility distances for all instance copies
    for (InstancedMaps::iterator i = m_InstancedMaps.begin(); i != m_InstancedMaps.end(); ++i)
    {
        (*i).second->InitVisibilityDistance();
    }
}

References m_InstancedMaps.

◆ UnloadAll()

void MapInstanced::UnloadAll ( )

overridevirtual

Reimplemented from Map.

{
    // Unload instanced maps
    for (InstancedMaps::iterator i = m_InstancedMaps.begin(); i != m_InstancedMaps.end(); ++i)
        i->second->UnloadAll();
 
    // Delete the maps only after everything is unloaded to prevent crashes
    for (InstancedMaps::iterator i = m_InstancedMaps.begin(); i != m_InstancedMaps.end(); ++i)
        delete i->second;
 
    m_InstancedMaps.clear();
 
    // Unload own grids (just dummy(placeholder) grids, neccesary to unload GridMaps!)
    Map::UnloadAll();
}

References m_InstancedMaps, and Map::UnloadAll().

◆ Update()

void MapInstanced::Update	(	const uint32	t,
		const uint32	s_diff,
		bool	thread = `true`
	)

overridevirtual

Reimplemented from Map.

{
    // take care of loaded GridMaps (when unused, unload it!)
    Map::Update(t, s_diff, false);
 
    // update the instanced maps
    InstancedMaps::iterator i = m_InstancedMaps.begin();
 
    while (i != m_InstancedMaps.end())
    {
        if (i->second->CanUnload(t))
        {
            if (!DestroyInstance(i))                             // iterator incremented
            {
                //m_unloadTimer
            }
        }
        else
        {
            // update only here, because it may schedule some bad things before delete
            if (sMapMgr->GetMapUpdater()->activated())
                sMapMgr->GetMapUpdater()->schedule_update(*i->second, t, s_diff);
            else
                i->second->Update(t, s_diff);
            ++i;
        }
    }
}

References DestroyInstance(), m_InstancedMaps, sMapMgr, and Map::Update().

Friends And Related Function Documentation

◆ MapMgr

friend class MapMgr

friend

Member Data Documentation

◆ m_InstancedMaps

InstancedMaps MapInstanced::m_InstancedMaps

private

Referenced by CreateBattleground(), CreateInstance(), CreateInstanceForPlayer(), DelayedUpdate(), DestroyInstance(), FindInstanceMap(), GetInstancedMaps(), InitVisibilityDistance(), MapInstanced(), UnloadAll(), and Update().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ InstancedMaps

Constructor & Destructor Documentation

◆ MapInstanced()

◆ ~MapInstanced()

Member Function Documentation

◆ CannotEnter()

◆ CreateBattleground()

◆ CreateInstance()

◆ CreateInstanceForPlayer()

◆ DelayedUpdate()

◆ DestroyInstance()

◆ FindInstanceMap()

◆ GetInstancedMaps()

◆ InitVisibilityDistance()

◆ UnloadAll()

◆ Update()

Friends And Related Function Documentation

◆ MapMgr

Member Data Documentation

◆ m_InstancedMaps