#include <Map.h>

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

	~InstanceMap ()

bool	AddPlayerToMap (Player *player, bool initPlayer=true) override

void	RemovePlayerFromMap (Player *, bool) override

void	Update (const uint32) override

void	CreateInstanceData (bool load)

bool	Reset (uint8 method)

uint32	GetScriptId () const

InstanceScript *	GetInstanceScript ()

void	PermBindAllPlayers (Player *source)

void	UnloadAll () override

EnterState	CannotEnter (Player *player) override

void	SendResetWarnings (uint32 timeLeft) const

void	SetResetSchedule (bool on)

bool	HasPermBoundPlayers () const

uint32	GetMaxPlayers () const

uint32	GetMaxResetDelay () const

virtual void	InitVisibilityDistance () override

Public Member Functions inherited from Map
	Map (uint32 id, time_t, uint32 InstanceId, uint8 SpawnMode, Map *_parent=NULL)

virtual	~Map ()

MapEntry const *	GetEntry () const

bool	CanUnload (uint32 diff)

template<class T >
bool	AddToMap (T *)

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

void	VisitNearbyCellsOf (WorldObject *obj, TypeContainerVisitor< Trinity::ObjectUpdater, GridTypeMapContainer > &gridVisitor, TypeContainerVisitor< Trinity::ObjectUpdater, WorldTypeMapContainer > &worldVisitor)

float	GetVisibilityRange () const

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

void	CreatureRelocation (Creature *creature, float x, float y, float z, float ang, bool respawnRelocationOnFail=true)

void	GameObjectRelocation (GameObject *go, float x, float y, float z, float orientation, bool respawnRelocationOnFail=true)

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

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

bool	GetUnloadLock (const GridCoord &p) const

void	SetUnloadLock (const GridCoord &p, bool on)

void	LoadGrid (float x, float y)

bool	UnloadGrid (NGridType &ngrid, bool pForce)

void	ResetGridExpiry (NGridType &grid, float factor=1) const

time_t	GetGridExpiry (void) const

uint32	GetId (void) const

Map const *	GetParent () const

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

float	GetMinHeight (float x, float y) const

ZLiquidStatus	getLiquidStatus (float x, float y, float z, uint8 ReqLiquidType, LiquidData *data=nullptr) const

uint32	GetAreaId (float x, float y, float z, bool *isOutdoors) const

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

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

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

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

bool	IsOutdoors (float x, float y, float z) const

uint8	GetTerrainType (float x, float y) const

float	GetWaterLevel (float x, float y) const

bool	IsInWater (float x, float y, float z, LiquidData *data=nullptr) const

bool	IsUnderWater (float x, float y, float z) const

void	MoveAllCreaturesInMoveList ()

void	MoveAllGameObjectsInMoveList ()

void	MoveAllDynamicObjectsInMoveList ()

void	RemoveAllObjectsInRemoveList ()

virtual void	RemoveAllPlayers ()

bool	CreatureRespawnRelocation (Creature *c, bool diffGridOnly)

bool	GameObjectRespawnRelocation (GameObject *go, bool diffGridOnly)

bool	CheckGridIntegrity (Creature *c, bool moved) const

uint32	GetInstanceId () const

uint8	GetSpawnMode () const

const char *	GetMapName () const

Difficulty	GetDifficultyID () const

MapDifficultyEntry const *	GetMapDifficulty () const

uint32	GetDifficultyLootBonusTreeMod () 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	IsGarrison () 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	UpdateObjectVisibility (WorldObject *obj, Cell cell, CellCoord cellpair)

void	UpdateObjectsVisibilityFor (Player *player, Cell cell, CellCoord cellpair)

void	resetMarkedCells ()

bool	isCellMarked (uint32 pCellId)

void	markCell (uint32 pCellId)

bool	HavePlayers () const

uint32	GetPlayersCountExceptGMs () const

bool	ActiveObjectsNearGrid (NGridType const &ngrid) 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)

template<class NOTIFIER >
void	VisitAll (const float &x, const float &y, float radius, NOTIFIER &notifier)

template<class NOTIFIER >
void	VisitFirstFound (const float &x, const float &y, float radius, NOTIFIER &notifier)

template<class NOTIFIER >
void	VisitWorld (const float &x, const float &y, float radius, NOTIFIER &notifier)

template<class NOTIFIER >
void	VisitGrid (const float &x, const float &y, float radius, NOTIFIER &notifier)

void	UpdateIteratorBack (Player *player)

TempSummon *	SummonCreature (uint32 entry, Position const &pos, SummonPropertiesEntry const properties=NULL, uint32 duration=0, Unit summoner=NULL, uint32 spellId=0, uint32 vehId=0)

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

AreaTrigger *	GetAreaTrigger (ObjectGuid const &guid)

Corpse *	GetCorpse (ObjectGuid const &guid)

Creature *	GetCreature (ObjectGuid const &guid)

DynamicObject *	GetDynamicObject (ObjectGuid const &guid)

GameObject *	GetGameObject (ObjectGuid const &guid)

Pet *	GetPet (ObjectGuid const &guid)

Transport *	GetTransport (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 (float x, float y, float z, float *ground=NULL, bool swim=false) 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) const

void	Balance ()

void	RemoveGameObjectModel (const GameObjectModel &model)

void	InsertGameObjectModel (const GameObjectModel &model)

bool	ContainsGameObjectModel (const GameObjectModel &model) 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)

virtual ObjectGuid::LowType	GetOwnerGuildId (uint32=TEAM_OTHER) 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 ()

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	SendUpdateTransportVisibility (Player *player, std::set< uint32 > const &previousPhases)

void	SendZoneDynamicInfo (Player *player)

void	SetZoneMusic (uint32 zoneId, uint32 musicId)

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

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

void	UpdateAreaDependentAuras ()

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

void	AddUpdateObject (Object *obj)

void	RemoveUpdateObject (Object *obj)

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	DeleteFromWorld (Transport *transport)

template<>
void	InitializeObject (Creature *obj)

template<>
void	InitializeObject (GameObject *obj)

template<>
bool	AddToMap (Transport *obj)

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

template<>
void	AddToActive (Creature *c)

template<>
void	AddToActive (DynamicObject *d)

template<>
void	RemoveFromActive (Creature *c)

template<>
void	RemoveFromActive (DynamicObject *obj)

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

GridReference< NGridType > *	getLast ()

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

Public Member Functions inherited from RefManager< GridRefManager< NGridType >, NGridType >
	RefManager ()

virtual	~RefManager ()

Reference< GridRefManager < NGridType >, NGridType > *	getFirst ()

Reference< GridRefManager < NGridType >, NGridType > const *	getFirst () const

Reference< GridRefManager < NGridType >, NGridType > *	getLast ()

Reference< GridRefManager < NGridType >, NGridType > const *	getLast () const

iterator	begin ()

iterator	end ()

iterator	rbegin ()

iterator	rend ()

void	clearReferences ()

Public Member Functions inherited from LinkedListHead
	LinkedListHead ()

virtual	~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 *	i_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 MapRefManager	PlayerList

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

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

Public Types inherited from GridRefManager< NGridType >
typedef LinkedListHead::Iterator < GridReference< NGridType > >	iterator

Public Types inherited from RefManager< GridRefManager< NGridType >, NGridType >
typedef LinkedListHead::Iterator < Reference< GridRefManager < NGridType >, NGridType > >	iterator

Public Types inherited from LinkedListHead
typedef Iterator < LinkedListElement >	iterator

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

static void	DeleteStateMachine ()

static void	DeleteRespawnTimesInDB (uint16 mapId, uint32 instanceId)

Public Attributes inherited from Map
CreatureGroupHolderType	CreatureGroupHolder

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

typedef std::set< Transport * >	TransportsContainer

Protected Member Functions inherited from Map
void	SetUnloadReferenceLock (const GridCoord &p, bool on)

virtual void	LoadGridObjects (NGridType *grid, Cell const &cell)

Protected Attributes inherited from Map
std::mutex	_mapLock

std::mutex	_gridLock

MapEntry const *	i_mapEntry

uint8	i_spawnMode

uint32	i_InstanceId

uint32	m_unloadTimer

float	m_VisibleDistance

DynamicMapTree	_dynamicTree

MapRefManager	m_mapRefManager

MapRefManager::iterator	m_mapRefIter

int32	m_VisibilityNotifyPeriod

ActiveNonPlayers	m_activeNonPlayers

ActiveNonPlayers::iterator	m_activeNonPlayersIter

TransportsContainer	_transports

TransportsContainer::iterator	_transportsUpdateIter

Constructor & Destructor Documentation

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

  : Map(id, expiry, InstanceId, SpawnMode, _parent),
  m_resetAfterUnload(false), m_unloadWhenEmpty(false),
  i_data(NULL), 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);
 }

Here is the call graph for this function:

InstanceMap::~InstanceMap ( )

 {
  delete i_data;
  i_data = NULL;
 }

Member Function Documentation

bool InstanceMap::AddPlayerToMap	(	Player *	player,
		bool	initPlayer = `true`
	)

overridevirtual

Todo:: Not sure about checking player level: already done in HandleAreaTriggerOpcode

Reimplemented from Map.

 {
  // GMs still can teleport player in instance.
  // Is it needed?
 
  {
  std::lock_guard<std::mutex> lock(_mapLock);
  // Check moved to void WorldSession::HandleMoveWorldportAckOpcode()
  //if (!CanEnter(player))
  //return false;
 
  // Dungeon only code
  if (IsDungeon())
  {
  Group* group = player->GetGroup();
 
  // increase current instances (hourly limit)
  if (!group || !group->isLFGGroup())
  player->AddInstanceEnterTime(GetInstanceId(), time(NULL));
 
  // get or create an instance save for the map
  InstanceSave* mapSave = sInstanceSaveMgr->GetInstanceSave(GetInstanceId());
  if (!mapSave)
  {
  TC_LOG_DEBUG("maps", "InstanceMap::Add: creating instance save for map %d spawnmode %d with instance id %d", GetId(), GetSpawnMode(), GetInstanceId());
  mapSave = sInstanceSaveMgr->AddInstanceSave(GetId(), GetInstanceId(), Difficulty(GetSpawnMode()), 0, true);
  }
 
  ASSERT(mapSave);
 
  // check for existing instance binds
  InstancePlayerBind* playerBind = player->GetBoundInstance(GetId(), Difficulty(GetSpawnMode()));
  if (playerBind && playerBind->perm)
  {
  // cannot enter other instances if bound permanently
  if (playerBind->save != mapSave)
  {
  TC_LOG_ERROR("maps", "InstanceMap::Add: player %s(%s) is permanently bound to instance %s %d, %d, %d, %d, %d, %d but he is being put into instance %s %d, %d, %d, %d, %d, %d", player->GetName().c_str(), player->GetGUID().ToString().c_str(), GetMapName(), playerBind->save->GetMapId(), playerBind->save->GetInstanceId(), playerBind->save->GetDifficultyID(), playerBind->save->GetPlayerCount(), playerBind->save->GetGroupCount(), playerBind->save->CanReset(), GetMapName(), mapSave->GetMapId(), mapSave->GetInstanceId(), mapSave->GetDifficultyID(), mapSave->GetPlayerCount(), mapSave->GetGroupCount(), mapSave->CanReset());
  return false;
  }
  }
  else
  {
  if (group)
  {
  // solo saves should have been reset when the map was loaded
  InstanceGroupBind* groupBind = group->GetBoundInstance(this);
  if (playerBind && playerBind->save != mapSave)
  {
  TC_LOG_ERROR("maps", "InstanceMap::Add: player %s(%s) is being put into instance %s %d, %d, %d, %d, %d, %d but he is in group %s and is bound to instance %d, %d, %d, %d, %d, %d!", player->GetName().c_str(), player->GetGUID().ToString().c_str(), GetMapName(), mapSave->GetMapId(), mapSave->GetInstanceId(), mapSave->GetDifficultyID(), mapSave->GetPlayerCount(), mapSave->GetGroupCount(), mapSave->CanReset(), group->GetLeaderGUID().ToString().c_str(), playerBind->save->GetMapId(), playerBind->save->GetInstanceId(), playerBind->save->GetDifficultyID(), playerBind->save->GetPlayerCount(), playerBind->save->GetGroupCount(), playerBind->save->CanReset());
  if (groupBind)
  TC_LOG_ERROR("maps", "InstanceMap::Add: the group is bound to the instance %s %d, %d, %d, %d, %d, %d", GetMapName(), groupBind->save->GetMapId(), groupBind->save->GetInstanceId(), groupBind->save->GetDifficultyID(), groupBind->save->GetPlayerCount(), groupBind->save->GetGroupCount(), groupBind->save->CanReset());
  //ABORT();
  return false;
  }
  // bind to the group or keep using the group save
  if (!groupBind)
  group->BindToInstance(mapSave, false);
  else
  {
  // cannot jump to a different instance without resetting it
  if (groupBind->save != mapSave)
  {
  TC_LOG_ERROR("maps", "InstanceMap::Add: player %s(%s) is being put into instance %d, %d, %d but he is in group %s which is bound to instance %d, %d, %d!", player->GetName().c_str(), player->GetGUID().ToString().c_str(), mapSave->GetMapId(), mapSave->GetInstanceId(), mapSave->GetDifficultyID(), group->GetLeaderGUID().ToString().c_str(), groupBind->save->GetMapId(), groupBind->save->GetInstanceId(), groupBind->save->GetDifficultyID());
  TC_LOG_ERROR("maps", "MapSave players: %d, group count: %d", mapSave->GetPlayerCount(), mapSave->GetGroupCount());
  if (groupBind->save)
  TC_LOG_ERROR("maps", "GroupBind save players: %d, group count: %d", groupBind->save->GetPlayerCount(), groupBind->save->GetGroupCount());
  else
  TC_LOG_ERROR("maps", "GroupBind save NULL");
  return false;
  }
  // if the group/leader is permanently bound to the instance
  // players also become permanently bound when they enter
  if (groupBind->perm)
  {
  WorldPackets::Instance::PendingRaidLock pendingRaidLock;
  pendingRaidLock.TimeUntilLock = 60000;
  pendingRaidLock.CompletedMask = i_data ? i_data->GetCompletedEncounterMask() : 0;
  pendingRaidLock.Extending = false;
  pendingRaidLock.WarningOnly = false; // events it throws: 1 : INSTANCE_LOCK_WARNING 0 : INSTANCE_LOCK_STOP / INSTANCE_LOCK_START
  player->GetSession()->SendPacket(pendingRaidLock.Write());
  player->SetPendingBind(mapSave->GetInstanceId(), 60000);
  }
  }
  }
  else
  {
  // set up a solo bind or continue using it
  if (!playerBind)
  player->BindToInstance(mapSave, false);
  else
  // cannot jump to a different instance without resetting it
  ASSERT(playerBind->save == mapSave);
  }
  }
  }
 
  // for normal instances cancel the reset schedule when the
  // first player enters (no players yet)
  SetResetSchedule(false);
 
  TC_LOG_DEBUG("maps", "MAP: Player '%s' entered instance '%u' of map '%s'", player->GetName().c_str(), GetInstanceId(), GetMapName());
  // 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, initPlayer);
 
  if (i_data)
  i_data->OnPlayerEnter(player);
 
  return true;
 }

Here is the call graph for this function:

Map::EnterState InstanceMap::CannotEnter ( Player * player )

overridevirtual

Reimplemented from Map.

 {
  if (player->GetMapRef().getTarget() == this)
  {
  TC_LOG_ERROR("maps", "InstanceMap::CannotEnter - player %s(%s) already in map %d, %d, %d!", player->GetName().c_str(), player->GetGUID().ToString().c_str(), GetId(), GetInstanceId(), GetSpawnMode());
  ABORT();
  return CANNOT_ENTER_ALREADY_IN_MAP;
  }
 
  // allow GM's to enter
  if (player->IsGameMaster())
  return Map::CannotEnter(player);
 
  // cannot enter if the instance is full (player cap), GMs don't count
  uint32 maxPlayers = GetMaxPlayers();
  if (GetPlayersCountExceptGMs() >= maxPlayers)
  {
  TC_LOG_WARN("maps", "MAP: Instance '%u' of map '%s' cannot have more than '%u' players. Player '%s' rejected", GetInstanceId(), GetMapName(), maxPlayers, player->GetName().c_str());
  return CANNOT_ENTER_MAX_PLAYERS;
  }
 
  // cannot enter while an encounter is in progress (unless this is a relog, in which case it is permitted)
  if (!player->IsLoading() && IsRaid() && GetInstanceScript() && GetInstanceScript()->IsEncounterInProgress())
  return CANNOT_ENTER_ZONE_IN_COMBAT;
 
  // cannot enter if player is permanent saved to a different instance id
  if (InstancePlayerBind* playerBind = player->GetBoundInstance(GetId(), GetDifficultyID()))
  if (playerBind->perm && playerBind->save)
  if (playerBind->save->GetInstanceId() != GetInstanceId())
  return CANNOT_ENTER_INSTANCE_BIND_MISMATCH;
 
  return Map::CannotEnter(player);
 }

Here is the call graph for this function:

void InstanceMap::CreateInstanceData ( bool load )

Todo:: make a global storage for this

 {
  if (i_data != NULL)
  return;
 
  InstanceTemplate const* mInstance = sObjectMgr->GetInstanceTemplate(GetId());
  if (mInstance)
  {
  i_script_id = mInstance->ScriptId;
  i_data = sScriptMgr->CreateInstanceData(this);
  }
 
  if (!i_data)
  return;
 
  i_data->Initialize();
 
  if (load)
  {
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_INSTANCE);
  stmt->setUInt16(0, uint16(GetId()));
  stmt->setUInt32(1, i_InstanceId);
  PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
  if (result)
  {
  Field* fields = result->Fetch();
  std::string data = fields[0].GetString();
  i_data->SetCompletedEncountersMask(fields[1].GetUInt32());
  if (!data.empty())
  {
  TC_LOG_DEBUG("maps", "Loading instance data for `%s` with id %u", sObjectMgr->GetScriptName(i_script_id).c_str(), i_InstanceId);
  i_data->Load(data.c_str());
  }
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

InstanceScript* InstanceMap::GetInstanceScript ( )

inline

769 { return i_data; }

InstanceMap::i_data

InstanceScript * i_data

Definition: Map.h:786

Here is the caller graph for this function:

uint32 InstanceMap::GetMaxPlayers ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 InstanceMap::GetMaxResetDelay ( ) const

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

Here is the call graph for this function:

uint32 InstanceMap::GetScriptId ( ) const

inline

768 { return i_script_id; }

InstanceMap::i_script_id

uint32 i_script_id

Definition: Map.h:787

Here is the caller graph for this function:

bool InstanceMap::HasPermBoundPlayers ( ) const

 {
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PERM_BIND_BY_INSTANCE);
  stmt->setUInt16(0,GetInstanceId());
  return !!CharacterDatabase.Query(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceMap::InitVisibilityDistance ( )

overridevirtual

Reimplemented from Map.

 {
  //init visibility distance for instances
  m_VisibleDistance = World::GetMaxVisibleDistanceInInstances();
  m_VisibilityNotifyPeriod = World::GetVisibilityNotifyPeriodInInstances();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceMap::PermBindAllPlayers ( Player * source )

 {
  if (!IsDungeon())
  return;
 
  InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(GetInstanceId());
  if (!save)
  {
  TC_LOG_ERROR("maps", "Cannot bind player (%s, Name: %s), because no instance save is available for instance map (Name: %s, Entry: %u, InstanceId: %u)!", source->GetGUID().ToString().c_str(), source->GetName().c_str(), source->GetMap()->GetMapName(), source->GetMapId(), GetInstanceId());
  return;
  }
 
  Group* group = source->GetGroup();
  // group members outside the instance group don't get bound
  for (MapRefManager::iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
  {
  Player* player = itr->GetSource();
  // players inside an instance cannot be bound to other instances
  // some players may already be permanently bound, in this case nothing happens
  InstancePlayerBind* bind = player->GetBoundInstance(save->GetMapId(), save->GetDifficultyID());
  if (!bind || !bind->perm)
  {
  player->BindToInstance(save, true);
  WorldPackets::Instance::InstanceSaveCreated data;
  data.Gm = player->IsGameMaster();
  player->GetSession()->SendPacket(data.Write());
  if (!player->IsGameMaster())
  player->GetSession()->SendCalendarRaidLockout(save, true);
  }
 
  // if the leader is not in the instance the group will not get a perm bind
  if (group && group->GetLeaderGUID() == player->GetGUID())
  group->BindToInstance(save, true);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Map.

 {
  TC_LOG_DEBUG("maps", "MAP: Removing player '%s' from instance '%u' of map '%s' before relocating to another map", player->GetName().c_str(), GetInstanceId(), GetMapName());
  //if last player set unload timer
  if (!m_unloadTimer && m_mapRefManager.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);
  // for normal instances schedule the reset after all players have left
  SetResetSchedule(true);
  sInstanceSaveMgr->UnloadInstanceSave(GetInstanceId());
 }

Here is the call graph for this function:

bool InstanceMap::Reset ( uint8 method )

 {
  // note: since the map may not be loaded when the instance needs to be reset
  // the instance must be deleted from the DB by InstanceSaveManager
 
  if (HavePlayers())
  {
  if (method == INSTANCE_RESET_ALL || method == INSTANCE_RESET_CHANGE_DIFFICULTY)
  {
  // notify the players to leave the instance so it can be reset
  for (MapRefManager::iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
  itr->GetSource()->SendResetFailedNotify(GetId());
  }
  else
  {
  bool doUnload = true;
  if (method == INSTANCE_RESET_GLOBAL)
  {
  // set the homebind timer for players inside (1 minute)
  for (MapRefManager::iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
  {
  InstancePlayerBind* bind = itr->GetSource()->GetBoundInstance(GetId(), GetDifficultyID());
  if (bind && bind->extendState && bind->save->GetInstanceId() == GetInstanceId())
  doUnload = false;
  else
  itr->GetSource()->m_InstanceValid = false;
  }
 
  if (doUnload && HasPermBoundPlayers()) // check if any unloaded players have a nonexpired save to this
  doUnload = false;
  }
 
  if (doUnload)
  {
  // the unload timer is not started
  // instead the map will unload immediately after the players have left
  m_unloadWhenEmpty = true;
  m_resetAfterUnload = true;
  }
  }
  }
  else
  {
  // unloaded at next update
  m_unloadTimer = MIN_UNLOAD_DELAY;
  m_resetAfterUnload = !(method == INSTANCE_RESET_GLOBAL && HasPermBoundPlayers());
  }
 
  return m_mapRefManager.isEmpty();
 }

Here is the call graph for this function:

void InstanceMap::SendResetWarnings ( uint32 timeLeft ) const

 {
     for (MapRefManager::const_iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
         itr->GetSource()->SendInstanceResetWarning(GetId(), itr->GetSource()->GetDifficultyID(GetEntry()), timeLeft, true);
 }

Here is the call graph for this function:

void InstanceMap::SetResetSchedule ( bool on )

 {
     // only for normal instances
     // the reset time is only scheduled when there are no payers inside
     // it is assumed that the reset time will rarely (if ever) change while the reset is scheduled
     if (IsDungeon() && !HavePlayers() && !IsRaidOrHeroicDungeon())
     {
         if (InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(GetInstanceId()))
             sInstanceSaveMgr->ScheduleReset(on, save->GetResetTime(), InstanceSaveManager::InstResetEvent(0, GetId(), Difficulty(GetSpawnMode()), GetInstanceId()));
         else
             TC_LOG_ERROR("maps", "InstanceMap::SetResetSchedule: cannot turn schedule %s, there is no save information for instance (map [id: %u, name: %s], instance id: %u, difficulty: %u)",
                 on ? "on" : "off", GetId(), GetMapName(), GetInstanceId(), Difficulty(GetSpawnMode()));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceMap::UnloadAll ( )

overridevirtual

Reimplemented from Map.

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

Here is the call graph for this function:

void InstanceMap::Update ( const uint32 t_diff )

overridevirtual

Reimplemented from Map.

 {
     Map::Update(t_diff);
 
     if (i_data)
         i_data->Update(t_diff);
 }

Here is the call graph for this function:

Member Data Documentation

InstanceScript* InstanceMap::i_data

private

uint32 InstanceMap::i_script_id

private

bool InstanceMap::m_resetAfterUnload

private

bool InstanceMap::m_unloadWhenEmpty

private

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

src/server/game/Maps/Map.h
src/server/game/Maps/Map.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation