#include "Map.h"

Inheritance diagram for InstanceMap:

Public Member Functions
	InstanceMap (uint32 id, uint32 InstanceId, uint8 SpawnMode, Map *_parent)

	~InstanceMap () override

bool	AddPlayerToMap (Player *) override

void	RemovePlayerFromMap (Player *, bool) override

void	AfterPlayerUnlinkFromMap () override

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

void	CreateInstanceScript (bool load, std::string data, uint32 completedEncounterMask)

bool	Reset (uint8 method, GuidList *globalSkipList=nullptr)

uint32	GetScriptId () const

std::string const &	GetScriptName () const

InstanceScript *	GetInstanceScript ()

InstanceScript const *	GetInstanceScript () const

void	PermBindAllPlayers ()

void	UnloadAll () override

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

void	SendResetWarnings (uint32 timeLeft) const

uint32	GetMaxPlayers () const

uint32	GetMaxResetDelay () const

void	InitVisibilityDistance () override

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

template<class T >
bool	AddToMap (T *, bool checkTransport=false)

template<class T >
void	RemoveFromMap (T *, bool)

void	MarkNearbyCellsOf (WorldObject *obj)

float	GetVisibilityRange () const

void	SetVisibilityRange (float range)

void	OnCreateMap ()

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

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

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

void	DynamicObjectRelocation (DynamicObject *go, float x, float y, float z, float o)

template<class T , class CONTAINER >
void	Visit (const Cell &cell, TypeContainerVisitor< T, CONTAINER > &visitor)

bool	IsGridLoaded (GridCoord const &gridCoord) const

bool	IsGridLoaded (float x, float y) const

bool	IsGridCreated (GridCoord const &gridCoord) const

bool	IsGridCreated (float x, float y) const

void	LoadGrid (float x, float y)

void	LoadAllGrids ()

void	LoadGridsInRange (Position const &center, float radius)

bool	UnloadGrid (MapGridType &grid)

std::shared_ptr< GridTerrainData >	GetGridTerrainDataSharedPtr (GridCoord const &gridCoord)

GridTerrainData *	GetGridTerrainData (GridCoord const &gridCoord)

GridTerrainData *	GetGridTerrainData (float x, float y)

uint32	GetId () const

Map const *	GetParent () const

void	HandleDelayedVisibility ()

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

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

float	GetGridHeight (float x, float y) const

float	GetMinHeight (float x, float y) const

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

void	GetFullTerrainStatusForPosition (uint32 phaseMask, float x, float y, float z, float collisionHeight, PositionFullTerrainStatus &data, Optional< uint8 > reqLiquidType={})

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

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

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

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

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

float	GetWaterLevel (float x, float y) const

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

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

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

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

void	MoveAllCreaturesInMoveList ()

void	MoveAllGameObjectsInMoveList ()

void	MoveAllDynamicObjectsInMoveList ()

void	RemoveAllObjectsInRemoveList ()

virtual void	RemoveAllPlayers ()

uint32	GetInstanceId () const

uint8	GetSpawnMode () const

const char *	GetMapName () const

Difficulty	GetDifficulty () const

bool	IsRegularDifficulty () const

MapDifficulty const *	GetMapDifficulty () const

bool	Instanceable () const

bool	IsDungeon () const

bool	IsNonRaidDungeon () const

bool	IsRaid () const

bool	IsRaidOrHeroicDungeon () const

bool	IsHeroic () const

bool	Is25ManRaid () const

bool	IsBattleground () const

bool	IsBattleArena () const

bool	IsBattlegroundOrArena () const

bool	IsWorldMap () const

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

void	AddObjectToRemoveList (WorldObject *obj)

virtual void	DelayedUpdate (const uint32 diff)

void	resetMarkedCells ()

bool	isCellMarked (uint32 pCellId)

void	markCell (uint32 pCellId)

bool	HavePlayers () const

uint32	GetPlayersCountExceptGMs (bool aliveOnly=false) const

void	SendToPlayers (WorldPacket const *data) const

PlayerList const &	GetPlayers () const

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

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

void	UpdateIteratorBack (Player *player)

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

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

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

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

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

Corpse *	GetCorpse (ObjectGuid const &guid)

Creature *	GetCreature (ObjectGuid const &guid)

GameObject *	GetGameObject (ObjectGuid const &guid)

Transport *	GetTransport (ObjectGuid const &guid)

DynamicObject *	GetDynamicObject (ObjectGuid const &guid)

Pet *	GetPet (ObjectGuid const &guid)

MapStoredObjectTypesContainer &	GetObjectsStore ()

CreatureBySpawnIdContainer &	GetCreatureBySpawnIdStore ()

GameObjectBySpawnIdContainer &	GetGameObjectBySpawnIdStore ()

std::unordered_set< Corpse * > const *	GetCorpsesInGrid (uint32 gridId) const

Corpse *	GetCorpseByPlayer (ObjectGuid const &ownerGuid) const

MapInstanced *	ToMapInstanced ()

MapInstanced const *	ToMapInstanced () const

InstanceMap *	ToInstanceMap ()

InstanceMap const *	ToInstanceMap () const

BattlegroundMap *	ToBattlegroundMap ()

BattlegroundMap const *	ToBattlegroundMap () const

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

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

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

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

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

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

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

void	Balance ()

void	RemoveGameObjectModel (const GameObjectModel &model)

void	InsertGameObjectModel (const GameObjectModel &model)

bool	ContainsGameObjectModel (const GameObjectModel &model) const

DynamicMapTree const &	GetDynamicMapTree () const

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

time_t	GetLinkedRespawnTime (ObjectGuid guid) const

time_t	GetCreatureRespawnTime (ObjectGuid::LowType dbGuid) const

time_t	GetGORespawnTime (ObjectGuid::LowType dbGuid) const

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

void	RemoveCreatureRespawnTime (ObjectGuid::LowType dbGuid)

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

void	RemoveGORespawnTime (ObjectGuid::LowType dbGuid)

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

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

void	LoadRespawnTimes ()

void	DeleteRespawnTimes ()

time_t	GetInstanceResetPeriod () const

void	UpdatePlayerZoneStats (uint32 oldZone, uint32 newZone)

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

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

bool	SpawnGroupDespawn (uint32 groupId, bool deleteRespawnTimes=false)

bool	IsSpawnGroupActive (uint32 groupId) const

void	ProcessRespawns ()

void	ProcessCreatureRespawn (ObjectGuid::LowType spawnId)

void	ProcessGameObjectRespawn (ObjectGuid::LowType spawnId)

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

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

void	ScheduleCreatureRespawn (ObjectGuid, Milliseconds, Position pos=Position())

void	LoadCorpseData ()

void	DeleteCorpseData ()

void	AddCorpse (Corpse *corpse)

void	RemoveCorpse (Corpse *corpse)

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

void	RemoveOldCorpses ()

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

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

void	SendInitTransports (Player *player)

void	SendRemoveTransports (Player *player)

void	SendZoneDynamicInfo (uint32 zoneId, Player *player) const

void	SendZoneWeather (uint32 zoneId, Player *player) const

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

void	SendInitSelf (Player *player)

void	UpdateWeather (uint32 const diff)

void	UpdateExpiredCorpses (uint32 const diff)

void	PlayDirectSoundToMap (uint32 soundId, uint32 zoneId=0)

void	SetZoneMusic (uint32 zoneId, uint32 musicId)

Weather *	GetOrGenerateZoneDefaultWeather (uint32 zoneId)

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

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

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

void	LogEncounterFinished (EncounterCreditType type, uint32 creditEntry)

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

void	EnsureGridCreated (GridCoord const &gridCoord)

bool	AllTransportsEmpty () const

void	AllTransportsRemovePassengers ()

TransportsContainer const &	GetAllTransports () const

template<HighGuid high>
ObjectGuid::LowType	GenerateLowGuid ()

void	AddUpdateObject (Object *obj)

void	RemoveUpdateObject (Object *obj)

size_t	GetUpdatableObjectsCount () const

uint32	GetCreatedGridsCount ()

uint32	GetLoadedGridsCount ()

uint32	GetCreatedCellsInGridCount (uint16 const x, uint16 const y)

uint32	GetCreatedCellsInMapCount ()

void	AddObjectToPendingUpdateList (WorldObject *obj)

void	RemoveObjectFromMapUpdateList (WorldObject *obj)

void	AddWorldObjectToFarVisibleMap (WorldObject *obj)

void	RemoveWorldObjectFromFarVisibleMap (WorldObject *obj)

void	AddWorldObjectToZoneWideVisibleMap (uint32 zoneId, WorldObject *obj)

void	RemoveWorldObjectFromZoneWideVisibleMap (uint32 zoneId, WorldObject *obj)

ZoneWideVisibleWorldObjectsSet const *	GetZoneWideVisibleWorldObjectsForZone (uint32 zoneId) const

uint32	GetPlayerCountInZone (uint32 zoneId) const

MapCollisionData &	GetMapCollisionData ()

MapCollisionData const &	GetMapCollisionData () const

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

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

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

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

template<>
void	DeleteFromWorld (Player *player)

template<>
void	InitializeObject (Creature *)

template<>
void	InitializeObject (GameObject *)

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

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

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

GridReference< MapGridType > *	getLast ()

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

Public Member Functions inherited from RefMgr< TO, FROM >
	RefMgr ()=default

virtual	~RefMgr ()

Reference< TO, FROM > *	getFirst ()

Reference< TO, FROM > const *	getFirst () const

Reference< TO, FROM > *	getLast ()

Reference< TO, FROM > const *	getLast () const

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

void	clearReferences ()

Public Member Functions inherited from LinkedListHead
	LinkedListHead ()

bool	IsEmpty () const

LinkedListElement *	getFirst ()

LinkedListElement const *	getFirst () const

LinkedListElement *	getLast ()

LinkedListElement const *	getLast () const

void	insertFirst (LinkedListElement *pElem)

void	insertLast (LinkedListElement *pElem)

uint32	getSize () const

void	incSize ()

void	decSize ()

Private Attributes
bool	m_resetAfterUnload

bool	m_unloadWhenEmpty

InstanceScript *	instance_data

uint32	i_script_id

Additional Inherited Members
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

typedef std::vector< WorldObject * >	UpdatableObjectList

typedef std::unordered_set< WorldObject * >	PendingAddUpdatableObjectList

Public Types inherited from GridRefMgr< MapGridType >
typedef LinkedListHead::Iterator< GridReference< MapGridType > >	iterator

Public Types inherited from RefMgr< TO, FROM >
typedef LinkedListHead::Iterator< Reference< TO, FROM > >	iterator

Public Types inherited from LinkedListHead
typedef Iterator< LinkedListElement >	iterator

Static Public Member Functions inherited from Map
static void	DeleteRespawnTimesInDB (uint16 mapId, uint32 instanceId)

Public Attributes inherited from Map
std::unordered_set< Unit * >	i_objectsForDelayedVisibility

CreatureGroupHolderType	CreatureGroupHolder

EventProcessor	Events

DataMap	CustomData

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

Protected Attributes inherited from Map
std::mutex	Lock

MapGridManager	_mapGridManager

MapEntry const *	i_mapEntry

MapCollisionData	_mapCollisionData

uint8	i_spawnMode

uint32	i_InstanceId

uint32	m_unloadTimer

float	m_VisibleDistance

time_t	_instanceResetPeriod

MapRefMgr	m_mapRefMgr

MapRefMgr::iterator	m_mapRefIter

TransportsContainer	_transports

TransportsContainer::iterator	_transportsUpdateIter

Detailed Description

Constructor & Destructor Documentation

◆ InstanceMap()

InstanceMap::InstanceMap	(	uint32	id,
		uint32	InstanceId,
		uint8	SpawnMode,
		Map *	_parent
	)

    : Map(id, InstanceId, SpawnMode, _parent),
      m_resetAfterUnload(false), m_unloadWhenEmpty(false),
      instance_data(nullptr), i_script_id(0)
{
    //lets initialize visibility distance for dungeons
    InstanceMap::InitVisibilityDistance();
 
    // the timer is started by default, and stopped when the first player joins
    // this make sure it gets unloaded if for some reason no player joins
    m_unloadTimer = std::max(sWorld->getIntConfig(CONFIG_INSTANCE_UNLOAD_DELAY), (uint32)MIN_UNLOAD_DELAY);
 
    // pussywizard:
    if (IsRaid())
        if (time_t resetTime = sInstanceSaveMgr->GetResetTimeFor(id, Difficulty(SpawnMode)))
            if (time_t extendedResetTime = sInstanceSaveMgr->GetExtendedResetTimeFor(id, Difficulty(SpawnMode)))
                _instanceResetPeriod = extendedResetTime - resetTime;
}

References Map::_instanceResetPeriod, CONFIG_INSTANCE_UNLOAD_DELAY, InitVisibilityDistance(), Map::IsRaid(), Map::m_unloadTimer, MIN_UNLOAD_DELAY, sInstanceSaveMgr, and sWorld.

◆ ~InstanceMap()

InstanceMap::~InstanceMap ( )

override

{
    delete instance_data;
    instance_data = nullptr;
    sInstanceSaveMgr->DeleteInstanceSaveIfNeeded(GetInstanceId(), true);
}

References Map::GetInstanceId(), instance_data, and sInstanceSaveMgr.

Member Function Documentation

◆ AddPlayerToMap()

bool InstanceMap::AddPlayerToMap ( Player * player )

overridevirtual

Reimplemented from Map.

{
    if (m_resetAfterUnload) // this instance has been reset, it's not meant to be used anymore
        return false;
 
    if (IsDungeon())
    {
        Group* group = player->GetGroup();
 
        // get an instance save for the map
        InstanceSave* mapSave = sInstanceSaveMgr->GetInstanceSave(GetInstanceId());
        if (!mapSave)
        {
            LOG_ERROR("maps", "InstanceMap::Add: InstanceSave does not exist for map {} spawnmode {} with instance id {}", GetId(), GetSpawnMode(), GetInstanceId());
            return false;
        }
 
        // check for existing instance binds
        InstancePlayerBind* playerBind = sInstanceSaveMgr->PlayerGetBoundInstance(player->GetGUID(), GetId(), Difficulty(GetSpawnMode()));
        if (playerBind && playerBind->perm)
        {
            if (playerBind->save != mapSave)
            {
                LOG_ERROR("maps", "InstanceMap::Add: player {} ({}) is permanently bound to instance {}, {}, {}, {} but he is being put into instance {}, {}, {}, {}",
                    player->GetName(), player->GetGUID().ToString(), playerBind->save->GetMapId(), playerBind->save->GetInstanceId(), playerBind->save->GetDifficulty(),
                    playerBind->save->CanReset(), mapSave->GetMapId(), mapSave->GetInstanceId(), mapSave->GetDifficulty(), mapSave->CanReset());
                return false;
            }
        }
        else if (player->GetSession()->PlayerLoading() && playerBind && playerBind->save != mapSave)
        {
            // Prevent "Convert to Raid" exploit to reset instances
            return false;
        }
        else
        {
            playerBind = sInstanceSaveMgr->PlayerBindToInstance(player->GetGUID(), mapSave, false, player);
            // pussywizard: bind lider also if not yet bound
            if (Group* g = player->GetGroup())
                if (g->GetLeaderGUID() != player->GetGUID())
                    if (!sInstanceSaveMgr->PlayerGetBoundInstance(g->GetLeaderGUID(), mapSave->GetMapId(), mapSave->GetDifficulty()))
                    {
                        sInstanceSaveMgr->PlayerCreateBoundInstancesMaps(g->GetLeaderGUID());
                        sInstanceSaveMgr->PlayerBindToInstance(g->GetLeaderGUID(), mapSave, false, ObjectAccessor::FindConnectedPlayer(g->GetLeaderGUID()));
                    }
        }
 
        // increase current instances (hourly limit)
        // xinef: specific instances are still limited
        if (!group || !group->isLFGGroup() || !group->IsLfgRandomInstance())
            player->AddInstanceEnterTime(GetInstanceId(), GameTime::GetGameTime().count());
 
        if (!playerBind->perm && !mapSave->CanReset() && group && !group->isLFGGroup() && !group->IsLfgRandomInstance())
        {
            WorldPacket data(SMSG_INSTANCE_LOCK_WARNING_QUERY, 9);
            data << uint32(60000);
            data << uint32(instance_data ? instance_data->GetCompletedEncounterMask() : 0);
            data << uint8(0);
            player->SendDirectMessage(&data);
            player->SetPendingBind(mapSave->GetInstanceId(), 60000);
        }
    }
 
    // initialize unload state
    m_unloadTimer = 0;
    m_resetAfterUnload = false;
    m_unloadWhenEmpty = false;
 
    // this will acquire the same mutex so it cannot be in the previous block
    Map::AddPlayerToMap(player);
 
    if (instance_data)
        instance_data->OnPlayerEnter(player);
 
    return true;
}

References Player::AddInstanceEnterTime(), Map::AddPlayerToMap(), InstanceSave::CanReset(), ObjectAccessor::FindConnectedPlayer(), InstanceScript::GetCompletedEncounterMask(), InstanceSave::GetDifficulty(), GameTime::GetGameTime(), Player::GetGroup(), Object::GetGUID(), Map::GetId(), InstanceSave::GetInstanceId(), Map::GetInstanceId(), InstanceSave::GetMapId(), WorldObject::GetName(), Player::GetSession(), Map::GetSpawnMode(), instance_data, Map::IsDungeon(), Group::isLFGGroup(), Group::IsLfgRandomInstance(), LOG_ERROR, m_resetAfterUnload, Map::m_unloadTimer, m_unloadWhenEmpty, InstanceScript::OnPlayerEnter(), InstancePlayerBind::perm, WorldSession::PlayerLoading(), InstancePlayerBind::save, Player::SendDirectMessage(), Player::SetPendingBind(), sInstanceSaveMgr, SMSG_INSTANCE_LOCK_WARNING_QUERY, and ObjectGuid::ToString().

◆ AfterPlayerUnlinkFromMap()

void InstanceMap::AfterPlayerUnlinkFromMap ( )

overridevirtual

Reimplemented from Map.

{
    if (!m_unloadTimer && !HavePlayers())
        m_unloadTimer = m_unloadWhenEmpty ? MIN_UNLOAD_DELAY : std::max(sWorld->getIntConfig(CONFIG_INSTANCE_UNLOAD_DELAY), (uint32)MIN_UNLOAD_DELAY);
    Map::AfterPlayerUnlinkFromMap();
}

References Map::AfterPlayerUnlinkFromMap(), CONFIG_INSTANCE_UNLOAD_DELAY, Map::HavePlayers(), Map::m_unloadTimer, m_unloadWhenEmpty, MIN_UNLOAD_DELAY, and sWorld.

◆ CannotEnter()

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

overridevirtual

Reimplemented from Map.

{
    if (!loginCheck && player->GetMapRef().getTarget() == this)
    {
        LOG_ERROR("maps", "InstanceMap::CanEnter - player {} ({}) already in map {}, {}, {}!",
            player->GetName(), player->GetGUID().ToString(), GetId(), GetInstanceId(), GetSpawnMode());
 
        return CANNOT_ENTER_ALREADY_IN_MAP;
    }
 
    // allow GM's to enter
    if (player->IsGameMaster())
        return Map::CannotEnter(player, loginCheck);
 
    // cannot enter if the instance is full (player cap), GMs don't count
    uint32 maxPlayers = GetMaxPlayers();
    if (GetPlayersCountExceptGMs() >= (loginCheck ? maxPlayers + 1 : maxPlayers))
    {
        LOG_DEBUG("maps", "MAP: Instance '{}' of map '{}' cannot have more than '{}' players. Player '{}' rejected", GetInstanceId(), GetMapName(), maxPlayers, player->GetName());
        player->SendTransferAborted(GetId(), TRANSFER_ABORT_MAX_PLAYERS);
        return CANNOT_ENTER_MAX_PLAYERS;
    }
 
    // cannot enter while an encounter is in progress on raids
    bool checkProgress = (IsRaid() || GetId() == 668 /*HoR*/);
    if (checkProgress && GetInstanceScript() && GetInstanceScript()->IsEncounterInProgress())
    {
        player->SendTransferAborted(GetId(), TRANSFER_ABORT_ZONE_IN_COMBAT);
        return CANNOT_ENTER_ZONE_IN_COMBAT;
    }
 
    // xinef: dont allow LFG Group to enter other instance that is selected
    if (Group* group = player->GetGroup())
        if (group->isLFGGroup())
            if (!sLFGMgr->inLfgDungeonMap(group->GetGUID(), GetId(), GetDifficulty()))
            {
                player->SendTransferAborted(GetId(), TRANSFER_ABORT_MAP_NOT_ALLOWED);
                return CANNOT_ENTER_UNSPECIFIED_REASON;
            }
 
    // cannot enter if instance is in use by another party/soloer that have a permanent save in the same instance id
    PlayerList const& playerList = GetPlayers();
    if (!playerList.IsEmpty())
        for (PlayerList::const_iterator i = playerList.begin(); i != playerList.end(); ++i)
            if (Player* iPlayer = i->GetSource())
            {
                if (iPlayer == player) // login case, player already added to map
                    continue;
                if (iPlayer->IsGameMaster()) // bypass GMs
                    continue;
                if (!player->GetGroup()) // player has not group and there is someone inside, deny entry
                {
                    player->SendTransferAborted(GetId(), TRANSFER_ABORT_MAX_PLAYERS);
                    return CANNOT_ENTER_INSTANCE_BIND_MISMATCH;
                }
                // player inside instance has no group or his groups is different to entering player's one, deny entry
                if (!iPlayer->GetGroup() || iPlayer->GetGroup() != player->GetGroup())
                {
                    player->SendTransferAborted(GetId(), TRANSFER_ABORT_MAX_PLAYERS);
                    return CANNOT_ENTER_INSTANCE_BIND_MISMATCH;
                }
                break;
            }
 
    return Map::CannotEnter(player, loginCheck);
}

References MapRefMgr::begin(), Map::CANNOT_ENTER_ALREADY_IN_MAP, Map::CANNOT_ENTER_INSTANCE_BIND_MISMATCH, Map::CANNOT_ENTER_MAX_PLAYERS, Map::CANNOT_ENTER_UNSPECIFIED_REASON, Map::CANNOT_ENTER_ZONE_IN_COMBAT, Map::CannotEnter(), MapRefMgr::end(), Map::GetDifficulty(), Player::GetGroup(), Object::GetGUID(), Map::GetId(), Map::GetInstanceId(), GetInstanceScript(), Map::GetMapName(), Player::GetMapRef(), GetMaxPlayers(), WorldObject::GetName(), Map::GetPlayers(), Map::GetPlayersCountExceptGMs(), Map::GetSpawnMode(), Reference< TO, FROM >::getTarget(), LinkedListHead::IsEmpty(), InstanceScript::IsEncounterInProgress(), Player::IsGameMaster(), Map::IsRaid(), LOG_DEBUG, LOG_ERROR, Player::SendTransferAborted(), sLFGMgr, ObjectGuid::ToString(), TRANSFER_ABORT_MAP_NOT_ALLOWED, TRANSFER_ABORT_MAX_PLAYERS, and TRANSFER_ABORT_ZONE_IN_COMBAT.

◆ CreateInstanceScript()

void InstanceMap::CreateInstanceScript	(	bool	load,
		std::string	data,
		uint32	completedEncounterMask
	)

{
    if (instance_data)
    {
        return;
    }
 
    bool isOtherAI = false;
 
    sScriptMgr->OnBeforeCreateInstanceScript(this, &instance_data, load, data, completedEncounterMask);
 
    if (instance_data)
        isOtherAI = true;
 
    // if ALE AI was fetched succesfully we should not call CreateInstanceData nor set the unused scriptID
    if (!isOtherAI)
    {
        InstanceTemplate const* mInstance = sObjectMgr->GetInstanceTemplate(GetId());
        if (mInstance)
        {
            i_script_id = mInstance->ScriptId;
            instance_data = sScriptMgr->CreateInstanceScript(this);
        }
    }
 
    if (!instance_data)
        return;
 
    // use mangos behavior if we are dealing with ALE AI
    // initialize should then be called only if load is false
    if (!isOtherAI || !load)
    {
        instance_data->Initialize();
    }
 
    if (load)
    {
        instance_data->SetCompletedEncountersMask(completedEncounterMask, false);
        if (data != "")
            instance_data->Load(data.c_str());
    }
 
    instance_data->LoadInstanceSavedGameobjectStateData();
}

References Map::GetId(), i_script_id, InstanceScript::Initialize(), instance_data, InstanceScript::Load(), InstanceScript::LoadInstanceSavedGameobjectStateData(), InstanceTemplate::ScriptId, InstanceScript::SetCompletedEncountersMask(), sObjectMgr, and sScriptMgr.

◆ GetDebugInfo()

std::string InstanceMap::GetDebugInfo ( ) const

overridevirtual

Reimplemented from Map.

{
    std::stringstream sstr;
    sstr << Map::GetDebugInfo() << "\n"
        << std::boolalpha
        << "ScriptId: " << GetScriptId() << " ScriptName: " << GetScriptName();
    return sstr.str();
}

References Map::GetDebugInfo(), GetScriptId(), and GetScriptName().

◆ GetInstanceScript() [1/2]

InstanceScript * InstanceMap::GetInstanceScript ( )

inline

720{ return instance_data; }

References instance_data.

Referenced by CannotEnter(), TransportMgr::CreateTransport(), WorldObject::GetInstanceScript(), instance_commandscript::HandleInstanceGetBossStateCommand(), instance_commandscript::HandleInstanceSaveDataCommand(), instance_commandscript::HandleInstanceSetBossStateCommand(), WorldSession::HandleSetRaidDifficultyOpcode(), InstanceSave::InsertToDB(), Condition::Meets(), and AchievementCriteriaData::Meets().

◆ GetInstanceScript() [2/2]

InstanceScript const * InstanceMap::GetInstanceScript ( ) const

inline

721{ return instance_data; }

References instance_data.

◆ GetMaxPlayers()

uint32 InstanceMap::GetMaxPlayers ( ) const

{
    MapDifficulty const* mapDiff = GetMapDifficulty();
    if (mapDiff && mapDiff->maxPlayers)
        return mapDiff->maxPlayers;
 
    return GetEntry()->maxPlayers;
}

References Map::GetEntry(), Map::GetMapDifficulty(), MapEntry::maxPlayers, and MapDifficulty::maxPlayers.

Referenced by CannotEnter(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::CheckAchievementCriteriaMeet(), and AchievementMgr::UpdateAchievementCriteria().

◆ GetMaxResetDelay()

uint32 InstanceMap::GetMaxResetDelay ( ) const

{
    MapDifficulty const* mapDiff = GetMapDifficulty();
    return mapDiff ? mapDiff->resetTime : 0;
}

References Map::GetMapDifficulty(), and MapDifficulty::resetTime.

◆ GetScriptId()

uint32 InstanceMap::GetScriptId ( ) const

inline

718{ return i_script_id; }

References i_script_id.

Referenced by ScriptMgr::CreateInstanceScript(), and GetDebugInfo().

◆ GetScriptName()

std::string const & InstanceMap::GetScriptName ( ) const

{
    return sObjectMgr->GetScriptName(i_script_id);
}

References i_script_id, and sObjectMgr.

Referenced by GetDebugInfo().

◆ InitVisibilityDistance()

void InstanceMap::InitVisibilityDistance ( )

overridevirtual

Reimplemented from Map.

{
    //init visibility distance for instances
    m_VisibleDistance = World::GetMaxVisibleDistanceInInstances();
 
    // pussywizard: this CAN NOT exceed MAX_VISIBILITY_DISTANCE
    switch (GetId())
    {
        case 429: // Dire Maul
        case 550: // The Eye
        case 578: // The Nexus: The Oculus
            m_VisibleDistance = 175.0f;
            break;
        case 649: // Trial of the Crusader
        case 650: // Trial of the Champion
        case 595: // Culling of Startholme
        case 658: // Pit of Saron
            m_VisibleDistance = 150.0f;
            break;
        case 615: // Obsidian Sanctum
        case 616: // Eye of Eternity
        case 603: // Ulduar
        case 668: // Halls of Reflection
        case 631: // Icecrown Citadel
        case 724: // Ruby Sanctum
            m_VisibleDistance = 200.0f;
            break;
        case 531: // Ahn'Qiraj Temple
            m_VisibleDistance = 300.0f;
            break;
    }
}

References Map::GetId(), World::GetMaxVisibleDistanceInInstances(), and Map::m_VisibleDistance.

Referenced by InstanceMap().

◆ PermBindAllPlayers()

void InstanceMap::PermBindAllPlayers ( )

{
    if (!IsDungeon())
        return;
 
    InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(GetInstanceId());
    if (!save)
    {
        LOG_ERROR("maps", "Cannot bind players because no instance save is available for instance map (Name: {}, Entry: {}, InstanceId: {})!", GetMapName(), GetId(), GetInstanceId());
        return;
    }
 
    Player* player;
    Group* group;
    // group members outside the instance group don't get bound
    for (MapRefMgr::iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
    {
        player = itr->GetSource();
        group = player->GetGroup();
 
        // players inside an instance cannot be bound to other instances
        // some players may already be permanently bound, in this case nothing happens
        InstancePlayerBind* bind = sInstanceSaveMgr->PlayerGetBoundInstance(player->GetGUID(), save->GetMapId(), save->GetDifficulty());
 
        if (!bind || !bind->perm)
        {
            WorldPacket data(SMSG_INSTANCE_SAVE_CREATED, 4);
            data << uint32(0);
            player->SendDirectMessage(&data);
            sInstanceSaveMgr->PlayerBindToInstance(player->GetGUID(), save, true, player);
        }
 
        // Xinef: Difficulty change prevention
        if (group)
            group->SetDifficultyChangePrevention(DIFFICULTY_PREVENTION_CHANGE_BOSS_KILLED);
    }
}

References MapRefMgr::begin(), DIFFICULTY_PREVENTION_CHANGE_BOSS_KILLED, MapRefMgr::end(), InstanceSave::GetDifficulty(), Player::GetGroup(), Object::GetGUID(), Map::GetId(), Map::GetInstanceId(), InstanceSave::GetMapId(), Map::GetMapName(), Map::IsDungeon(), LOG_ERROR, Map::m_mapRefMgr, InstancePlayerBind::perm, Player::SendDirectMessage(), Group::SetDifficultyChangePrevention(), sInstanceSaveMgr, and SMSG_INSTANCE_SAVE_CREATED.

Referenced by boss_flame_leviathan::BindPlayers(), npc_harrison_jones::DoAction(), boss_skeram::JustDied(), boss_sartharion_dragonAI::JustDied(), Unit::Kill(), instance_karazhan::instance_karazhan_InstanceMapScript::OnUnitDeath(), instance_karazhan::instance_karazhan_InstanceMapScript::SetData(), instance_trial_of_the_champion::instance_trial_of_the_champion_InstanceMapScript::SetData(), and instance_halls_of_reflection::UpdateOutro().

◆ RemovePlayerFromMap()

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

overridevirtual

Reimplemented from Map.

{
    if (instance_data)
        instance_data->OnPlayerLeave(player);
    // pussywizard: moved m_unloadTimer to InstanceMap::AfterPlayerUnlinkFromMap(), in this function if 2 players run out at the same time the instance won't close
    //if (!m_unloadTimer && m_mapRefMgr.getSize() == 1)
    //    m_unloadTimer = m_unloadWhenEmpty ? MIN_UNLOAD_DELAY : std::max(sWorld->getIntConfig(CONFIG_INSTANCE_UNLOAD_DELAY), (uint32)MIN_UNLOAD_DELAY);
    Map::RemovePlayerFromMap(player, remove);
 
    // If remove == true - player already deleted.
    if (!remove)
        player->SetPendingBind(0, 0);
}

References instance_data, InstanceScript::OnPlayerLeave(), Map::RemovePlayerFromMap(), and Player::SetPendingBind().

◆ Reset()

bool InstanceMap::Reset	(	uint8	method,
		GuidList *	globalSkipList = `nullptr`
	)

{
    if (method == INSTANCE_RESET_GLOBAL)
    {
        // pussywizard: teleport out immediately
        for (MapRefMgr::iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
        {
            // teleport players that are no longer bound (can be still bound if extended id)
            if (!globalResetSkipList || std::find(globalResetSkipList->begin(), globalResetSkipList->end(), itr->GetSource()->GetGUID()) == globalResetSkipList->end())
                itr->GetSource()->RepopAtGraveyard();
        }
 
        // reset map only if noone is bound
        if (!globalResetSkipList || globalResetSkipList->empty())
        {
            // pussywizard: setting both m_unloadWhenEmpty and m_unloadTimer intended, in case RepopAtGraveyard failed
            if (HavePlayers())
                m_unloadWhenEmpty = true;
            m_unloadTimer = MIN_UNLOAD_DELAY;
            m_resetAfterUnload = true;
        }
 
        return m_mapRefMgr.IsEmpty();
    }
 
    if (HavePlayers())
    {
        if (method == INSTANCE_RESET_ALL || method == INSTANCE_RESET_CHANGE_DIFFICULTY)
        {
            for (MapRefMgr::iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
                itr->GetSource()->SendResetFailedNotify(GetId());
        }
    }
    else
    {
        m_unloadTimer = MIN_UNLOAD_DELAY;
        m_resetAfterUnload = true;
    }
 
    return m_mapRefMgr.IsEmpty();
}

References MapRefMgr::begin(), MapRefMgr::end(), Map::GetId(), Map::HavePlayers(), INSTANCE_RESET_ALL, INSTANCE_RESET_CHANGE_DIFFICULTY, INSTANCE_RESET_GLOBAL, LinkedListHead::IsEmpty(), Map::m_mapRefMgr, m_resetAfterUnload, Map::m_unloadTimer, m_unloadWhenEmpty, and MIN_UNLOAD_DELAY.

Referenced by InstanceSaveMgr::_ResetOrWarnAll(), Player::ResetInstances(), and Group::ResetInstances().

◆ SendResetWarnings()

void InstanceMap::SendResetWarnings ( uint32 timeLeft ) const

{
    for (MapRefMgr::const_iterator itr = m_mapRefMgr.begin(); itr != m_mapRefMgr.end(); ++itr)
        itr->GetSource()->SendInstanceResetWarning(GetId(), itr->GetSource()->GetDifficulty(IsRaid()), timeLeft, false);
}

References MapRefMgr::begin(), MapRefMgr::end(), Map::GetId(), Map::IsRaid(), and Map::m_mapRefMgr.

Referenced by InstanceSaveMgr::_ResetOrWarnAll().

◆ UnloadAll()

void InstanceMap::UnloadAll ( )

overridevirtual

Reimplemented from Map.

{
    ASSERT(!HavePlayers());
 
    if (m_resetAfterUnload)
    {
        DeleteRespawnTimes();
        DeleteCorpseData();
    }
 
    Map::UnloadAll();
}

References ASSERT, Map::DeleteCorpseData(), Map::DeleteRespawnTimes(), Map::HavePlayers(), m_resetAfterUnload, and Map::UnloadAll().

◆ Update()

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

overridevirtual

Reimplemented from Map.

{
    Map::Update(t_diff, s_diff);
 
    if (t_diff)
        if (instance_data)
            instance_data->Update(t_diff);
}

References instance_data, Map::Update(), and InstanceScript::Update().

Member Data Documentation

◆ i_script_id

uint32 InstanceMap::i_script_id

private

Referenced by CreateInstanceScript(), GetScriptId(), and GetScriptName().

◆ instance_data

InstanceScript* InstanceMap::instance_data

private

Referenced by AddPlayerToMap(), CreateInstanceScript(), GetInstanceScript(), GetInstanceScript(), RemovePlayerFromMap(), Update(), and ~InstanceMap().

◆ m_resetAfterUnload

bool InstanceMap::m_resetAfterUnload

private

Referenced by AddPlayerToMap(), Reset(), and UnloadAll().

◆ m_unloadWhenEmpty

bool InstanceMap::m_unloadWhenEmpty

private

Referenced by AddPlayerToMap(), AfterPlayerUnlinkFromMap(), and Reset().

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

azerothcore-wotlk/src/server/game/Maps/Map.h
azerothcore-wotlk/src/server/game/Maps/Map.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ InstanceMap()

◆ ~InstanceMap()

Member Function Documentation

◆ AddPlayerToMap()

◆ AfterPlayerUnlinkFromMap()

◆ CannotEnter()

◆ CreateInstanceScript()

◆ GetDebugInfo()

◆ GetInstanceScript() [1/2]

◆ GetInstanceScript() [2/2]

◆ GetMaxPlayers()

◆ GetMaxResetDelay()

◆ GetScriptId()

◆ GetScriptName()

◆ InitVisibilityDistance()

◆ PermBindAllPlayers()

◆ RemovePlayerFromMap()

◆ Reset()

◆ SendResetWarnings()

◆ UnloadAll()

◆ Update()

Member Data Documentation

◆ i_script_id

◆ instance_data

◆ m_resetAfterUnload

◆ m_unloadWhenEmpty