TrinityCore: Map Class Reference

DynamicMapTree _dynamicTree

Definition: Map.h:645

Here is the caller graph for this function:

void Map::buildNGridLinkage ( NGridType * pNGridType )

inlineprivate

615 { pNGridType->link(this); }

NGrid::link

void link(GridRefManager< NGrid< N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES > > *pTo)

Definition: NGrid.h:105

Here is the call graph for this function:

Here is the caller graph for this function:

virtual EnterState Map::CannotEnter ( Player * )

inlinevirtual

Reimplemented in BattlegroundMap, InstanceMap, and MapInstanced.

386 { return CAN_ENTER; }

Map::CAN_ENTER

Definition: Map.h:373

Here is the caller graph for this function:

bool Map::CanUnload ( uint32 diff )

inline

         {
             if (!m_unloadTimer)
                 return false;
 
             if (m_unloadTimer <= diff)
                 return true;
 
             m_unloadTimer -= diff;
             return false;
         }

bool Map::CheckGridIntegrity	(	Creature *	c,
		bool	moved
	)		const

 {
     Cell const& cur_cell = c->GetCurrentCell();
     Cell xy_cell(c->GetPositionX(), c->GetPositionY());
     if (xy_cell != cur_cell)
     {
         TC_LOG_DEBUG("maps", "Creature (%s) X: %f Y: %f (%s) is in grid[%u, %u]cell[%u, %u] instead of grid[%u, %u]cell[%u, %u]",
             c->GetGUID().ToString().c_str(),
             c->GetPositionX(), c->GetPositionY(), (moved ? "final" : "original"),
             cur_cell.GridX(), cur_cell.GridY(), cur_cell.CellX(), cur_cell.CellY(),
             xy_cell.GridX(),  xy_cell.GridY(),  xy_cell.CellX(),  xy_cell.CellY());
         return true;                                        // not crash at error, just output error in debug mode
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::ContainsGameObjectModel ( const GameObjectModel & model ) const

inline

507 { return _dynamicTree.contains(model);}

DynamicMapTree::contains

bool contains(const GameObjectModel &) const

Definition: DynamicTree.cpp:127

Map::_creatureBySpawnIdStore

DynamicMapTree _dynamicTree

Definition: Map.h:645

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

 {
     Corpse* corpse = GetCorpseByPlayer(ownerGuid);
     if (!corpse)
         return nullptr;
 
     RemoveCorpse(corpse);
 
     // remove corpse from DB
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     corpse->DeleteFromDB(trans);
     CharacterDatabase.CommitTransaction(trans);
 
     Corpse* bones = NULL;
 
     // create the bones only if the map and the grid is loaded at the corpse's location
     // ignore bones creating option in case insignia
     if ((insignia ||
         (IsBattlegroundOrArena() ? sWorld->getBoolConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld->getBoolConfig(CONFIG_DEATH_BONES_WORLD))) &&
         !IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))
     {
         // Create bones, don't change Corpse
         bones = new Corpse();
         bones->Create(corpse->GetGUID().GetCounter(), this);
 
         for (uint8 i = OBJECT_FIELD_GUID + 4; i < CORPSE_END; ++i)                    // don't overwrite guid
             bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 
         bones->SetCellCoord(corpse->GetCellCoord());
         bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
 
         bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
         bones->SetGuidValue(CORPSE_FIELD_OWNER, ObjectGuid::Empty);
         bones->SetGuidValue(OBJECT_FIELD_DATA, ObjectGuid::Empty);
 
         for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
             if (corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
                 bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
 
         bones->CopyPhaseFrom(corpse);
 
         AddCorpse(bones);
 
         // add bones in grid store if grid loaded where corpse placed
         AddToMap(bones);
     }
 
     // all references to the corpse should be removed at this point
     delete corpse;
 
     return bones;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::CreatureCellRelocation	(	Creature *	creature,
		Cell	new_cell
	)

private

 {
     Cell const& old_cell = c->GetCurrentCell();
     if (!old_cell.DiffGrid(new_cell))                       // in same grid
     {
         // if in same cell then none do
         if (old_cell.DiffCell(new_cell))
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) moved in grid[%u, %u] from cell[%u, %u] to cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.CellX(), new_cell.CellY());
             #endif
 
             c->RemoveFromGrid();
             AddToGrid(c, new_cell);
         }
         else
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) moved in same grid[%u, %u]cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY());
             #endif
         }
 
         return true;
     }
 
     // in diff. grids but active creature
     if (c->isActiveObject())
     {
         EnsureGridLoadedForActiveObject(new_cell, c);
 
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "Active creature (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         c->RemoveFromGrid();
         AddToGrid(c, new_cell);
 
         return true;
     }
 
     // in diff. loaded grid normal creature
     if (IsGridLoaded(GridCoord(new_cell.GridX(), new_cell.GridY())))
     {
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         c->RemoveFromGrid();
         EnsureGridCreated(GridCoord(new_cell.GridX(), new_cell.GridY()));
         AddToGrid(c, new_cell);
 
         return true;
     }
 
     // fail to move: normal creature attempt move to unloaded grid
     #ifdef TRINITY_DEBUG
     TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) attempted to move from grid[%u, %u]cell[%u, %u] to unloaded grid[%u, %u]cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
     #endif
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

If hovering, always increase our server-side Z position Client automatically projects correct position based on Z coord sent in monster move and UNIT_FIELD_HOVERHEIGHT sent in object updates

 {
     ASSERT(CheckGridIntegrity(creature, false));
 
     Cell old_cell = creature->GetCurrentCell();
     Cell new_cell(x, y);
 
     if (!respawnRelocationOnFail && !getNGrid(new_cell.GridX(), new_cell.GridY()))
         return;
 
     if (creature->HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
         z += creature->GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
     // delay creature move for grid/cell to grid/cell moves
     if (old_cell.DiffCell(new_cell) || old_cell.DiffGrid(new_cell))
     {
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) added to moving list from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", creature->GetGUID().ToString().c_str(), creature->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
         AddCreatureToMoveList(creature, x, y, z, ang);
         // in diffcell/diffgrid case notifiers called at finishing move creature in Map::MoveAllCreaturesInMoveList
     }
     else
     {
         creature->Relocate(x, y, z, ang);
         if (creature->IsVehicle())
             creature->GetVehicleKit()->RelocatePassengers();
         creature->UpdateObjectVisibility(false);
         RemoveCreatureFromMoveList(creature);
     }
 
     ASSERT(CheckGridIntegrity(creature, true));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::CreatureRespawnRelocation	(	Creature *	c,
		bool	diffGridOnly
	)

 {
     float resp_x, resp_y, resp_z, resp_o;
     c->GetRespawnPosition(resp_x, resp_y, resp_z, &resp_o);
     Cell resp_cell(resp_x, resp_y);
 
     //creature will be unloaded with grid
     if (diffGridOnly && !c->GetCurrentCell().DiffGrid(resp_cell))
         return true;
 
     c->CombatStop();
     c->GetMotionMaster()->Clear();
 
     #ifdef TRINITY_DEBUG
     TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to respawn grid[%u, %u]cell[%u, %u].", c->GetGUID().ToString().c_str(), c->GetEntry(), c->GetCurrentCell().GridX(), c->GetCurrentCell().GridY(), c->GetCurrentCell().CellX(), c->GetCurrentCell().CellY(), resp_cell.GridX(), resp_cell.GridY(), resp_cell.CellX(), resp_cell.CellY());
     #endif
 
     // teleport it to respawn point (like normal respawn if player see)
     if (CreatureCellRelocation(c, resp_cell))
     {
         c->Relocate(resp_x, resp_y, resp_z, resp_o);
         c->GetMotionMaster()->Initialize();                 // prevent possible problems with default move generators
         //CreatureRelocationNotify(c, resp_cell, resp_cell.GetCellCoord());
         c->UpdateObjectVisibility(false);
         return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::DelayedUpdate ( const uint32 diff )

virtual

Reimplemented in MapInstanced.

 {
     for (_transportsUpdateIter = _transports.begin(); _transportsUpdateIter != _transports.end();)
     {
         Transport* transport = *_transportsUpdateIter;
         ++_transportsUpdateIter;
 
         if (!transport->IsInWorld())
             continue;
 
         transport->DelayedUpdate(t_diff);
     }
 
     RemoveAllObjectsInRemoveList();
 
     // Don't unload grids if it's battleground, since we may have manually added GOs, creatures, those doesn't load from DB at grid re-load !
     // This isn't really bother us, since as soon as we have instanced BG-s, the whole map unloads as the BG gets ended
     if (!IsBattlegroundOrArena())
     {
         for (GridRefManager<NGridType>::iterator i = GridRefManager<NGridType>::begin(); i != GridRefManager<NGridType>::end();)
         {
             NGridType *grid = i->GetSource();
             GridInfo* info = i->GetSource()->getGridInfoRef();
             ++i;                                                // The update might delete the map and we need the next map before the iterator gets invalid
             ASSERT(grid->GetGridState() >= 0 && grid->GetGridState() < MAX_GRID_STATE);
             si_GridStates[grid->GetGridState()]->Update(*this, *grid, *info, t_diff);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::DeleteCorpseData ( )

 {
     // DELETE cp, c FROM corpse_phases cp INNER JOIN corpse c ON cp.OwnerGuid = c.guid WHERE c.mapId = ? AND c.instanceId = ?
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CORPSES_FROM_MAP);
     stmt->setUInt32(0, GetId());
     stmt->setUInt32(1, GetInstanceId());
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

void Map::DeleteFromWorld ( Player * player )

Todo:: I do not know why we need this, it should be removed in ~Object anyway

 {
     ObjectAccessor::RemoveObject(player);
     RemoveUpdateObject(player); 
     delete player;
 }

Here is the call graph for this function:

template<>

void Map::DeleteFromWorld ( Transport * transport )

 {
     ObjectAccessor::RemoveObject(transport);
     delete transport;
 }

Here is the call graph for this function:

template<class T >

void Map::DeleteFromWorld ( T * obj )

private

 {
     // Note: In case resurrectable corpse and pet its removed from global lists in own destructor
     delete obj;
 }

Here is the caller graph for this function:

void Map::DeleteRespawnTimes ( )

 {
     _creatureRespawnTimes.clear();
     _goRespawnTimes.clear();
 
     DeleteRespawnTimesInDB(GetId(), GetInstanceId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::DeleteRespawnTimesInDB	(	uint16	mapId,
		uint32	instanceId
	)

static

 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN_BY_INSTANCE);
     stmt->setUInt16(0, mapId);
     stmt->setUInt32(1, instanceId);
     CharacterDatabase.Execute(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GO_RESPAWN_BY_INSTANCE);
     stmt->setUInt16(0, mapId);
     stmt->setUInt32(1, instanceId);
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::DeleteStateMachine ( )

static

 {
     delete si_GridStates[GRID_STATE_INVALID];
     delete si_GridStates[GRID_STATE_ACTIVE];
     delete si_GridStates[GRID_STATE_IDLE];
     delete si_GridStates[GRID_STATE_REMOVAL];
 }

Here is the caller graph for this function:

bool Map::DynamicObjectCellRelocation	(	DynamicObject *	go,
		Cell	new_cell
	)

private

 {
     Cell const& old_cell = go->GetCurrentCell();
     if (!old_cell.DiffGrid(new_cell))                       // in same grid
     {
         // if in same cell then none do
         if (old_cell.DiffCell(new_cell))
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "DynamicObject (%s) moved in grid[%u, %u] from cell[%u, %u] to cell[%u, %u].", go->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.CellX(), new_cell.CellY());
             #endif
 
             go->RemoveFromGrid();
             AddToGrid(go, new_cell);
         }
         else
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "DynamicObject (%s) moved in same grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY());
             #endif
         }
 
         return true;
     }
 
     // in diff. grids but active GameObject
     if (go->isActiveObject())
     {
         EnsureGridLoadedForActiveObject(new_cell, go);
 
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "Active DynamicObject (%s) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         go->RemoveFromGrid();
         AddToGrid(go, new_cell);
 
         return true;
     }
 
     // in diff. loaded grid normal GameObject
     if (IsGridLoaded(GridCoord(new_cell.GridX(), new_cell.GridY())))
     {
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "DynamicObject (%s) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         go->RemoveFromGrid();
         EnsureGridCreated(GridCoord(new_cell.GridX(), new_cell.GridY()));
         AddToGrid(go, new_cell);
 
         return true;
     }
 
     // fail to move: normal GameObject attempt move to unloaded grid
     #ifdef TRINITY_DEBUG
     TC_LOG_DEBUG("maps", "DynamicObject (%s) attempted to move from grid[%u, %u]cell[%u, %u] to unloaded grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
     #endif
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Cell integrity_check(dynObj->GetPositionX(), dynObj->GetPositionY());
     Cell old_cell = dynObj->GetCurrentCell();
 
     ASSERT(integrity_check == old_cell);
     Cell new_cell(x, y);
 
     if (!getNGrid(new_cell.GridX(), new_cell.GridY()))
         return;
 
     // delay creature move for grid/cell to grid/cell moves
     if (old_cell.DiffCell(new_cell) || old_cell.DiffGrid(new_cell))
     {
 #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "GameObject (%s) added to moving list from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", dynObj->GetGUID().ToString().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
 #endif
         AddDynamicObjectToMoveList(dynObj, x, y, z, orientation);
         // in diffcell/diffgrid case notifiers called at finishing move dynObj in Map::MoveAllGameObjectsInMoveList
     }
     else
     {
         dynObj->Relocate(x, y, z, orientation);
         dynObj->UpdateObjectVisibility(false);
         RemoveDynamicObjectFromMoveList(dynObj);
     }
 
     old_cell = dynObj->GetCurrentCell();
     integrity_check = Cell(dynObj->GetPositionX(), dynObj->GetPositionY());
     ASSERT(integrity_check == old_cell);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::EnsureGridCreated ( const GridCoord & p )

private

 {
     std::lock_guard<std::mutex> lock(_gridLock);
     EnsureGridCreated_i(p);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::EnsureGridCreated_i ( const GridCoord & p )

private

 {
     if (!getNGrid(p.x_coord, p.y_coord))
     {
         TC_LOG_DEBUG("maps", "Creating grid[%u, %u] for map %u instance %u", p.x_coord, p.y_coord, GetId(), i_InstanceId);
 
         setNGrid(new NGridType(p.x_coord*MAX_NUMBER_OF_GRIDS + p.y_coord, p.x_coord, p.y_coord, i_gridExpiry, sWorld->getBoolConfig(CONFIG_GRID_UNLOAD)),
             p.x_coord, p.y_coord);
 
         // build a linkage between this map and NGridType
         buildNGridLinkage(getNGrid(p.x_coord, p.y_coord));
 
         getNGrid(p.x_coord, p.y_coord)->SetGridState(GRID_STATE_IDLE);
 
         //z coord
         int gx = (MAX_NUMBER_OF_GRIDS - 1) - p.x_coord;
         int gy = (MAX_NUMBER_OF_GRIDS - 1) - p.y_coord;
 
         if (!GridMaps[gx][gy])
             LoadMapAndVMap(gx, gy);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::EnsureGridLoaded ( Cell const & cell )

private

 {
     EnsureGridCreated(GridCoord(cell.GridX(), cell.GridY()));
     NGridType *grid = getNGrid(cell.GridX(), cell.GridY());
 
     ASSERT(grid != NULL);
     if (!isGridObjectDataLoaded(cell.GridX(), cell.GridY()))
     {
         TC_LOG_DEBUG("maps", "Loading grid[%u, %u] for map %u instance %u", cell.GridX(), cell.GridY(), GetId(), i_InstanceId);
 
         setGridObjectDataLoaded(true, cell.GridX(), cell.GridY());
 
         LoadGridObjects(grid, cell);
 
         Balance();
         return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::EnsureGridLoadedForActiveObject	(	Cell const &	cell,
		WorldObject *	object
	)

private

 {
     EnsureGridLoaded(cell);
     NGridType *grid = getNGrid(cell.GridX(), cell.GridY());
     ASSERT(grid != NULL);
 
     // refresh grid state & timer
     if (grid->GetGridState() != GRID_STATE_ACTIVE)
     {
         TC_LOG_DEBUG("maps", "Active object %s triggers loading of grid [%u, %u] on map %u", object->GetGUID().ToString().c_str(), cell.GridX(), cell.GridY(), GetId());
         ResetGridExpiry(*grid, 0.1f);
         grid->SetGridState(GRID_STATE_ACTIVE);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::ExistMap	(	uint32	mapid,
		int	gx,
		int	gy
	)

static

 {
     std::string fileName = Trinity::StringFormat("%smaps/%04u_%02u_%02u.map", sWorld->GetDataPath().c_str(), mapid, gx, gy);
 
     bool ret = false;
     FILE* file = fopen(fileName.c_str(), "rb");
     if (!file)
     {
         TC_LOG_ERROR("maps", "Map file '%s' does not exist!", fileName.c_str());
         TC_LOG_ERROR("maps", "Please place MAP-files (*.map) in the appropriate directory (%s), or correct the DataDir setting in your worldserver.conf file.", (sWorld->GetDataPath()+"maps/").c_str());
     }
     else
     {
         map_fileheader header;
         if (fread(&header, sizeof(header), 1, file) == 1)
         {
             if (header.mapMagic.asUInt != MapMagic.asUInt || header.versionMagic.asUInt != MapVersionMagic.asUInt)
                 TC_LOG_ERROR("maps", "Map file '%s' is from an incompatible map version (%.*s %.*s), %.*s %.*s is expected. Please recreate using the mapextractor.",
                     fileName.c_str(), 4, header.mapMagic.asChar, 4, header.versionMagic.asChar, 4, MapMagic.asChar, 4, MapVersionMagic.asChar);
             else
                 ret = true;
         }
         fclose(file);
     }
 
     return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::ExistVMap	(	uint32	mapid,
		int	gx,
		int	gy
	)

static

 {
     if (VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
     {
         if (vmgr->isMapLoadingEnabled())
         {
             bool exists = vmgr->existsMap((sWorld->GetDataPath()+ "vmaps").c_str(),  mapid, gx, gy);
             if (!exists)
             {
                 std::string name = vmgr->getDirFileName(mapid, gx, gy);
                 TC_LOG_ERROR("maps", "VMap file '%s' does not exist", (sWorld->GetDataPath()+"vmaps/"+name).c_str());
                 TC_LOG_ERROR("maps", "Please place VMAP-files (*.vmtree and *.vmtile) in the vmap-directory (%s), or correct the DataDir setting in your worldserver.conf file.", (sWorld->GetDataPath()+"vmaps/").c_str());
                 return false;
             }
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::GameObjectCellRelocation	(	GameObject *	go,
		Cell	new_cell
	)

private

 {
     Cell const& old_cell = go->GetCurrentCell();
     if (!old_cell.DiffGrid(new_cell))                       // in same grid
     {
         // if in same cell then none do
         if (old_cell.DiffCell(new_cell))
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) moved in grid[%u, %u] from cell[%u, %u] to cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.CellX(), new_cell.CellY());
             #endif
 
             go->RemoveFromGrid();
             AddToGrid(go, new_cell);
         }
         else
         {
             #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) moved in same grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY());
             #endif
         }
 
         return true;
     }
 
     // in diff. grids but active GameObject
     if (go->isActiveObject())
     {
         EnsureGridLoadedForActiveObject(new_cell, go);
 
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "Active GameObject (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         go->RemoveFromGrid();
         AddToGrid(go, new_cell);
 
         return true;
     }
 
     // in diff. loaded grid normal GameObject
     if (IsGridLoaded(GridCoord(new_cell.GridX(), new_cell.GridY())))
     {
         #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
         #endif
 
         go->RemoveFromGrid();
         EnsureGridCreated(GridCoord(new_cell.GridX(), new_cell.GridY()));
         AddToGrid(go, new_cell);
 
         return true;
     }
 
     // fail to move: normal GameObject attempt move to unloaded grid
     #ifdef TRINITY_DEBUG
     TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) attempted to move from grid[%u, %u]cell[%u, %u] to unloaded grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
     #endif
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Cell integrity_check(go->GetPositionX(), go->GetPositionY());
     Cell old_cell = go->GetCurrentCell();
 
     ASSERT(integrity_check == old_cell);
     Cell new_cell(x, y);
 
     if (!respawnRelocationOnFail && !getNGrid(new_cell.GridX(), new_cell.GridY()))
         return;
 
     // delay creature move for grid/cell to grid/cell moves
     if (old_cell.DiffCell(new_cell) || old_cell.DiffGrid(new_cell))
     {
 #ifdef TRINITY_DEBUG
         TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) added to moving list from grid[%u, %u]cell[%u, %u] to grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
 #endif
         AddGameObjectToMoveList(go, x, y, z, orientation);
         // in diffcell/diffgrid case notifiers called at finishing move go in Map::MoveAllGameObjectsInMoveList
     }
     else
     {
         go->Relocate(x, y, z, orientation);
         go->UpdateModelPosition();
         go->UpdateObjectVisibility(false);
         RemoveGameObjectFromMoveList(go);
     }
 
     old_cell = go->GetCurrentCell();
     integrity_check = Cell(go->GetPositionX(), go->GetPositionY());
     ASSERT(integrity_check == old_cell);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::GameObjectRespawnRelocation	(	GameObject *	go,
		bool	diffGridOnly
	)

 {
     float resp_x, resp_y, resp_z, resp_o;
     go->GetRespawnPosition(resp_x, resp_y, resp_z, &resp_o);
     Cell resp_cell(resp_x, resp_y);
 
     //GameObject will be unloaded with grid
     if (diffGridOnly && !go->GetCurrentCell().DiffGrid(resp_cell))
         return true;
 
     #ifdef TRINITY_DEBUG
     TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) moved from grid[%u, %u]cell[%u, %u] to respawn grid[%u, %u]cell[%u, %u].", go->GetGUID().ToString().c_str(), go->GetEntry(), go->GetCurrentCell().GridX(), go->GetCurrentCell().GridY(), go->GetCurrentCell().CellX(), go->GetCurrentCell().CellY(), resp_cell.GridX(), resp_cell.GridY(), resp_cell.CellX(), resp_cell.CellY());
     #endif
 
     // teleport it to respawn point (like normal respawn if player see)
     if (GameObjectCellRelocation(go, resp_cell))
     {
         go->Relocate(resp_x, resp_y, resp_z, resp_o);
         go->UpdateObjectVisibility(false);
         return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<HighGuid high>

ObjectGuid::LowType Map::GenerateLowGuid ( )

inline

         {
             static_assert(ObjectGuidTraits<high>::MapSpecific, "Only map specific guid can be generated in Map context");
             return GetGuidSequenceGenerator<high>().Generate();
         }

Here is the caller graph for this function:

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

 {
     uint32 mogpFlags;
     int32 adtId, rootId, groupId;
     WMOAreaTableEntry const* wmoEntry = nullptr;
     AreaTableEntry const* atEntry = nullptr;
     bool haveAreaInfo = false;
 
     if (GetAreaInfo(x, y, z, mogpFlags, adtId, rootId, groupId))
     {
         haveAreaInfo = true;
         wmoEntry = GetWMOAreaTableEntryByTripple(rootId, adtId, groupId);
         if (wmoEntry)
             atEntry = sAreaTableStore.LookupEntry(wmoEntry->AreaTableID);
     }
 
     uint32 areaId = 0;
 
     if (atEntry)
         areaId = atEntry->ID;
     else
     {
         if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
             areaId = gmap->getArea(x, y);
 
         // this used while not all *.map files generated (instances)
         if (!areaId)
             areaId = i_mapEntry->AreaTableID;
     }
 
     if (isOutdoors)
     {
         if (haveAreaInfo)
             *isOutdoors = IsOutdoorWMO(mogpFlags, adtId, rootId, groupId, wmoEntry, atEntry);
         else
             *isOutdoors = true;
     }
     return areaId;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     return GetAreaId(x, y, z, nullptr);
 }

Here is the call graph for this function:

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

 {
     float vmap_z = z;
     VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
     if (vmgr->getAreaInfo(GetId(), x, y, vmap_z, flags, adtId, rootId, groupId))
     {
         // check if there's terrain between player height and object height
         if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
         {
             float _mapheight = gmap->getHeight(x, y);
             // z + 2.0f condition taken from GetHeight(), not sure if it's such a great choice...
             if (z + 2.0f > _mapheight &&  _mapheight > vmap_z)
                 return false;
         }
         return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AreaTrigger * Map::GetAreaTrigger ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<AreaTrigger>(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Corpse * Map::GetCorpse ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<Corpse>(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Corpse* Map::GetCorpseByPlayer ( ObjectGuid const & ownerGuid ) const

inline

         {
             auto itr = _corpsesByPlayer.find(ownerGuid);
             if (itr != _corpsesByPlayer.end())
                 return itr->second;
 
             return nullptr;
         }

Here is the caller graph for this function:

std::unordered_set<Corpse*> const* Map::GetCorpsesInCell ( uint32 cellId ) const

inline

         {
             auto itr = _corpsesByCell.find(cellId);
             if (itr != _corpsesByCell.end())
                 return &itr->second;
 
             return nullptr;
         }

Here is the caller graph for this function:

Creature * Map::GetCreature ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<Creature>(guid);
 }

Here is the call graph for this function:

CreatureBySpawnIdContainer& Map::GetCreatureBySpawnIdStore ( )

inline

469 { return _creatureBySpawnIdStore; }

CreatureBySpawnIdContainer _creatureBySpawnIdStore

Definition: Map.h:739

Here is the caller graph for this function:

time_t Map::GetCreatureRespawnTime ( ObjectGuid::LowType dbGuid ) const

inline

         {
             std::unordered_map<ObjectGuid::LowType /*dbGUID*/, time_t>::const_iterator itr = _creatureRespawnTimes.find(dbGuid);
             if (itr != _creatureRespawnTimes.end())
                 return itr->second;
 
             return time_t(0);
         }

Here is the caller graph for this function:

Difficulty Map::GetDifficultyID ( ) const

inline

390 { return Difficulty(GetSpawnMode()); }

Difficulty

Definition: DBCEnums.h:402

Map::GetSpawnMode

uint8 GetSpawnMode() const

Definition: Map.h:369

Here is the caller graph for this function:

uint32 Map::GetDifficultyLootBonusTreeMod ( ) const

 {
     if (MapDifficultyEntry const* mapDifficulty = GetMapDifficulty())
         if (mapDifficulty->ItemBonusTreeModID)
             return mapDifficulty->ItemBonusTreeModID;
 
     if (DifficultyEntry const* difficulty = sDifficultyStore.LookupEntry(GetDifficultyID()))
         return difficulty->ItemBonusTreeModID;
 
     return 0;
 }

Here is the call graph for this function:

DynamicObject * Map::GetDynamicObject ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<DynamicObject>(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

         {
             if (!i_mapEntry)
                 return false;
             return i_mapEntry->GetEntrancePos(mapid, x, y);
         }

MapEntry const* Map::GetEntry ( ) const

inline

266 { return i_mapEntry; }

Map::_gameobjectBySpawnIdStore

MapEntry const * i_mapEntry

Definition: Map.h:640

Here is the caller graph for this function:

GameObject * Map::GetGameObject ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<GameObject>(guid);
 }

Here is the call graph for this function:

GameObjectBySpawnIdContainer& Map::GetGameObjectBySpawnIdStore ( )

inline

472 { return _gameobjectBySpawnIdStore; }

GameObjectBySpawnIdContainer _gameobjectBySpawnIdStore

Definition: Map.h:740

Here is the caller graph for this function:

time_t Map::GetGORespawnTime ( ObjectGuid::LowType dbGuid ) const

inline

         {
             std::unordered_map<ObjectGuid::LowType /*dbGUID*/, time_t>::const_iterator itr = _goRespawnTimes.find(dbGuid);
             if (itr != _goRespawnTimes.end())
                 return itr->second;
 
             return time_t(0);
         }

Here is the caller graph for this function:

GridMap * Map::GetGrid	(	float	x,
		float	y
	)

inlineprivate

 {
     // half opt method
     int gx=(int)(CENTER_GRID_ID - x/SIZE_OF_GRIDS);                       //grid x
     int gy=(int)(CENTER_GRID_ID - y/SIZE_OF_GRIDS);                       //grid y
 
     // ensure GridMap is loaded
     EnsureGridCreated(GridCoord((MAX_NUMBER_OF_GRIDS - 1) - gx, (MAX_NUMBER_OF_GRIDS - 1) - gy));
 
     return GridMaps[gx][gy];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

time_t Map::GetGridExpiry ( void ) const

inline

324 { return i_gridExpiry; }

Map::i_gridExpiry

time_t i_gridExpiry

Definition: Map.h:671

Here is the caller graph for this function:

template<HighGuid high>

ObjectGuidGeneratorBase& Map::GetGuidSequenceGenerator ( )

inlineprivate

         {
             auto itr = _guidGenerators.find(high);
             if (itr == _guidGenerators.end())
                 itr = _guidGenerators.insert(std::make_pair(high, Trinity::make_unique<ObjectGuidGenerator<high>>())).first;
 
             return *itr->second;
         }

Here is the call graph for this function:

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

 {
     // find raw .map surface under Z coordinates
     float mapHeight = VMAP_INVALID_HEIGHT_VALUE;
     if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
     {
         float gridHeight = gmap->getHeight(x, y);
         // look from a bit higher pos to find the floor, ignore under surface case
         if (z + 2.0f > gridHeight)
             mapHeight = gridHeight;
     }
 
     float vmapHeight = VMAP_INVALID_HEIGHT_VALUE;
     if (checkVMap)
     {
         VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
         if (vmgr->isHeightCalcEnabled())
             vmapHeight = vmgr->getHeight(GetId(), x, y, z + 2.0f, maxSearchDist);   // look from a bit higher pos to find the floor
     }
 
     // mapHeight set for any above raw ground Z or <= INVALID_HEIGHT
     // vmapheight set for any under Z value or <= INVALID_HEIGHT
     if (vmapHeight > INVALID_HEIGHT)
     {
         if (mapHeight > INVALID_HEIGHT)
         {
             // we have mapheight and vmapheight and must select more appropriate
 
             // we are already under the surface or vmap height above map heigt
             // or if the distance of the vmap height is less the land height distance
             if (z < mapHeight || vmapHeight > mapHeight || std::fabs(mapHeight - z) > std::fabs(vmapHeight - z))
                 return vmapHeight;
             else
                 return mapHeight;                           // better use .map surface height
         }
         else
             return vmapHeight;                              // we have only vmapHeight (if have)
     }
 
     return mapHeight;                               // explicitly use map data
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     return std::max<float>(GetHeight(x, y, z, vmap, maxSearchDist), _dynamicTree.getHeight(x, y, z, maxSearchDist, phasemask));
 }

Here is the call graph for this function:

uint32 Map::GetId ( void ) const

inline

325 { return i_mapEntry->ID; }

MapEntry const * i_mapEntry

Definition: Map.h:640

MapEntry::ID

uint32 ID

Definition: DBCStructure.h:832

uint32 Map::GetInstanceId ( ) const

inline

368 { return i_InstanceId; }

Map::i_InstanceId

uint32 i_InstanceId

Definition: Map.h:642

Here is the caller graph for this function:

time_t Map::GetLinkedRespawnTime ( ObjectGuid guid ) const

 {
     ObjectGuid linkedGuid = sObjectMgr->GetLinkedRespawnGuid(guid);
     switch (linkedGuid.GetHigh())
     {
         case HighGuid::Creature:
             return GetCreatureRespawnTime(linkedGuid.GetCounter());
         case HighGuid::GameObject:
             return GetGORespawnTime(linkedGuid.GetCounter());
         default:
             break;
     }
 
     return time_t(0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ZLiquidStatus result = LIQUID_MAP_NO_WATER;
     VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
     float liquid_level = INVALID_HEIGHT;
     float ground_level = INVALID_HEIGHT;
     uint32 liquid_type = 0;
     if (vmgr->GetLiquidLevel(GetId(), x, y, z, ReqLiquidType, liquid_level, ground_level, liquid_type))
     {
         TC_LOG_DEBUG("maps", "getLiquidStatus(): vmap liquid level: %f ground: %f type: %u", liquid_level, ground_level, liquid_type);
         // Check water level and ground level
         if (liquid_level > ground_level && z > ground_level - 2)
         {
             // All ok in water -> store data
             if (data)
             {
                 // hardcoded in client like this
                 if (GetId() == 530 && liquid_type == 2)
                     liquid_type = 15;
 
                 uint32 liquidFlagType = 0;
                 if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(liquid_type))
                     liquidFlagType = liq->Type;
 
                 if (liquid_type && liquid_type < 21)
                 {
                     if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(GetAreaId(x, y, z)))
                     {
                         uint32 overrideLiquid = area->LiquidTypeID[liquidFlagType];
                         if (!overrideLiquid && area->ParentAreaID)
                         {
                             area = sAreaTableStore.LookupEntry(area->ParentAreaID);
                             if (area)
                                 overrideLiquid = area->LiquidTypeID[liquidFlagType];
                         }
 
                         if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(overrideLiquid))
                         {
                             liquid_type = overrideLiquid;
                             liquidFlagType = liq->Type;
                         }
                     }
                 }
 
                 data->level = liquid_level;
                 data->depth_level = ground_level;
 
                 data->entry = liquid_type;
                 data->type_flags = 1 << liquidFlagType;
             }
 
             float delta = liquid_level - z;
 
             // Get position delta
             if (delta > 2.0f)                   // Under water
                 return LIQUID_MAP_UNDER_WATER;
             if (delta > 0.0f)                   // In water
                 return LIQUID_MAP_IN_WATER;
             if (delta > -0.1f)                   // Walk on water
                 return LIQUID_MAP_WATER_WALK;
             result = LIQUID_MAP_ABOVE_WATER;
         }
     }
 
     if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
     {
         LiquidData map_data;
         ZLiquidStatus map_result = gmap->getLiquidStatus(x, y, z, ReqLiquidType, &map_data);
         // Not override LIQUID_MAP_ABOVE_WATER with LIQUID_MAP_NO_WATER:
         if (map_result != LIQUID_MAP_NO_WATER && (map_data.level > ground_level))
         {
             if (data)
             {
                 // hardcoded in client like this
                 if (GetId() == 530 && map_data.entry == 2)
                     map_data.entry = 15;
 
                 *data = map_data;
             }
             return map_result;
         }
     }
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

MapDifficultyEntry const * Map::GetMapDifficulty ( ) const

 {
     return GetMapDifficultyData(GetId(), GetDifficultyID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

char const * Map::GetMapName ( ) const

 {
     return i_mapEntry ? i_mapEntry->MapName_lang : "UNNAMEDMAP\x0";
 }

Here is the caller graph for this function:

float Map::GetMinHeight	(	float	x,
		float	y
	)		const

 {
     if (GridMap const* grid = const_cast<Map*>(this)->GetGrid(x, y))
         return grid->getMinHeight(x, y);
 
     return -500.0f;
 }

Here is the call graph for this function:

NGridType* Map::getNGrid	(	uint32	x,
		uint32	y
	)		const

inlineprivate

         {
             ASSERT(x < MAX_NUMBER_OF_GRIDS && y < MAX_NUMBER_OF_GRIDS);
             return i_grids[x][y];
         }

Here is the caller graph for this function:

bool Map::getObjectHitPos	(	uint32	phasemask,
		float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2,
		float &	rx,
		float &	ry,
		float &	rz,
		float	modifyDist
	)

 {
     G3D::Vector3 startPos(x1, y1, z1);
     G3D::Vector3 dstPos(x2, y2, z2);
 
     G3D::Vector3 resultPos;
     bool result = _dynamicTree.getObjectHitPos(phasemask, startPos, dstPos, resultPos, modifyDist);
 
     rx = resultPos.x;
     ry = resultPos.y;
     rz = resultPos.z;
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

MapStoredObjectTypesContainer& Map::GetObjectsStore ( )

inline

466 { return _objectsStore; }

Map::_objectsStore

MapStoredObjectTypesContainer _objectsStore

Definition: Map.h:738

Here is the caller graph for this function:

virtual ObjectGuid::LowType Map::GetOwnerGuildId ( uint32 = TEAM_OTHER ) const

inlinevirtual

510 { return UI64LIT(0); }

UI64LIT

#define UI64LIT(N)

Definition: Define.h:138

Map const* Map::GetParent ( ) const

inline

333 { return m_parentMap; }

Map::m_parentMap

Map * m_parentMap

Definition: Map.h:675

Here is the caller graph for this function:

Pet * Map::GetPet ( ObjectGuid const & guid )

 {
     return _objectsStore.Find<Pet>(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PlayerList const& Map::GetPlayers ( ) const

inline

433 { return m_mapRefManager; }

Map::m_mapRefManager

MapRefManager m_mapRefManager

Definition: Map.h:647

uint32 Map::GetPlayersCountExceptGMs ( ) const

 {
     uint32 count = 0;
     for (MapRefManager::const_iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
         if (!itr->GetSource()->IsGameMaster())
             ++count;
     return count;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Map::GetSpawnMode ( ) const

inline

369 { return (i_spawnMode); }

Map::i_spawnMode

uint8 i_spawnMode

Definition: Map.h:641

Here is the caller graph for this function:

uint8 Map::GetTerrainType	(	float	x,
		float	y
	)		const

 {
     if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
         return gmap->getTerrainType(x, y);
     else
         return 0;
 }

Here is the call graph for this function:

Transport * Map::GetTransport ( ObjectGuid const & guid )

 {
     if (!guid.IsMOTransport())
         return NULL;
 
     GameObject* go = GetGameObject(guid);
     return go ? go->ToTransport() : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::GetUnloadLock ( const GridCoord & p ) const

inline

313 { return getNGrid(p.x_coord, p.y_coord)->getUnloadLock(); }

NGrid::getUnloadLock

bool getUnloadLock() const

Definition: NGrid.h:114

NGridType * getNGrid(uint32 x, uint32 y) const

Definition: Map.h:617

CoordPair::y_coord

uint32 y_coord

Definition: GridDefines.h:156

CoordPair::x_coord

uint32 x_coord

Definition: GridDefines.h:155

float Map::GetVisibilityRange ( ) const

inline

290 { return m_VisibleDistance; }

Map::m_VisibleDistance

float m_VisibleDistance

Definition: Map.h:644

Here is the caller graph for this function:

float Map::GetWaterLevel	(	float	x,
		float	y
	)		const

 {
     if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(x, y))
         return gmap->getLiquidLevel(x, y);
     else
         return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float Map::GetWaterOrGroundLevel	(	float	x,
		float	y,
		float	z,
		float *	ground = `NULL`,
		bool	swim = `false`
	)		const

 {
     if (const_cast<Map*>(this)->GetGrid(x, y))
     {
         // we need ground level (including grid height version) for proper return water level in point
         float ground_z = GetHeight(PHASEMASK_NORMAL, x, y, z, true, 50.0f);
         if (ground)
             *ground = ground_z;
 
         LiquidData liquid_status;
 
         ZLiquidStatus res = getLiquidStatus(x, y, ground_z, MAP_ALL_LIQUIDS, &liquid_status);
         return res ? liquid_status.level : ground_z;
     }
 
     return VMAP_INVALID_HEIGHT_VALUE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     areaid = zoneid = GetAreaId(x, y, z);
     if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaid))
         if (area->ParentAreaID)
             zoneid = area->ParentAreaID;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     uint32 areaId = GetAreaId(x, y, z);
     if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
         if (area->ParentAreaID)
             return area->ParentAreaID;
 
     return areaId;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::HavePlayers ( ) const

inline

423 { return !m_mapRefManager.isEmpty(); }

LinkedListHead::isEmpty

bool isEmpty() const

Definition: LinkedList.h:102

Map::m_mapRefManager

MapRefManager m_mapRefManager

Definition: Map.h:647

Here is the caller graph for this function:

template<>

void Map::InitializeObject ( Creature * obj )

 {
     obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
 }

template<>

void Map::InitializeObject ( GameObject * obj )

 {
     obj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
 }

template<class T >

void Map::InitializeObject ( T * obj )

private

551 { }

Here is the caller graph for this function:

void Map::InitStateMachine ( )

static

 {
     si_GridStates[GRID_STATE_INVALID] = new InvalidState;
     si_GridStates[GRID_STATE_ACTIVE] = new ActiveState;
     si_GridStates[GRID_STATE_IDLE] = new IdleState;
     si_GridStates[GRID_STATE_REMOVAL] = new RemovalState;
 }

Here is the caller graph for this function:

void Map::InitVisibilityDistance ( )

virtual

Reimplemented in BattlegroundMap, InstanceMap, MapInstanced, and GarrisonMap.

 {
     //init visibility for continents
     m_VisibleDistance = World::GetMaxVisibleDistanceOnContinents();
     m_VisibilityNotifyPeriod = World::GetVisibilityNotifyPeriodOnContinents();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::InsertGameObjectModel ( const GameObjectModel & model )

inline

506 { _dynamicTree.insert(model); }

DynamicMapTree _dynamicTree

Definition: Map.h:645

DynamicMapTree::insert

void insert(const GameObjectModel &)

Definition: DynamicTree.cpp:117

Here is the caller graph for this function:

bool Map::Instanceable ( ) const

inline

394 { return i_mapEntry && i_mapEntry->Instanceable(); }

MapEntry const * i_mapEntry

Definition: Map.h:640

MapEntry::Instanceable

bool Instanceable() const

Definition: DBCStructure.h:859

Here is the caller graph for this function:

bool Map::Is25ManRaid ( ) const

inline

400 { return IsRaid() && (i_spawnMode == DIFFICULTY_25_N || i_spawnMode == DIFFICULTY_25_HC); } // since 25man difficulties are 1 and 3, we can check them like that

Map::IsRaid

bool IsRaid() const

Definition: Map.h:397

Map::i_spawnMode

uint8 i_spawnMode

Definition: Map.h:641

DIFFICULTY_25_N

Definition: DBCEnums.h:408

DIFFICULTY_25_HC

Definition: DBCEnums.h:410

Here is the caller graph for this function:

bool Map::IsBattleArena ( ) const

inline

402 { return i_mapEntry && i_mapEntry->IsBattleArena(); }

MapEntry::IsBattleArena

bool IsBattleArena() const

Definition: DBCStructure.h:862

MapEntry const * i_mapEntry

Definition: Map.h:640

bool Map::IsBattleground ( ) const

inline

401 { return i_mapEntry && i_mapEntry->IsBattleground(); }

MapEntry const * i_mapEntry

Definition: Map.h:640

MapEntry::IsBattleground

bool IsBattleground() const

Definition: DBCStructure.h:861

Here is the caller graph for this function:

bool Map::IsBattlegroundOrArena ( ) const

inline

403 { return i_mapEntry && i_mapEntry->IsBattlegroundOrArena(); }

MapEntry::IsBattlegroundOrArena

MapEntry const * i_mapEntry

Definition: Map.h:640

bool IsBattlegroundOrArena() const

Definition: DBCStructure.h:863

Here is the caller graph for this function:

bool Map::isCellMarked ( uint32 pCellId )

inline

420 { return marked_cells.test(pCellId); }

Map::marked_cells

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP > marked_cells

Definition: Map.h:679

Here is the caller graph for this function:

bool Map::IsDungeon ( ) const

inline

395 { return i_mapEntry && i_mapEntry->IsDungeon(); }

MapEntry const * i_mapEntry

Definition: Map.h:640

MapEntry::IsDungeon

bool IsDungeon() const

Definition: DBCStructure.h:857

Here is the caller graph for this function:

bool Map::IsGarrison ( ) const

inline

404 { return i_mapEntry && i_mapEntry->IsGarrison(); }

MapEntry::IsGarrison

bool IsGarrison() const

Definition: DBCStructure.h:882

MapEntry const * i_mapEntry

Definition: Map.h:640

Here is the caller graph for this function:

bool Map::IsGridLoaded	(	float	x,
		float	y
	)		const

inline

         {
             return IsGridLoaded(Trinity::ComputeGridCoord(x, y));
         }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::IsGridLoaded ( const GridCoord & p ) const

private

 {
     return (getNGrid(p.x_coord, p.y_coord) && isGridObjectDataLoaded(p.x_coord, p.y_coord));
 }

Here is the call graph for this function:

bool Map::isGridObjectDataLoaded	(	uint32	x,
		uint32	y
	)		const

inlineprivate

623 { return getNGrid(x, y)->isGridObjectDataLoaded(); }

NGrid::isGridObjectDataLoaded

NGridType * getNGrid(uint32 x, uint32 y) const

Definition: Map.h:617

G3D::y

G3D::int16 y

Definition: Vector2int16.h:38

G3D::x

G3D::int16 x

Definition: Vector2int16.h:37

bool isGridObjectDataLoaded() const

Definition: NGrid.h:109

Here is the caller graph for this function:

bool Map::IsHeroic ( ) const

 {
     if (DifficultyEntry const* difficulty = sDifficultyStore.LookupEntry(i_spawnMode))
         return difficulty->Flags & DIFFICULTY_FLAG_HEROIC;
     return false;
 }

Here is the caller graph for this function:

bool Map::isInLineOfSight	(	float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2,
		uint32	phasemask
	)		const

 {
     return VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(GetId(), x1, y1, z1, x2, y2, z2)
         && _dynamicTree.isInLineOfSight(x1, y1, z1, x2, y2, z2, phasemask);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     LiquidData liquid_status;
     LiquidData* liquid_ptr = data ? data : &liquid_status;
     return (getLiquidStatus(x, y, pZ, MAP_ALL_LIQUIDS, liquid_ptr) & (LIQUID_MAP_IN_WATER | LIQUID_MAP_UNDER_WATER)) != 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::IsNonRaidDungeon ( ) const

inline

396 { return i_mapEntry && i_mapEntry->IsNonRaidDungeon(); }

MapEntry::IsNonRaidDungeon

MapEntry const * i_mapEntry

Definition: Map.h:640

bool IsNonRaidDungeon() const

Definition: DBCStructure.h:858

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

 {
     uint32 mogpFlags;
     int32 adtId, rootId, groupId;
 
     // no wmo found? -> outside by default
     if (!GetAreaInfo(x, y, z, mogpFlags, adtId, rootId, groupId))
         return true;
 
     AreaTableEntry const* atEntry = nullptr;
     WMOAreaTableEntry const* wmoEntry= GetWMOAreaTableEntryByTripple(rootId, adtId, groupId);
     if (wmoEntry)
     {
         TC_LOG_DEBUG("maps", "Got WMOAreaTableEntry! flag %u, areaid %u", wmoEntry->Flags, wmoEntry->AreaTableID);
         atEntry = sAreaTableStore.LookupEntry(wmoEntry->AreaTableID);
     }
     return IsOutdoorWMO(mogpFlags, adtId, rootId, groupId, wmoEntry, atEntry);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map::IsRaid ( ) const

inline

397 { return i_mapEntry && i_mapEntry->IsRaid(); }

MapEntry const * i_mapEntry

Definition: Map.h:640

MapEntry::IsRaid

bool IsRaid() const

Definition: DBCStructure.h:860

Here is the caller graph for this function:

bool Map::IsRaidOrHeroicDungeon ( ) const

inline

398 { return IsRaid() || IsHeroic(); }

Map::IsRaid

bool IsRaid() const

Definition: Map.h:397

Map::IsHeroic

bool IsHeroic() const

Definition: Map.cpp:3420

Here is the caller graph for this function:

bool Map::IsRemovalGrid	(	float	x,
		float	y
	)		const

inline

         {
             GridCoord p = Trinity::ComputeGridCoord(x, y);
             return !getNGrid(p.x_coord, p.y_coord) || getNGrid(p.x_coord, p.y_coord)->GetGridState() == GRID_STATE_REMOVAL;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     return (getLiquidStatus(x, y, z, MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN) & LIQUID_MAP_UNDER_WATER) != 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadCorpseData ( )

 {
     std::unordered_map<ObjectGuid::LowType, std::unordered_set<uint32>> phases;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CORPSE_PHASES);
     stmt->setUInt32(0, GetId());
     stmt->setUInt32(1, GetInstanceId());
 
     //        0          1
     // SELECT OwnerGuid, PhaseId FROM corpse_phases cp LEFT JOIN corpse c ON cp.OwnerGuid = c.guid WHERE c.mapId = ? AND c.instanceId = ?
     PreparedQueryResult phaseResult = CharacterDatabase.Query(stmt);
     if (phaseResult)
     {
         do
         {
             Field* fields = phaseResult->Fetch();
             ObjectGuid::LowType guid = fields[0].GetUInt64();
             uint32 phaseId = fields[1].GetUInt32();
 
             phases[guid].insert(phaseId);
 
         } while (phaseResult->NextRow());
     }
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CORPSES);
     stmt->setUInt32(0, GetId());
     stmt->setUInt32(1, GetInstanceId());
 
     //        0     1     2     3            4      5          6          7       8       9      10        11    12          13          14
     // SELECT posX, posY, posZ, orientation, mapId, displayId, itemCache, bytes1, bytes2, flags, dynFlags, time, corpseType, instanceId, guid FROM corpse WHERE mapId = ? AND instanceId = ?
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
     if (!result)
         return;
 
     do
     {
         Field* fields = result->Fetch();
         CorpseType type = CorpseType(fields[12].GetUInt8());
         ObjectGuid::LowType guid = fields[14].GetUInt64();
         if (type >= MAX_CORPSE_TYPE || type == CORPSE_BONES)
         {
             TC_LOG_ERROR("misc", "Corpse (guid: " UI64FMTD ") have wrong corpse type (%u), not loading.", guid, type);
             continue;
         }
 
         Corpse* corpse = new Corpse(type);
         if (!corpse->LoadCorpseFromDB(GenerateLowGuid<HighGuid::Corpse>(), fields))
         {
             delete corpse;
             continue;
         }
 
         for (auto phaseId : phases[guid])
             corpse->SetInPhase(phaseId, false, true);
 
         AddCorpse(corpse);
 
     } while (result->NextRow());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadGrid	(	float	x,
		float	y
	)

 {
     EnsureGridLoaded(Cell(x, y));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protectedvirtual

Reimplemented in GarrisonMap.

 {
     ObjectGridLoader loader(*grid, this, cell);
     loader.LoadN();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadMap	(	int	gx,
		int	gy,
		bool	reload = `false`
	)

private

 {
     if (i_InstanceId != 0)
     {
         if (GridMaps[gx][gy])
             return;
 
         // load grid map for base map
         if (!m_parentMap->GridMaps[gx][gy])
             m_parentMap->EnsureGridCreated(GridCoord((MAX_NUMBER_OF_GRIDS - 1) - gx, (MAX_NUMBER_OF_GRIDS - 1) - gy));
 
         ((MapInstanced*)(m_parentMap))->AddGridMapReference(GridCoord(gx, gy));
         GridMaps[gx][gy] = m_parentMap->GridMaps[gx][gy];
         return;
     }
 
     if (GridMaps[gx][gy] && !reload)
         return;
 
     //map already load, delete it before reloading (Is it necessary? Do we really need the ability the reload maps during runtime?)
     if (GridMaps[gx][gy])
     {
         TC_LOG_DEBUG("maps", "Unloading previously loaded map %u before reloading.", GetId());
         sScriptMgr->OnUnloadGridMap(this, GridMaps[gx][gy], gx, gy);
 
         delete (GridMaps[gx][gy]);
         GridMaps[gx][gy]=NULL;
     }
 
     // map file name
     std::string fileName = Trinity::StringFormat("%smaps/%04u_%02u_%02u.map", sWorld->GetDataPath().c_str(), GetId(), gx, gy);
     TC_LOG_DEBUG("maps", "Loading map %s", fileName.c_str());
     // loading data
     GridMaps[gx][gy] = new GridMap();
     if (!GridMaps[gx][gy]->loadData(fileName.c_str()))
         TC_LOG_ERROR("maps", "Error loading map file: %s", fileName.c_str());
 
     sScriptMgr->OnLoadGridMap(this, GridMaps[gx][gy], gx, gy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadMapAndVMap	(	int	gx,
		int	gy
	)

private

 {
     LoadMap(gx, gy);
    // Only load the data for the base map
     if (i_InstanceId == 0)
     {
         LoadVMap(gx, gy);
         LoadMMap(gx, gy);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadMMap	(	int	gx,
		int	gy
	)

private

 {
     if (!DisableMgr::IsPathfindingEnabled(GetId()))
         return;
 
     bool mmapLoadResult = MMAP::MMapFactory::createOrGetMMapManager()->loadMap((sWorld->GetDataPath() + "mmaps").c_str(), GetId(), gx, gy);
 
     if (mmapLoadResult)
         TC_LOG_DEBUG("maps", "MMAP loaded name:%s, id:%d, x:%d, y:%d (mmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
     else
         TC_LOG_ERROR("maps", "Could not load MMAP name:%s, id:%d, x:%d, y:%d (mmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadRespawnTimes ( )

 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CREATURE_RESPAWNS);
     stmt->setUInt16(0, GetId());
     stmt->setUInt32(1, GetInstanceId());
     if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
     {
         do
         {
             Field* fields = result->Fetch();
             ObjectGuid::LowType loguid = fields[0].GetUInt64();
             uint32 respawnTime = fields[1].GetUInt32();
 
             _creatureRespawnTimes[loguid] = time_t(respawnTime);
         } while (result->NextRow());
     }
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GO_RESPAWNS);
     stmt->setUInt16(0, GetId());
     stmt->setUInt32(1, GetInstanceId());
     if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
     {
         do
         {
             Field* fields = result->Fetch();
             ObjectGuid::LowType loguid = fields[0].GetUInt64();
             uint32 respawnTime = fields[1].GetUInt32();
 
             _goRespawnTimes[loguid] = time_t(respawnTime);
         } while (result->NextRow());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::LoadVMap	(	int	gx,
		int	gy
	)

private

 {
     if (!VMAP::VMapFactory::createOrGetVMapManager()->isMapLoadingEnabled())
         return;
                                                             // x and y are swapped !!
     int vmapLoadResult = VMAP::VMapFactory::createOrGetVMapManager()->loadMap((sWorld->GetDataPath()+ "vmaps").c_str(),  GetId(), gx, gy);
     switch (vmapLoadResult)
     {
         case VMAP::VMAP_LOAD_RESULT_OK:
             TC_LOG_DEBUG("maps", "VMAP loaded name:%s, id:%d, x:%d, y:%d (vmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
             break;
         case VMAP::VMAP_LOAD_RESULT_ERROR:
             TC_LOG_ERROR("maps", "Could not load VMAP name:%s, id:%d, x:%d, y:%d (vmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
             break;
         case VMAP::VMAP_LOAD_RESULT_IGNORED:
             TC_LOG_DEBUG("maps", "Ignored VMAP name:%s, id:%d, x:%d, y:%d (vmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::markCell ( uint32 pCellId )

inline

421 { marked_cells.set(pCellId); }

Map::marked_cells

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP > marked_cells

Definition: Map.h:679

Here is the caller graph for this function:

void Map::MoveAllCreaturesInMoveList ( )

Todo:: pets will disappear if this is outside CreatureRespawnRelocation

 {
     _creatureToMoveLock = true;
     for (std::vector<Creature*>::iterator itr = _creaturesToMove.begin(); itr != _creaturesToMove.end(); ++itr)
     {
         Creature* c = *itr;
         if (c->FindMap() != this) //pet is teleported to another map
             continue;
 
         if (c->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
         {
             c->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
             continue;
         }
 
         c->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
         if (!c->IsInWorld())
             continue;
 
         // do move or do move to respawn or remove creature if previous all fail
         if (CreatureCellRelocation(c, Cell(c->_newPosition.m_positionX, c->_newPosition.m_positionY)))
         {
             // update pos
             c->Relocate(c->_newPosition);
             if (c->IsVehicle())
                 c->GetVehicleKit()->RelocatePassengers();
             //CreatureRelocationNotify(c, new_cell, new_cell.cellCoord());
             c->UpdateObjectVisibility(false);
         }
         else
         {
             // if creature can't be move in new cell/grid (not loaded) move it to repawn cell/grid
             // creature coordinates will be updated and notifiers send
             if (!CreatureRespawnRelocation(c, false))
             {
                 // ... or unload (if respawn grid also not loaded)
                 #ifdef TRINITY_DEBUG
                 TC_LOG_DEBUG("maps", "Creature (%s Entry: %u) cannot be move to unloaded respawn grid.", c->GetGUID().ToString().c_str(), c->GetEntry());
                 #endif
                 //AddObjectToRemoveList(Pet*) should only be called in Pet::Remove
                 //This may happen when a player just logs in and a pet moves to a nearby unloaded cell
                 //To avoid this, we can load nearby cells when player log in
                 //But this check is always needed to ensure safety
                 //need to check why pet is frequently relocated to an unloaded cell
                 if (c->IsPet())
                     ((Pet*)c)->Remove(PET_SAVE_NOT_IN_SLOT, true);
                 else
                     AddObjectToRemoveList(c);
             }
         }
     }
     _creaturesToMove.clear();
     _creatureToMoveLock = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::MoveAllDynamicObjectsInMoveList ( )

 {
     _dynamicObjectsToMoveLock = true;
     for (std::vector<DynamicObject*>::iterator itr = _dynamicObjectsToMove.begin(); itr != _dynamicObjectsToMove.end(); ++itr)
     {
         DynamicObject* dynObj = *itr;
         if (dynObj->FindMap() != this) //transport is teleported to another map
             continue;
 
         if (dynObj->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
         {
             dynObj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
             continue;
         }
 
         dynObj->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
         if (!dynObj->IsInWorld())
             continue;
 
         // do move or do move to respawn or remove creature if previous all fail
         if (DynamicObjectCellRelocation(dynObj, Cell(dynObj->_newPosition.m_positionX, dynObj->_newPosition.m_positionY)))
         {
             // update pos
             dynObj->Relocate(dynObj->_newPosition);
             dynObj->UpdateObjectVisibility(false);
         }
         else
         {
 #ifdef TRINITY_DEBUG
             TC_LOG_DEBUG("maps", "DynamicObject (%s) cannot be moved to unloaded grid.", dynObj->GetGUID().ToString().c_str());
 #endif
         }
     }
 
     _dynamicObjectsToMove.clear();
     _dynamicObjectsToMoveLock = false;
 }

Here is the call graph for this function:

void Map::MoveAllGameObjectsInMoveList ( )

 {
     _gameObjectsToMoveLock = true;
     for (std::vector<GameObject*>::iterator itr = _gameObjectsToMove.begin(); itr != _gameObjectsToMove.end(); ++itr)
     {
         GameObject* go = *itr;
         if (go->FindMap() != this) //transport is teleported to another map
             continue;
 
         if (go->_moveState != MAP_OBJECT_CELL_MOVE_ACTIVE)
         {
             go->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
             continue;
         }
 
         go->_moveState = MAP_OBJECT_CELL_MOVE_NONE;
         if (!go->IsInWorld())
             continue;
 
         // do move or do move to respawn or remove creature if previous all fail
         if (GameObjectCellRelocation(go, Cell(go->_newPosition.m_positionX, go->_newPosition.m_positionY)))
         {
             // update pos
             go->Relocate(go->_newPosition);
             go->UpdateModelPosition();
             go->UpdateObjectVisibility(false);
         }
         else
         {
             // if GameObject can't be move in new cell/grid (not loaded) move it to repawn cell/grid
             // GameObject coordinates will be updated and notifiers send
             if (!GameObjectRespawnRelocation(go, false))
             {
                 // ... or unload (if respawn grid also not loaded)
 #ifdef TRINITY_DEBUG
                 TC_LOG_DEBUG("maps", "GameObject (%s Entry: %u) cannot be move to unloaded respawn grid.", go->GetGUID().ToString().c_str(), go->GetEntry());
 #endif
                 AddObjectToRemoveList(go);
             }
         }
     }
     _gameObjectsToMove.clear();
     _gameObjectsToMoveLock = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

If hovering, always increase our server-side Z position Client automatically projects correct position based on Z coord sent in monster move and UNIT_FIELD_HOVERHEIGHT sent in object updates

 {
     ASSERT(player);
 
     Cell old_cell(player->GetPositionX(), player->GetPositionY());
     Cell new_cell(x, y);
 
     if (player->HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
         z += player->GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
     player->Relocate(x, y, z, orientation);
     if (player->IsVehicle())
         player->GetVehicleKit()->RelocatePassengers();
 
     if (old_cell.DiffGrid(new_cell) || old_cell.DiffCell(new_cell))
     {
         TC_LOG_DEBUG("maps", "Player %s relocation grid[%u, %u]cell[%u, %u]->grid[%u, %u]cell[%u, %u]", player->GetName().c_str(), old_cell.GridX(), old_cell.GridY(), old_cell.CellX(), old_cell.CellY(), new_cell.GridX(), new_cell.GridY(), new_cell.CellX(), new_cell.CellY());
 
         player->RemoveFromGrid();
 
         if (old_cell.DiffGrid(new_cell))
             EnsureGridLoadedForActiveObject(new_cell, player);
 
         AddToGrid(player, new_cell);
     }
 
     player->UpdateObjectVisibility(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::ProcessRelocationNotifies ( const uint32 diff )

private

 {
     for (GridRefManager<NGridType>::iterator i = GridRefManager<NGridType>::begin(); i != GridRefManager<NGridType>::end(); ++i)
     {
         NGridType *grid = i->GetSource();
 
         if (grid->GetGridState() != GRID_STATE_ACTIVE)
             continue;
 
         grid->getGridInfoRef()->getRelocationTimer().TUpdate(diff);
         if (!grid->getGridInfoRef()->getRelocationTimer().TPassed())
             continue;
 
         uint32 gx = grid->getX(), gy = grid->getY();
 
         CellCoord cell_min(gx*MAX_NUMBER_OF_CELLS, gy*MAX_NUMBER_OF_CELLS);
         CellCoord cell_max(cell_min.x_coord + MAX_NUMBER_OF_CELLS, cell_min.y_coord+MAX_NUMBER_OF_CELLS);
 
         for (uint32 x = cell_min.x_coord; x < cell_max.x_coord; ++x)
         {
             for (uint32 y = cell_min.y_coord; y < cell_max.y_coord; ++y)
             {
                 uint32 cell_id = (y * TOTAL_NUMBER_OF_CELLS_PER_MAP) + x;
                 if (!isCellMarked(cell_id))
                     continue;
 
                 CellCoord pair(x, y);
                 Cell cell(pair);
                 cell.SetNoCreate();
 
                 Trinity::DelayedUnitRelocation cell_relocation(cell, pair, *this, MAX_VISIBILITY_DISTANCE);
                 TypeContainerVisitor<Trinity::DelayedUnitRelocation, GridTypeMapContainer  > grid_object_relocation(cell_relocation);
                 TypeContainerVisitor<Trinity::DelayedUnitRelocation, WorldTypeMapContainer > world_object_relocation(cell_relocation);
                 Visit(cell, grid_object_relocation);
                 Visit(cell, world_object_relocation);
             }
         }
     }
 
     ResetNotifier reset;
     TypeContainerVisitor<ResetNotifier, GridTypeMapContainer >  grid_notifier(reset);
     TypeContainerVisitor<ResetNotifier, WorldTypeMapContainer > world_notifier(reset);
     for (GridRefManager<NGridType>::iterator i = GridRefManager<NGridType>::begin(); i != GridRefManager<NGridType>::end(); ++i)
     {
         NGridType *grid = i->GetSource();
 
         if (grid->GetGridState() != GRID_STATE_ACTIVE)
             continue;
 
         if (!grid->getGridInfoRef()->getRelocationTimer().TPassed())
             continue;
 
         grid->getGridInfoRef()->getRelocationTimer().TReset(diff, m_VisibilityNotifyPeriod);
 
         uint32 gx = grid->getX(), gy = grid->getY();
 
         CellCoord cell_min(gx*MAX_NUMBER_OF_CELLS, gy*MAX_NUMBER_OF_CELLS);
         CellCoord cell_max(cell_min.x_coord + MAX_NUMBER_OF_CELLS, cell_min.y_coord+MAX_NUMBER_OF_CELLS);
 
         for (uint32 x = cell_min.x_coord; x < cell_max.x_coord; ++x)
         {
             for (uint32 y = cell_min.y_coord; y < cell_max.y_coord; ++y)
             {
                 uint32 cell_id = (y * TOTAL_NUMBER_OF_CELLS_PER_MAP) + x;
                 if (!isCellMarked(cell_id))
                     continue;
 
                 CellCoord pair(x, y);
                 Cell cell(pair);
                 cell.SetNoCreate();
                 Visit(cell, grid_notifier);
                 Visit(cell, world_notifier);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveAllObjectsInRemoveList ( )

 {
     while (!i_objectsToSwitch.empty())
     {
         std::map<WorldObject*, bool>::iterator itr = i_objectsToSwitch.begin();
         WorldObject* obj = itr->first;
         bool on = itr->second;
         i_objectsToSwitch.erase(itr);
 
         if (!obj->IsPermanentWorldObject())
         {
             switch (obj->GetTypeId())
             {
                 case TYPEID_UNIT:
                     SwitchGridContainers<Creature>(obj->ToCreature(), on);
                     break;
                 case TYPEID_GAMEOBJECT:
                     SwitchGridContainers<GameObject>(obj->ToGameObject(), on);
                     break;
                 default:
                     break;
             }
         }
     }
 
     //TC_LOG_DEBUG("maps", "Object remover 1 check.");
     while (!i_objectsToRemove.empty())
     {
         std::set<WorldObject*>::iterator itr = i_objectsToRemove.begin();
         WorldObject* obj = *itr;
 
         switch (obj->GetTypeId())
         {
             case TYPEID_CORPSE:
             {
                 Corpse* corpse = ObjectAccessor::GetCorpse(*obj, obj->GetGUID());
                 if (!corpse)
                     TC_LOG_ERROR("maps", "Tried to delete corpse/bones %s that is not in map.", obj->GetGUID().ToString().c_str());
                 else
                     RemoveFromMap(corpse, true);
                 break;
             }
             case TYPEID_DYNAMICOBJECT:
                 RemoveFromMap(obj->ToDynObject(), true);
                 break;
             case TYPEID_AREATRIGGER:
                 RemoveFromMap((AreaTrigger*)obj, true);
                 break;
             case TYPEID_GAMEOBJECT:
             {
                 GameObject* go = obj->ToGameObject();
                 if (Transport* transport = go->ToTransport())
                     RemoveFromMap(transport, true);
                 else
                     RemoveFromMap(go, true);
                 break;
             }
             case TYPEID_UNIT:
                 // in case triggered sequence some spell can continue casting after prev CleanupsBeforeDelete call
                 // make sure that like sources auras/etc removed before destructor start
                 obj->ToCreature()->CleanupsBeforeDelete();
                 RemoveFromMap(obj->ToCreature(), true);
                 break;
             default:
                 TC_LOG_ERROR("maps", "Non-grid object (TypeId: %u) is in grid object remove list, ignored.", obj->GetTypeId());
                 break;
         }
 
         i_objectsToRemove.erase(itr);
     }
 
     //TC_LOG_DEBUG("maps", "Object remover 2 check.");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveAllPlayers ( )

virtual

Reimplemented in BattlegroundMap.

 {
     if (HavePlayers())
     {
         for (MapRefManager::iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
         {
             Player* player = itr->GetSource();
             if (!player->IsBeingTeleportedFar())
             {
                 // this is happening for bg
                 TC_LOG_ERROR("maps", "Map::UnloadAll: player %s is still in map %u during unload, this should not happen!", player->GetName().c_str(), GetId());
                 player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation());
             }
         }
     }
 }

Here is the call graph for this function:

void Map::RemoveCorpse ( Corpse * corpse )

 {
     ASSERT(corpse);
 
     corpse->DestroyForNearbyPlayers();
     if (corpse->IsInGrid())
         RemoveFromMap(corpse, false);
     else
     {
         corpse->RemoveFromWorld();
         corpse->ResetMap();
     }
 
     _corpsesByCell[corpse->GetCellCoord().GetId()].erase(corpse);
     if (corpse->GetType() != CORPSE_BONES)
         _corpsesByPlayer.erase(corpse->GetOwnerGUID());
     else
         _corpseBones.erase(corpse);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveCreatureFromMoveList ( Creature * c )

private

 {
     if (_creatureToMoveLock) //can this happen?
         return;
 
     if (c->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
         c->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
 }

Here is the caller graph for this function:

void Map::RemoveCreatureRespawnTime ( ObjectGuid::LowType dbGuid )

 {
     _creatureRespawnTimes.erase(dbGuid);
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN);
     stmt->setUInt64(0, dbGuid);
     stmt->setUInt16(1, GetId());
     stmt->setUInt32(2, GetInstanceId());
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveDynamicObjectFromMoveList ( DynamicObject * go )

private

 {
     if (_dynamicObjectsToMoveLock) //can this happen?
         return;
 
     if (dynObj->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
         dynObj->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
 }

Here is the caller graph for this function:

template<class T >

void Map::RemoveFromActive ( T * obj )

2992 { }

Here is the caller graph for this function:

template<>

void Map::RemoveFromActive ( Creature * c )

 {
     RemoveFromActiveHelper(c);
 
     // also allow unloading spawn grid
     if (!c->IsPet() && c->GetSpawnId())
     {
         float x, y, z;
         c->GetRespawnPosition(x, y, z);
         GridCoord p = Trinity::ComputeGridCoord(x, y);
         if (getNGrid(p.x_coord, p.y_coord))
             getNGrid(p.x_coord, p.y_coord)->decUnloadActiveLock();
         else
         {
             GridCoord p2 = Trinity::ComputeGridCoord(c->GetPositionX(), c->GetPositionY());
             TC_LOG_ERROR("maps", "Active creature (%s Entry: %u) removed from grid[%u, %u] but spawn grid[%u, %u] was not loaded.",
                 c->GetGUID().ToString().c_str(), c->GetEntry(), p.x_coord, p.y_coord, p2.x_coord, p2.y_coord);
         }
     }
 }

Here is the call graph for this function:

template<>

void Map::RemoveFromActive ( DynamicObject * obj )

 {
     RemoveFromActiveHelper(obj);
 }

Here is the call graph for this function:

void Map::RemoveFromActiveHelper ( WorldObject * obj )

inlineprivate

         {
             // Map::Update for active object in proccess
             if (m_activeNonPlayersIter != m_activeNonPlayers.end())
             {
                 ActiveNonPlayers::iterator itr = m_activeNonPlayers.find(obj);
                 if (itr == m_activeNonPlayers.end())
                     return;
                 if (itr == m_activeNonPlayersIter)
                     ++m_activeNonPlayersIter;
                 m_activeNonPlayers.erase(itr);
             }
             else
                 m_activeNonPlayers.erase(obj);
         }

Here is the caller graph for this function:

template<class T >

void Map::RemoveFromMap	(	T *	obj,
		bool	remove
	)

 {
     obj->RemoveFromWorld();
     if (obj->isActiveObject())
         RemoveFromActive(obj);
 
     obj->UpdateObjectVisibility(true);
     obj->RemoveFromGrid();
 
     obj->ResetMap();
 
     if (remove)
     {
         // if option set then object already saved at this moment
         if (!sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY))
             obj->SaveRespawnTime();
         DeleteFromWorld(obj);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

void Map::RemoveFromMap	(	Transport *	obj,
		bool	remove
	)

 {
     obj->RemoveFromWorld();
 
     Map::PlayerList const& players = GetPlayers();
     if (!players.isEmpty())
     {
         UpdateData data(GetId());
         obj->BuildOutOfRangeUpdateBlock(&data);
         WorldPacket packet;
         data.BuildPacket(&packet);
         for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
             if (itr->GetSource()->GetTransport() != obj)
                 itr->GetSource()->SendDirectMessage(&packet);
     }
 
     if (_transportsUpdateIter != _transports.end())
     {
         TransportsContainer::iterator itr = _transports.find(obj);
         if (itr == _transports.end())
             return;
         if (itr == _transportsUpdateIter)
             ++_transportsUpdateIter;
         _transports.erase(itr);
     }
     else
         _transports.erase(obj);
 
     obj->ResetMap();
 
     if (remove)
     {
         // if option set then object already saved at this moment
         if (!sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY))
             obj->SaveRespawnTime();
         DeleteFromWorld(obj);
     }
 }

Here is the call graph for this function:

void Map::RemoveGameObjectFromMoveList ( GameObject * go )

private

 {
     if (_gameObjectsToMoveLock) //can this happen?
         return;
 
     if (go->_moveState == MAP_OBJECT_CELL_MOVE_ACTIVE)
         go->_moveState = MAP_OBJECT_CELL_MOVE_INACTIVE;
 }

Here is the caller graph for this function:

void Map::RemoveGameObjectModel ( const GameObjectModel & model )

inline

505 { _dynamicTree.remove(model); }

DynamicMapTree::remove

void remove(const GameObjectModel &)

Definition: DynamicTree.cpp:122

NGrid::setGridObjectDataLoaded

DynamicMapTree _dynamicTree

Definition: Map.h:645

Here is the caller graph for this function:

void Map::RemoveGORespawnTime ( ObjectGuid::LowType dbGuid )

 {
     _goRespawnTimes.erase(dbGuid);
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GO_RESPAWN);
     stmt->setUInt64(0, dbGuid);
     stmt->setUInt16(1, GetId());
     stmt->setUInt32(2, GetInstanceId());
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveOldCorpses ( )

 {
     time_t now = time(nullptr);
 
     std::vector<ObjectGuid> corpses;
     corpses.reserve(_corpsesByPlayer.size());
 
     for (auto const& p : _corpsesByPlayer)
         if (p.second->IsExpired(now))
             corpses.push_back(p.first);
 
     for (ObjectGuid const& ownerGuid : corpses)
         ConvertCorpseToBones(ownerGuid);
 
     std::vector<Corpse*> expiredBones;
     for (Corpse* bones : _corpseBones)
         if (bones->IsExpired(now))
             expiredBones.push_back(bones);
 
     for (Corpse* bones : expiredBones)
     {
         RemoveCorpse(bones);
         delete bones;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented in BattlegroundMap, and InstanceMap.

 {
     sScriptMgr->OnPlayerLeaveMap(this, player);
 
     player->RemoveFromWorld();
     SendRemoveTransports(player);
 
     player->UpdateObjectVisibility(true);
     if (player->IsInGrid())
         player->RemoveFromGrid();
     else
         ASSERT(remove); //maybe deleted in logoutplayer when player is not in a map
 
     if (remove)
         DeleteFromWorld(player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::RemoveUpdateObject ( Object * obj )

inline

         {
             _updateObjects.erase(obj);
         }

Here is the caller graph for this function:

void Map::RemoveWorldObject ( WorldObject * obj )

inline

428 { i_worldObjects.erase(obj); }

Map::i_worldObjects

std::set< WorldObject * > i_worldObjects

Definition: Map.h:688

Here is the caller graph for this function:

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

inline

         {
             grid.ResetTimeTracker(time_t(float(i_gridExpiry)*factor));
         }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::resetMarkedCells ( )

inline

419 { marked_cells.reset(); }

Map::marked_cells

std::bitset< TOTAL_NUMBER_OF_CELLS_PER_MAP *TOTAL_NUMBER_OF_CELLS_PER_MAP > marked_cells

Definition: Map.h:679

Here is the caller graph for this function:

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

 {
     if (!respawnTime)
     {
         // Delete only
         RemoveCreatureRespawnTime(dbGuid);
         return;
     }
 
     _creatureRespawnTimes[dbGuid] = respawnTime;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CREATURE_RESPAWN);
     stmt->setUInt64(0, dbGuid);
     stmt->setUInt32(1, uint32(respawnTime));
     stmt->setUInt16(2, GetId());
     stmt->setUInt32(3, GetInstanceId());
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!respawnTime)
     {
         // Delete only
         RemoveGORespawnTime(dbGuid);
         return;
     }
 
     _goRespawnTimes[dbGuid] = respawnTime;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_GO_RESPAWN);
     stmt->setUInt64(0, dbGuid);
     stmt->setUInt32(1, uint32(respawnTime));
     stmt->setUInt16(2, GetId());
     stmt->setUInt32(3, GetInstanceId());
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

If effects should be immediate, launch the script execution

 {
     // NOTE: script record _must_ exist until command executed
 
     // prepare static data
     ObjectGuid sourceGUID = source ? source->GetGUID() : ObjectGuid::Empty;
     ObjectGuid targetGUID = target ? target->GetGUID() : ObjectGuid::Empty;
     ObjectGuid ownerGUID = (source && source->GetTypeId() == TYPEID_ITEM) ? ((Item*)source)->GetOwnerGUID() : ObjectGuid::Empty;
 
     ScriptAction sa;
     sa.sourceGUID = sourceGUID;
     sa.targetGUID = targetGUID;
     sa.ownerGUID  = ownerGUID;
 
     sa.script = &script;
     m_scriptSchedule.insert(ScriptScheduleMap::value_type(time_t(sWorld->GetGameTime() + delay), sa));
 
     sScriptMgr->IncreaseScheduledScriptsCount();
 
     if (delay == 0 && !i_scriptLock)
     {
         i_scriptLock = true;
         ScriptsProcess();
         i_scriptLock = false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::ScriptsProcess ( )

private

Process queued scripts.

Process overdue queued scripts

Todo:: Allow gameobjects to be targets and casters

 {
     if (m_scriptSchedule.empty())
         return;
 
     ScriptScheduleMap::iterator iter = m_scriptSchedule.begin();
     // ok as multimap is a *sorted* associative container
     while (!m_scriptSchedule.empty() && (iter->first <= sWorld->GetGameTime()))
     {
         ScriptAction const& step = iter->second;
 
         Object* source = NULL;
         if (!step.sourceGUID.IsEmpty())
         {
             switch (step.sourceGUID.GetHigh())
             {
                 case HighGuid::Item: // as well as HIGHGUID_CONTAINER
                     if (Player* player = HashMapHolder<Player>::Find(step.ownerGUID))
                         source = player->GetItemByGuid(step.sourceGUID);
                     break;
                 case HighGuid::Creature:
                 case HighGuid::Vehicle:
                     source = GetCreature(step.sourceGUID);
                     break;
                 case HighGuid::Pet:
                     source = GetPet(step.sourceGUID);
                     break;
                 case HighGuid::Player:
                     source = HashMapHolder<Player>::Find(step.sourceGUID);
                     break;
                 case HighGuid::GameObject:
                     source = GetGameObject(step.sourceGUID);
                     break;
                 case HighGuid::Corpse:
                     source = GetCorpse(step.sourceGUID);
                     break;
                 case HighGuid::Transport:
                     source = GetTransport(step.sourceGUID);
                     break;
                 default:
                     TC_LOG_ERROR("scripts", "%s source with unsupported high guid %s.",
                         step.script->GetDebugInfo().c_str(), step.sourceGUID.ToString().c_str());
                     break;
             }
         }
 
         WorldObject* target = NULL;
         if (!step.targetGUID.IsEmpty())
         {
             switch (step.targetGUID.GetHigh())
             {
                 case HighGuid::Creature:
                 case HighGuid::Vehicle:
                     target = GetCreature(step.targetGUID);
                     break;
                 case HighGuid::Pet:
                     target = GetPet(step.targetGUID);
                     break;
                 case HighGuid::Player:
                     target = HashMapHolder<Player>::Find(step.targetGUID);
                     break;
                 case HighGuid::GameObject:
                     target = GetGameObject(step.targetGUID);
                     break;
                 case HighGuid::Corpse:
                     target = GetCorpse(step.targetGUID);
                     break;
                 case HighGuid::Transport:
                     target = GetTransport(step.targetGUID);
                     break;
                 default:
                     TC_LOG_ERROR("scripts", "%s target with unsupported high guid %s.",
                         step.script->GetDebugInfo().c_str(), step.targetGUID.ToString().c_str());
                     break;
             }
         }
 
         switch (step.script->command)
         {
             case SCRIPT_COMMAND_TALK:
             {
                 if (step.script->Talk.ChatType > CHAT_TYPE_BOSS_WHISPER)
                 {
                     TC_LOG_ERROR("scripts", "%s invalid chat type (%u) specified, skipping.", step.script->GetDebugInfo().c_str(), step.script->Talk.ChatType);
                     break;
                 }
 
                 if (step.script->Talk.Flags & SF_TALK_USE_PLAYER)
                     source = _GetScriptPlayerSourceOrTarget(source, target, step.script);
                 else
                     source = _GetScriptCreatureSourceOrTarget(source, target, step.script);
 
                 if (source)
                 {
                     Unit* sourceUnit = source->ToUnit();
                     if (!sourceUnit)
                     {
                         TC_LOG_ERROR("scripts", "%s source object (%s) is not an unit, skipping.", step.script->GetDebugInfo().c_str(), source->GetGUID().ToString().c_str());
                         break;
                     }
 
                     switch (step.script->Talk.ChatType)
                     {
                         case CHAT_TYPE_SAY:
                             sourceUnit->Say(step.script->Talk.TextID, target);
                             break;
                         case CHAT_TYPE_YELL:
                             sourceUnit->Yell(step.script->Talk.TextID, target);
                             break;
                         case CHAT_TYPE_TEXT_EMOTE:
                         case CHAT_TYPE_BOSS_EMOTE:
                             sourceUnit->TextEmote(step.script->Talk.TextID, target, step.script->Talk.ChatType == CHAT_TYPE_BOSS_EMOTE);
                             break;
                         case CHAT_TYPE_WHISPER:
                         case CHAT_TYPE_BOSS_WHISPER:
                         {
                             Player* receiver = target ? target->ToPlayer() : nullptr;
                             if (!receiver)
                                 TC_LOG_ERROR("scripts", "%s attempt to whisper to non-player unit, skipping.", step.script->GetDebugInfo().c_str());
                             else
                                 sourceUnit->Whisper(step.script->Talk.TextID, receiver, step.script->Talk.ChatType == CHAT_TYPE_BOSS_WHISPER);
                             break;
                         }
                         default:
                             break;                              // must be already checked at load
                     }
                 }
                 break;
             }
 
             case SCRIPT_COMMAND_EMOTE:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     if (step.script->Emote.Flags & SF_EMOTE_USE_STATE)
                         cSource->SetUInt32Value(UNIT_NPC_EMOTESTATE, step.script->Emote.EmoteID);
                     else
                         cSource->HandleEmoteCommand(step.script->Emote.EmoteID);
                 }
                 break;
 
             case SCRIPT_COMMAND_FIELD_SET:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     // Validate field number.
                     if (step.script->FieldSet.FieldID <= OBJECT_FIELD_ENTRY || step.script->FieldSet.FieldID >= cSource->GetValuesCount())
                         TC_LOG_ERROR("scripts", "%s wrong field %u (max count: %u) in object (TypeId: %u, %s) specified, skipping.",
                             step.script->GetDebugInfo().c_str(), step.script->FieldSet.FieldID,
                             cSource->GetValuesCount(), cSource->GetTypeId(), cSource->GetGUID().ToString().c_str());
                     else
                         cSource->SetUInt32Value(step.script->FieldSet.FieldID, step.script->FieldSet.FieldValue);
                 }
                 break;
 
             case SCRIPT_COMMAND_MOVE_TO:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     Unit* unit = (Unit*)cSource;
                     if (step.script->MoveTo.TravelTime != 0)
                     {
                         float speed = unit->GetDistance(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ) / ((float)step.script->MoveTo.TravelTime * 0.001f);
                         unit->MonsterMoveWithSpeed(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, speed);
                     }
                     else
                         unit->NearTeleportTo(step.script->MoveTo.DestX, step.script->MoveTo.DestY, step.script->MoveTo.DestZ, unit->GetOrientation());
                 }
                 break;
 
             case SCRIPT_COMMAND_FLAG_SET:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     // Validate field number.
                     if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                     {
                         TC_LOG_ERROR("scripts", "%s wrong field %u (max count: %u) in object (TypeId: %u, Entry: %u, %s) specified, skipping.",
                             step.script->GetDebugInfo().c_str(), step.script->FlagToggle.FieldID,
                             cSource->GetValuesCount(), cSource->GetTypeId(), cSource->GetEntry(), cSource->GetGUID().ToString().c_str());
                     }
                     else
                         cSource->SetFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                 }
                 break;
 
             case SCRIPT_COMMAND_FLAG_REMOVE:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     // Validate field number.
                     if (step.script->FlagToggle.FieldID <= OBJECT_FIELD_ENTRY || step.script->FlagToggle.FieldID >= cSource->GetValuesCount())
                     {
                         TC_LOG_ERROR("scripts", "%s wrong field %u (max count: %u) in object (TypeId: %u, Entry: %u, %s) specified, skipping.",
                             step.script->GetDebugInfo().c_str(), step.script->FlagToggle.FieldID,
                             cSource->GetValuesCount(), cSource->GetTypeId(), cSource->GetEntry(), cSource->GetGUID().ToString().c_str());
                     }
                     else
                         cSource->RemoveFlag(step.script->FlagToggle.FieldID, step.script->FlagToggle.FieldValue);
                 }
                 break;
 
             case SCRIPT_COMMAND_TELEPORT_TO:
                 if (step.script->TeleportTo.Flags & SF_TELEPORT_USE_CREATURE)
                 {
                     // Source or target must be Creature.
                     if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                         cSource->NearTeleportTo(step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                 }
                 else
                 {
                     // Source or target must be Player.
                     if (Player* player = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                         player->TeleportTo(step.script->TeleportTo.MapID, step.script->TeleportTo.DestX, step.script->TeleportTo.DestY, step.script->TeleportTo.DestZ, step.script->TeleportTo.Orientation);
                 }
                 break;
 
             case SCRIPT_COMMAND_QUEST_EXPLORED:
             {
                 if (!source)
                 {
                     TC_LOG_ERROR("scripts", "%s source object is NULL.", step.script->GetDebugInfo().c_str());
                     break;
                 }
                 if (!target)
                 {
                     TC_LOG_ERROR("scripts", "%s target object is NULL.", step.script->GetDebugInfo().c_str());
                     break;
                 }
 
                 // when script called for item spell casting then target == (unit or GO) and source is player
                 WorldObject* worldObject;
                 Player* player = target->ToPlayer();
                 if (player)
                 {
                     if (source->GetTypeId() != TYPEID_UNIT && source->GetTypeId() != TYPEID_GAMEOBJECT && source->GetTypeId() != TYPEID_PLAYER)
                     {
                         TC_LOG_ERROR("scripts", "%s source is not unit, gameobject or player (TypeId: %u, Entry: %u, %s), skipping.",
                             step.script->GetDebugInfo().c_str(), source->GetTypeId(), source->GetEntry(), source->GetGUID().ToString().c_str());
                         break;
                     }
                     worldObject = dynamic_cast<WorldObject*>(source);
                 }
                 else
                 {
                     player = source->ToPlayer();
                     if (player)
                     {
                         if (target->GetTypeId() != TYPEID_UNIT && target->GetTypeId() != TYPEID_GAMEOBJECT && target->GetTypeId() != TYPEID_PLAYER)
                         {
                             TC_LOG_ERROR("scripts", "%s target is not unit, gameobject or player (TypeId: %u, Entry: %u, %s), skipping.",
                                 step.script->GetDebugInfo().c_str(), target->GetTypeId(), target->GetEntry(), target->GetGUID().ToString().c_str());
                             break;
                         }
                         worldObject = dynamic_cast<WorldObject*>(target);
                     }
                     else
                     {
                         TC_LOG_ERROR("scripts", "%s neither source nor target is player (Entry: %u, GUID: %s; target: Entry: %u, GUID: %s), skipping.",
                             step.script->GetDebugInfo().c_str(), source->GetEntry(), source->GetGUID().ToString().c_str(),
                             target->GetEntry(), target->GetGUID().ToString().c_str());
                         break;
                     }
                 }
 
                 // quest id and flags checked at script loading
                 if ((worldObject->GetTypeId() != TYPEID_UNIT || ((Unit*)worldObject)->IsAlive()) &&
                     (step.script->QuestExplored.Distance == 0 || worldObject->IsWithinDistInMap(player, float(step.script->QuestExplored.Distance))))
                     player->AreaExploredOrEventHappens(step.script->QuestExplored.QuestID);
                 else
                     player->FailQuest(step.script->QuestExplored.QuestID);
 
                 break;
             }
 
             case SCRIPT_COMMAND_KILL_CREDIT:
                 // Source or target must be Player.
                 if (Player* player = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                 {
                     if (step.script->KillCredit.Flags & SF_KILLCREDIT_REWARD_GROUP)
                         player->RewardPlayerAndGroupAtEvent(step.script->KillCredit.CreatureEntry, player);
                     else
                         player->KilledMonsterCredit(step.script->KillCredit.CreatureEntry);
                 }
                 break;
 
             case SCRIPT_COMMAND_RESPAWN_GAMEOBJECT:
                 if (!step.script->RespawnGameobject.GOGuid)
                 {
                     TC_LOG_ERROR("scripts", "%s gameobject guid (datalong) is not specified.", step.script->GetDebugInfo().c_str());
                     break;
                 }
 
                 // Source or target must be WorldObject.
                 if (WorldObject* pSummoner = _GetScriptWorldObject(source, true, step.script))
                 {
                     GameObject* pGO = _FindGameObject(pSummoner, step.script->RespawnGameobject.GOGuid);
                     if (!pGO)
                     {
                         TC_LOG_ERROR("scripts", "%s gameobject was not found (guid: %u).", step.script->GetDebugInfo().c_str(), step.script->RespawnGameobject.GOGuid);
                         break;
                     }
 
                     if (pGO->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE ||
                         pGO->GetGoType() == GAMEOBJECT_TYPE_DOOR        ||
                         pGO->GetGoType() == GAMEOBJECT_TYPE_BUTTON      ||
                         pGO->GetGoType() == GAMEOBJECT_TYPE_TRAP)
                     {
                         TC_LOG_ERROR("scripts", "%s can not be used with gameobject of type %u (guid: %u).",
                             step.script->GetDebugInfo().c_str(), uint32(pGO->GetGoType()), step.script->RespawnGameobject.GOGuid);
                         break;
                     }
 
                     // Check that GO is not spawned
                     if (!pGO->isSpawned())
                     {
                         int32 nTimeToDespawn = std::max(5, int32(step.script->RespawnGameobject.DespawnDelay));
                         pGO->SetLootState(GO_READY);
                         pGO->SetRespawnTime(nTimeToDespawn);
 
                         pGO->GetMap()->AddToMap(pGO);
                     }
                 }
                 break;
 
             case SCRIPT_COMMAND_TEMP_SUMMON_CREATURE:
             {
                 // Source must be WorldObject.
                 if (WorldObject* pSummoner = _GetScriptWorldObject(source, true, step.script))
                 {
                     if (!step.script->TempSummonCreature.CreatureEntry)
                         TC_LOG_ERROR("scripts", "%s creature entry (datalong) is not specified.", step.script->GetDebugInfo().c_str());
                     else
                     {
                         float x = step.script->TempSummonCreature.PosX;
                         float y = step.script->TempSummonCreature.PosY;
                         float z = step.script->TempSummonCreature.PosZ;
                         float o = step.script->TempSummonCreature.Orientation;
 
                         if (!pSummoner->SummonCreature(step.script->TempSummonCreature.CreatureEntry, x, y, z, o, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, step.script->TempSummonCreature.DespawnDelay))
                             TC_LOG_ERROR("scripts", "%s creature was not spawned (entry: %u).", step.script->GetDebugInfo().c_str(), step.script->TempSummonCreature.CreatureEntry);
                     }
                 }
                 break;
             }
 
             case SCRIPT_COMMAND_OPEN_DOOR:
             case SCRIPT_COMMAND_CLOSE_DOOR:
                 _ScriptProcessDoor(source, target, step.script);
                 break;
 
             case SCRIPT_COMMAND_ACTIVATE_OBJECT:
                 // Source must be Unit.
                 if (Unit* unit = _GetScriptUnit(source, true, step.script))
                 {
                     // Target must be GameObject.
                     if (!target)
                     {
                         TC_LOG_ERROR("scripts", "%s target object is NULL.", step.script->GetDebugInfo().c_str());
                         break;
                     }
 
                     if (target->GetTypeId() != TYPEID_GAMEOBJECT)
                     {
                         TC_LOG_ERROR("scripts", "%s target object is not gameobject (TypeId: %u, Entry: %u, %s), skipping.",
                             step.script->GetDebugInfo().c_str(), target->GetTypeId(), target->GetEntry(), target->GetGUID().ToString().c_str());
                         break;
                     }
 
                     if (GameObject* pGO = target->ToGameObject())
                         pGO->Use(unit);
                 }
                 break;
 
             case SCRIPT_COMMAND_REMOVE_AURA:
             {
                 // Source (datalong2 != 0) or target (datalong2 == 0) must be Unit.
                 bool bReverse = step.script->RemoveAura.Flags & SF_REMOVEAURA_REVERSE;
                 if (Unit* unit = _GetScriptUnit(bReverse ? source : target, bReverse, step.script))
                     unit->RemoveAurasDueToSpell(step.script->RemoveAura.SpellID);
                 break;
             }
 
             case SCRIPT_COMMAND_CAST_SPELL:
             {
                 if (!source && !target)
                 {
                     TC_LOG_ERROR("scripts", "%s source and target objects are NULL.", step.script->GetDebugInfo().c_str());
                     break;
                 }
 
                 Unit* uSource = NULL;
                 Unit* uTarget = NULL;
                 // source/target cast spell at target/source (script->datalong2: 0: s->t 1: s->s 2: t->t 3: t->s
                 switch (step.script->CastSpell.Flags)
                 {
                     case SF_CASTSPELL_SOURCE_TO_TARGET: // source -> target
                         uSource = source ? source->ToUnit() : NULL;
                         uTarget = target ? target->ToUnit() : NULL;
                         break;
                     case SF_CASTSPELL_SOURCE_TO_SOURCE: // source -> source
                         uSource = source ? source->ToUnit() : NULL;
                         uTarget = uSource;
                         break;
                     case SF_CASTSPELL_TARGET_TO_TARGET: // target -> target
                         uSource = target ? target->ToUnit() : NULL;
                         uTarget = uSource;
                         break;
                     case SF_CASTSPELL_TARGET_TO_SOURCE: // target -> source
                         uSource = target ? target->ToUnit() : NULL;
                         uTarget = source ? source->ToUnit() : NULL;
                         break;
                     case SF_CASTSPELL_SEARCH_CREATURE: // source -> creature with entry
                         uSource = source ? source->ToUnit() : NULL;
                         uTarget = uSource ? GetClosestCreatureWithEntry(uSource, abs(step.script->CastSpell.CreatureEntry), step.script->CastSpell.SearchRadius) : NULL;
                         break;
                 }
 
                 if (!uSource || !uSource->isType(TYPEMASK_UNIT))
                 {
                     TC_LOG_ERROR("scripts", "%s no source unit found for spell %u", step.script->GetDebugInfo().c_str(), step.script->CastSpell.SpellID);
                     break;
                 }
 
                 if (!uTarget || !uTarget->isType(TYPEMASK_UNIT))
                 {
                     TC_LOG_ERROR("scripts", "%s no target unit found for spell %u", step.script->GetDebugInfo().c_str(), step.script->CastSpell.SpellID);
                     break;
                 }
 
                 bool triggered = (step.script->CastSpell.Flags != 4) ?
                     step.script->CastSpell.CreatureEntry & SF_CASTSPELL_TRIGGERED :
                     step.script->CastSpell.CreatureEntry < 0;
                 uSource->CastSpell(uTarget, step.script->CastSpell.SpellID, triggered);
                 break;
             }
 
             case SCRIPT_COMMAND_PLAY_SOUND:
                 // Source must be WorldObject.
                 if (WorldObject* object = _GetScriptWorldObject(source, true, step.script))
                 {
                     // PlaySound.Flags bitmask: 0/1=anyone/target
                     Player* player = NULL;
                     if (step.script->PlaySound.Flags & SF_PLAYSOUND_TARGET_PLAYER)
                     {
                         // Target must be Player.
                         player = _GetScriptPlayer(target, false, step.script);
                         if (!target)
                             break;
                     }
 
                     // PlaySound.Flags bitmask: 0/2=without/with distance dependent
                     if (step.script->PlaySound.Flags & SF_PLAYSOUND_DISTANCE_SOUND)
                         object->PlayDistanceSound(step.script->PlaySound.SoundID, player);
                     else
                         object->PlayDirectSound(step.script->PlaySound.SoundID, player);
                 }
                 break;
 
             case SCRIPT_COMMAND_CREATE_ITEM:
                 // Target or source must be Player.
                 if (Player* pReceiver = _GetScriptPlayerSourceOrTarget(source, target, step.script))
                 {
                     ItemPosCountVec dest;
                     InventoryResult msg = pReceiver->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, step.script->CreateItem.ItemEntry, step.script->CreateItem.Amount);
                     if (msg == EQUIP_ERR_OK)
                     {
                         if (Item* item = pReceiver->StoreNewItem(dest, step.script->CreateItem.ItemEntry, true))
                             pReceiver->SendNewItem(item, step.script->CreateItem.Amount, false, true);
                     }
                     else
                         pReceiver->SendEquipError(msg, NULL, NULL, step.script->CreateItem.ItemEntry);
                 }
                 break;
 
             case SCRIPT_COMMAND_DESPAWN_SELF:
                 // Target or source must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script, true))
                     cSource->DespawnOrUnsummon(step.script->DespawnSelf.DespawnDelay);
                 break;
 
             case SCRIPT_COMMAND_LOAD_PATH:
                 // Source must be Unit.
                 if (Unit* unit = _GetScriptUnit(source, true, step.script))
                 {
                     if (!sWaypointMgr->GetPath(step.script->LoadPath.PathID))
                         TC_LOG_ERROR("scripts", "%s source object has an invalid path (%u), skipping.", step.script->GetDebugInfo().c_str(), step.script->LoadPath.PathID);
                     else
                         unit->GetMotionMaster()->MovePath(step.script->LoadPath.PathID, step.script->LoadPath.IsRepeatable != 0);
                 }
                 break;
 
             case SCRIPT_COMMAND_CALLSCRIPT_TO_UNIT:
             {
                 if (!step.script->CallScript.CreatureEntry)
                 {
                     TC_LOG_ERROR("scripts", "%s creature entry is not specified, skipping.", step.script->GetDebugInfo().c_str());
                     break;
                 }
                 if (!step.script->CallScript.ScriptID)
                 {
                     TC_LOG_ERROR("scripts", "%s script id is not specified, skipping.", step.script->GetDebugInfo().c_str());
                     break;
                 }
 
                 Creature* cTarget = NULL;
                 auto creatureBounds = _creatureBySpawnIdStore.equal_range(step.script->CallScript.CreatureEntry);
                 if (creatureBounds.first != creatureBounds.second)
                 {
                     // Prefer alive (last respawned) creature
                     auto creatureItr = std::find_if(creatureBounds.first, creatureBounds.second, [](Map::CreatureBySpawnIdContainer::value_type const& pair)
                     {
                         return pair.second->IsAlive();
                     });
 
                     cTarget = creatureItr != creatureBounds.second ? creatureItr->second : creatureBounds.first->second;
                 }
 
                 if (!cTarget)
                 {
                     TC_LOG_ERROR("scripts", "%s target was not found (entry: %u)", step.script->GetDebugInfo().c_str(), step.script->CallScript.CreatureEntry);
                     break;
                 }
 
                 //Lets choose our ScriptMap map
                 ScriptMapMap* datamap = GetScriptsMapByType(ScriptsType(step.script->CallScript.ScriptType));
                 //if no scriptmap present...
                 if (!datamap)
                 {
                     TC_LOG_ERROR("scripts", "%s unknown scriptmap (%u) specified, skipping.", step.script->GetDebugInfo().c_str(), step.script->CallScript.ScriptType);
                     break;
                 }
 
                 // Insert script into schedule but do not start it
                 ScriptsStart(*datamap, step.script->CallScript.ScriptID, cTarget, NULL);
                 break;
             }
 
             case SCRIPT_COMMAND_KILL:
                 // Source or target must be Creature.
                 if (Creature* cSource = _GetScriptCreatureSourceOrTarget(source, target, step.script))
                 {
                     if (cSource->isDead())
                     {
                         TC_LOG_ERROR("scripts", "%s creature is already dead (Entry: %u, %s)",
                             step.script->GetDebugInfo().c_str(), cSource->GetEntry(), cSource->GetGUID().ToString().c_str());
                     }
                     else
                     {
                         cSource->setDeathState(JUST_DIED);
                         if (step.script->Kill.RemoveCorpse == 1)
                             cSource->RemoveCorpse();
                     }
                 }
                 break;
 
             case SCRIPT_COMMAND_ORIENTATION:
                 // Source must be Unit.
                 if (Unit* sourceUnit = _GetScriptUnit(source, true, step.script))
                 {
                     if (step.script->Orientation.Flags & SF_ORIENTATION_FACE_TARGET)
                     {
                         // Target must be Unit.
                         Unit* targetUnit = _GetScriptUnit(target, false, step.script);
                         if (!targetUnit)
                             break;
 
                         sourceUnit->SetFacingToObject(targetUnit);
                     }
                     else
                         sourceUnit->SetFacingTo(step.script->Orientation.Orientation);
                 }
                 break;
 
             case SCRIPT_COMMAND_EQUIP:
                 // Source must be Creature.
                 if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                     cSource->LoadEquipment(step.script->Equip.EquipmentID);
                 break;
 
             case SCRIPT_COMMAND_MODEL:
                 // Source must be Creature.
                 if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                     cSource->SetDisplayId(step.script->Model.ModelID);
                 break;
 
             case SCRIPT_COMMAND_CLOSE_GOSSIP:
                 // Source must be Player.
                 if (Player* player = _GetScriptPlayer(source, true, step.script))
                     player->PlayerTalkClass->SendCloseGossip();
                 break;
 
             case SCRIPT_COMMAND_PLAYMOVIE:
                 // Source must be Player.
                 if (Player* player = _GetScriptPlayer(source, true, step.script))
                     player->SendMovieStart(step.script->PlayMovie.MovieID);
                 break;
 
             case SCRIPT_COMMAND_PLAY_ANIMKIT:
                 // Source must be Creature.
                 if (Creature* cSource = _GetScriptCreature(source, true, step.script))
                     cSource->PlayOneShotAnimKitId(step.script->PlayAnimKit.AnimKitID);
                 break;
 
             default:
                 TC_LOG_ERROR("scripts", "Unknown script command %s.", step.script->GetDebugInfo().c_str());
                 break;
         }
 
         m_scriptSchedule.erase(iter);
         iter = m_scriptSchedule.begin();
         sScriptMgr->DecreaseScheduledScriptCount();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::ScriptsStart	(	std::map< uint32, std::multimap< uint32, ScriptInfo > > const &	scripts,
		uint32	id,
		Object *	source,
		Object *	target
	)

Put scripts in the execution queue.

Find the script map
Schedule script execution for all scripts in the script map
If one of the effects should be immediate, launch the script execution

 {
     ScriptMapMap::const_iterator s = scripts.find(id);
     if (s == scripts.end())
         return;
 
     // prepare static data
     ObjectGuid sourceGUID = source ? source->GetGUID() : ObjectGuid::Empty; //some script commands doesn't have source
     ObjectGuid targetGUID = target ? target->GetGUID() : ObjectGuid::Empty;
     ObjectGuid ownerGUID = (source && source->GetTypeId() == TYPEID_ITEM) ? ((Item*)source)->GetOwnerGUID() : ObjectGuid::Empty;
 
     ScriptMap const* s2 = &(s->second);
     bool immedScript = false;
     for (ScriptMap::const_iterator iter = s2->begin(); iter != s2->end(); ++iter)
     {
         ScriptAction sa;
         sa.sourceGUID = sourceGUID;
         sa.targetGUID = targetGUID;
         sa.ownerGUID  = ownerGUID;
 
         sa.script = &iter->second;
         m_scriptSchedule.insert(ScriptScheduleMap::value_type(time_t(sWorld->GetGameTime() + iter->first), sa));
         if (iter->first == 0)
             immedScript = true;
 
         sScriptMgr->IncreaseScheduledScriptsCount();
     }
     if (/*start &&*/ immedScript && !i_scriptLock)
     {
         i_scriptLock = true;
         ScriptsProcess();
         i_scriptLock = false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::SendInitSelf ( Player * player )

private

 {
     TC_LOG_DEBUG("maps", "Creating player data for himself %s", player->GetGUID().ToString().c_str());
 
     UpdateData data(player->GetMapId());
 
     // attach to player data current transport data
     if (Transport* transport = player->GetTransport())
     {
         transport->BuildCreateUpdateBlockForPlayer(&data, player);
     }
 
     // build data for self presence in world at own client (one time for map)
     player->BuildCreateUpdateBlockForPlayer(&data, player);
 
     // build other passengers at transport also (they always visible and marked as visible and will not send at visibility update at add to map
     if (Transport* transport = player->GetTransport())
         for (Transport::PassengerSet::const_iterator itr = transport->GetPassengers().begin(); itr != transport->GetPassengers().end(); ++itr)
             if (player != (*itr) && player->HaveAtClient(*itr))
                 (*itr)->BuildCreateUpdateBlockForPlayer(&data, player);
 
     WorldPacket packet;
     data.BuildPacket(&packet);
     player->GetSession()->SendPacket(&packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::SendInitTransports ( Player * player )

 {
     // Hack to send out transports
     UpdateData transData(player->GetMapId());
     for (TransportsContainer::const_iterator i = _transports.begin(); i != _transports.end(); ++i)
         if (*i != player->GetTransport() && player->IsInPhase(*i))
             (*i)->BuildCreateUpdateBlockForPlayer(&transData, player);
 
     WorldPacket packet;
     transData.BuildPacket(&packet);
     player->GetSession()->SendPacket(&packet);
 }

Here is the caller graph for this function:

void Map::SendObjectUpdates ( )

private

 {
     UpdateDataMapType update_players;
 
     while (!_updateObjects.empty())
     {
         Object* obj = *_updateObjects.begin();
         ASSERT(obj->IsInWorld());
         _updateObjects.erase(_updateObjects.begin());
         obj->BuildUpdate(update_players);
     }
 
     WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
     for (UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
     {
         iter->second.BuildPacket(&packet);
         iter->first->GetSession()->SendPacket(&packet);
         packet.clear();                                     // clean the string
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::SendRemoveTransports ( Player * player )

 {
     // Hack to send out transports
     UpdateData transData(player->GetMapId());
     for (TransportsContainer::const_iterator i = _transports.begin(); i != _transports.end(); ++i)
         if (*i != player->GetTransport())
             (*i)->BuildOutOfRangeUpdateBlock(&transData);
 
     WorldPacket packet;
     transData.BuildPacket(&packet);
     player->GetSession()->SendPacket(&packet);
 }

Here is the caller graph for this function:

void Map::SendToPlayers ( WorldPacket const * data ) const

 {
     for (MapRefManager::const_iterator itr = m_mapRefManager.begin(); itr != m_mapRefManager.end(); ++itr)
         itr->GetSource()->GetSession()->SendPacket(data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::SendUpdateTransportVisibility	(	Player *	player,
		std::set< uint32 > const &	previousPhases
	)

 {
     // Hack to send out transports
     UpdateData transData(player->GetMapId());
     for (TransportsContainer::const_iterator i = _transports.begin(); i != _transports.end(); ++i)
     {
         if (*i == player->GetTransport())
             continue;
 
         if (player->IsInPhase(*i) && !Trinity::Containers::Intersects(previousPhases.begin(), previousPhases.end(), (*i)->GetPhases().begin(), (*i)->GetPhases().end()))
             (*i)->BuildCreateUpdateBlockForPlayer(&transData, player);
         else if (!player->IsInPhase(*i))
             (*i)->BuildOutOfRangeUpdateBlock(&transData);
     }
 
     WorldPacket packet;
     transData.BuildPacket(&packet);
     player->GetSession()->SendPacket(&packet);
 }

Here is the call graph for this function:

void Map::SendZoneDynamicInfo ( Player * player )

 {
     uint32 zoneId = GetZoneId(player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
     ZoneDynamicInfoMap::const_iterator itr = _zoneDynamicInfo.find(zoneId);
     if (itr == _zoneDynamicInfo.end())
         return;
 
     if (uint32 music = itr->second.MusicId)
         player->SendDirectMessage(WorldPackets::Misc::PlayMusic(music).Write());
 
     if (WeatherState weatherId = itr->second.WeatherId)
     {
         WorldPackets::Misc::Weather weather(weatherId, itr->second.WeatherGrade);
         player->SendDirectMessage(weather.Write());
     }
 
     if (uint32 overrideLightId = itr->second.OverrideLightId)
     {
         WorldPackets::Misc::OverrideLight overrideLight;
         overrideLight.AreaLightID = _defaultLight;
         overrideLight.OverrideLightID = overrideLightId;
         overrideLight.TransitionMilliseconds = itr->second.LightFadeInTime;
         player->SendDirectMessage(overrideLight.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Map::setGridObjectDataLoaded	(	bool	pLoaded,
		uint32	x,
		uint32	y
	)

inlineprivate

624 { getNGrid(x, y)->setGridObjectDataLoaded(pLoaded); }

void setGridObjectDataLoaded(bool pLoaded)

Definition: NGrid.h:110

NGrid::setUnloadExplicitLock

NGridType * getNGrid(uint32 x, uint32 y) const

Definition: Map.h:617

G3D::y

G3D::int16 y

Definition: Vector2int16.h:38

G3D::x

G3D::int16 x

Definition: Vector2int16.h:37

Here is the caller graph for this function:

void Map::setNGrid	(	NGridType *	grid,
		uint32	x,
		uint32	y
	)

inlineprivate

 {
     if (x >= MAX_NUMBER_OF_GRIDS || y >= MAX_NUMBER_OF_GRIDS)
     {
         TC_LOG_ERROR("maps", "map::setNGrid() Invalid grid coordinates found: %d, %d!", x, y);
         ABORT();
     }
     i_grids[x][y] = grid;
 }

Here is the caller graph for this function:

void Map::SetTimer ( uint32 t )

inlineprivate

584 { i_gridExpiry = t < MIN_GRID_DELAY ? MIN_GRID_DELAY : t; }

MIN_GRID_DELAY

#define MIN_GRID_DELAY

Definition: GridDefines.h:44

Map::i_gridExpiry

time_t i_gridExpiry

Definition: Map.h:671

void Map::SetUnloadLock	(	const GridCoord &	p,
		bool	on
	)

inline

314 { getNGrid(p.x_coord, p.y_coord)->setUnloadExplicitLock(on); }

void setUnloadExplicitLock(bool on)

Definition: NGrid.h:115

NGridType * getNGrid(uint32 x, uint32 y) const

Definition: Map.h:617

CoordPair::y_coord

uint32 y_coord

Definition: GridDefines.h:156

CoordPair::x_coord

uint32 x_coord

Definition: GridDefines.h:155

void Map::SetUnloadReferenceLock	(	const GridCoord &	p,
		bool	on
	)

inlineprotected

634 { getNGrid(p.x_coord, p.y_coord)->setUnloadReferenceLock(on); }

NGrid::setUnloadReferenceLock

NGridType * getNGrid(uint32 x, uint32 y) const

Definition: Map.h:617

CoordPair::y_coord

uint32 y_coord

Definition: GridDefines.h:156

CoordPair::x_coord

uint32 x_coord

Definition: GridDefines.h:155

void setUnloadReferenceLock(bool on)

Definition: NGrid.h:116

Here is the caller graph for this function:

void Map::SetZoneMusic	(	uint32	zoneId,
		uint32	musicId
	)

 {
     if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
         _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
     _zoneDynamicInfo[zoneId].MusicId = musicId;
 
     Map::PlayerList const& players = GetPlayers();
     if (!players.isEmpty())
     {
         for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
             if (Player* player = itr->GetSource())
                 if (player->GetZoneId() == zoneId)
                     player->SendDirectMessage(WorldPackets::Misc::PlayMusic(musicId).Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
         _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
     ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
     info.OverrideLightId = lightId;
     info.LightFadeInTime = fadeInTime;
     Map::PlayerList const& players = GetPlayers();
 
     if (!players.isEmpty())
     {
         WorldPackets::Misc::OverrideLight overrideLight;
         overrideLight.AreaLightID = _defaultLight;
         overrideLight.OverrideLightID = lightId;
         overrideLight.TransitionMilliseconds = fadeInTime;
         overrideLight.Write();
 
         for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
             if (Player* player = itr->GetSource())
                 if (player->GetZoneId() == zoneId)
                     player->SendDirectMessage(overrideLight.GetRawPacket());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (_zoneDynamicInfo.find(zoneId) == _zoneDynamicInfo.end())
         _zoneDynamicInfo.insert(ZoneDynamicInfoMap::value_type(zoneId, ZoneDynamicInfo()));
 
     ZoneDynamicInfo& info = _zoneDynamicInfo[zoneId];
     info.WeatherId = weatherId;
     info.WeatherGrade = weatherGrade;
     Map::PlayerList const& players = GetPlayers();
 
     if (!players.isEmpty())
     {
         WorldPackets::Misc::Weather weather(weatherId, weatherGrade);
 
         for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
             if (Player* player = itr->GetSource())
                 if (player->GetZoneId() == zoneId)
                     player->SendDirectMessage(weather.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     uint32 mask = UNIT_MASK_SUMMON;
     if (properties)
     {
         switch (properties->Category)
         {
             case SUMMON_CATEGORY_PET:
                 mask = UNIT_MASK_GUARDIAN;
                 break;
             case SUMMON_CATEGORY_PUPPET:
                 mask = UNIT_MASK_PUPPET;
                 break;
             case SUMMON_CATEGORY_VEHICLE:
                 mask = UNIT_MASK_MINION;
                 break;
             case SUMMON_CATEGORY_WILD:
             case SUMMON_CATEGORY_ALLY:
             case SUMMON_CATEGORY_UNK:
             {
                 switch (properties->Type)
                 {
                 case SUMMON_TYPE_MINION:
                 case SUMMON_TYPE_GUARDIAN:
                 case SUMMON_TYPE_GUARDIAN2:
                     mask = UNIT_MASK_GUARDIAN;
                     break;
                 case SUMMON_TYPE_TOTEM:
                 case SUMMON_TYPE_LIGHTWELL:
                     mask = UNIT_MASK_TOTEM;
                     break;
                 case SUMMON_TYPE_VEHICLE:
                 case SUMMON_TYPE_VEHICLE2:
                     mask = UNIT_MASK_SUMMON;
                     break;
                 case SUMMON_TYPE_MINIPET:
                     mask = UNIT_MASK_MINION;
                     break;
                 default:
                     if (properties->Flags & 512) // Mirror Image, Summon Gargoyle
                         mask = UNIT_MASK_GUARDIAN;
                     break;
                 }
                 break;
             }
             default:
                 return NULL;
         }
     }
 
     TempSummon* summon = NULL;
     switch (mask)
     {
         case UNIT_MASK_SUMMON:
             summon = new TempSummon(properties, summoner, false);
             break;
         case UNIT_MASK_GUARDIAN:
             summon = new Guardian(properties, summoner, false);
             break;
         case UNIT_MASK_PUPPET:
             summon = new Puppet(properties, summoner);
             break;
         case UNIT_MASK_TOTEM:
             summon = new Totem(properties, summoner);
             break;
         case UNIT_MASK_MINION:
             summon = new Minion(properties, summoner, false);
             break;
     }
 
     if (!summon->Create(GenerateLowGuid<HighGuid::Creature>(), this, 0, entry, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), nullptr, vehId))
     {
         delete summon;
         return NULL;
     }
 
     // Set the summon to the summoner's phase
     summon->CopyPhaseFrom(summoner);
 
     summon->SetUInt32Value(UNIT_CREATED_BY_SPELL, spellId);
 
     summon->SetHomePosition(pos);
 
     summon->InitStats(duration);
     AddToMap(summon->ToCreature());
     summon->InitSummon();
 
     //ObjectAccessor::UpdateObjectVisibility(summon);
 
     return summon;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Summons group of creatures.

Parameters

group	Id of group to summon.
list	List to store pointers to summoned creatures.

 {
     std::vector<TempSummonData> const* data = sObjectMgr->GetSummonGroup(GetId(), SUMMONER_TYPE_MAP, group);
     if (!data)
         return;
 
     for (std::vector<TempSummonData>::const_iterator itr = data->begin(); itr != data->end(); ++itr)
         if (TempSummon* summon = SummonCreature(itr->entry, itr->pos, NULL, itr->time))
             if (list)
                 list->push_back(summon);
 }

Here is the call graph for this function:

template<>

void Map::SwitchGridContainers	(	Creature *	obj,
		bool	on
	)

 {
     ASSERT(!obj->IsPermanentWorldObject());
     CellCoord p = Trinity::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
     if (!p.IsCoordValid())
     {
         TC_LOG_ERROR("maps", "Map::SwitchGridContainers: Object %s has invalid coordinates X:%f Y:%f grid cell [%u:%u]", obj->GetGUID().ToString().c_str(), obj->GetPositionX(), obj->GetPositionY(), p.x_coord, p.y_coord);
         return;
     }
 
     Cell cell(p);
     if (!IsGridLoaded(GridCoord(cell.data.Part.grid_x, cell.data.Part.grid_y)))
         return;
 
     if (sLog->ShouldLog("maps", LOG_LEVEL_DEBUG))
     {
         // Extract bitfield values
         uint32 const grid_x = cell.data.Part.grid_x;
         uint32 const grid_y = cell.data.Part.grid_y;
 
         TC_LOG_DEBUG("maps", "Switch object %s from grid[%u, %u] %u", obj->GetGUID().ToString().c_str(), grid_x, grid_y, on);
     }
 
     NGridType *ngrid = getNGrid(cell.GridX(), cell.GridY());
     ASSERT(ngrid != NULL);
 
     GridType &grid = ngrid->GetGridType(cell.CellX(), cell.CellY());
 
     obj->RemoveFromGrid(); //This step is not really necessary but we want to do ASSERT in remove/add
 
     if (on)
     {
         grid.AddWorldObject(obj);
         AddWorldObject(obj);
     }
     else
     {
         grid.AddGridObject(obj);
         RemoveWorldObject(obj);
     }
 
     obj->m_isTempWorldObject = on;
 }

Here is the call graph for this function:

template<>

void Map::SwitchGridContainers	(	GameObject *	obj,
		bool	on
	)

 {
     ASSERT(!obj->IsPermanentWorldObject());
     CellCoord p = Trinity::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
     if (!p.IsCoordValid())
     {
         TC_LOG_ERROR("maps", "Map::SwitchGridContainers: Object %s has invalid coordinates X:%f Y:%f grid cell [%u:%u]", obj->GetGUID().ToString().c_str(), obj->GetPositionX(), obj->GetPositionY(), p.x_coord, p.y_coord);
         return;
     }
 
     Cell cell(p);
     if (!IsGridLoaded(GridCoord(cell.data.Part.grid_x, cell.data.Part.grid_y)))
         return;
 
     if (sLog->ShouldLog("maps", LOG_LEVEL_DEBUG))
     {
         // Extract bitfield values
         uint32 const grid_x = cell.data.Part.grid_x;
         uint32 const grid_y = cell.data.Part.grid_y;
 
         TC_LOG_DEBUG("maps", "Switch object %s from grid[%u, %u] %u", obj->GetGUID().ToString().c_str(), grid_x, grid_y, on);
     }
 
     NGridType *ngrid = getNGrid(cell.GridX(), cell.GridY());
     ASSERT(ngrid != NULL);
 
     GridType &grid = ngrid->GetGridType(cell.CellX(), cell.CellY());
 
     obj->RemoveFromGrid(); //This step is not really necessary but we want to do ASSERT in remove/add
 
     if (on)
     {
         grid.AddWorldObject(obj);
         AddWorldObject(obj);
     }
     else
     {
         grid.AddGridObject(obj);
         RemoveWorldObject(obj);
     }
 }

Here is the call graph for this function:

template<class T >

void Map::SwitchGridContainers	(	T *	obj,
		bool	on
	)

321 { }

BattlegroundMap* Map::ToBattlegroundMap ( )

inline

498 { if (IsBattlegroundOrArena()) return reinterpret_cast<BattlegroundMap*>(this); else return NULL; }

Map::IsBattlegroundOrArena

bool IsBattlegroundOrArena() const

Definition: Map.h:403

Map::IsBattlegroundOrArena

arena_t NULL

Definition: jemalloc_internal.h:624

BattlegroundMap

Definition: Map.h:790

Here is the caller graph for this function:

BattlegroundMap const* Map::ToBattlegroundMap ( ) const

inline

499 { if (IsBattlegroundOrArena()) return reinterpret_cast<BattlegroundMap const*>(this); return NULL; }

bool IsBattlegroundOrArena() const

Definition: Map.h:403

arena_t NULL

Definition: jemalloc_internal.h:624

BattlegroundMap

Definition: Map.h:790

const

#define const

Definition: zconf.h:217

InstanceMap* Map::ToInstanceMap ( )

inline

495 { if (IsDungeon()) return reinterpret_cast<InstanceMap*>(this); else return NULL; }

arena_t NULL

Definition: jemalloc_internal.h:624

Map::IsDungeon

bool IsDungeon() const

Definition: Map.h:395

InstanceMap

Definition: Map.h:758

Here is the caller graph for this function:

InstanceMap const* Map::ToInstanceMap ( ) const

inline

496 { if (IsDungeon()) return reinterpret_cast<InstanceMap const*>(this); return NULL; }

arena_t NULL

Definition: jemalloc_internal.h:624

Map::IsDungeon

bool IsDungeon() const

Definition: Map.h:395

InstanceMap

Definition: Map.h:758

const

#define const

Definition: zconf.h:217

MapInstanced* Map::ToMapInstanced ( )

inline

492 { if (Instanceable()) return reinterpret_cast<MapInstanced*>(this); return NULL; }

MapInstanced

Definition: MapInstanced.h:28

arena_t NULL

Definition: jemalloc_internal.h:624

Map::Instanceable

bool Instanceable() const

Definition: Map.h:394

Here is the caller graph for this function:

MapInstanced const* Map::ToMapInstanced ( ) const

inline

493 { if (Instanceable()) return reinterpret_cast<MapInstanced const*>(this); return NULL; }

MapInstanced

Definition: MapInstanced.h:28