MapGridManager Class Reference

#include "MapGridManager.h"

Public Member Functions
	MapGridManager (Map *map)
void	CreateGrid (uint16 const x, uint16 const y)
bool	LoadGrid (uint16 const x, uint16 const y)
void	UnloadGrid (uint16 const x, uint16 const y)
bool	IsGridCreated (uint16 const x, uint16 const y) const
bool	IsGridLoaded (uint16 const x, uint16 const y) const
MapGridType *	GetGrid (uint16 const x, uint16 const y)
uint32	GetCreatedGridsCount ()
uint32	GetLoadedGridsCount ()
uint32	GetCreatedCellsInGridCount (uint16 const x, uint16 const y)
uint32	GetCreatedCellsInMapCount ()
bool	IsGridsFullyCreated () const
bool	IsGridsFullyLoaded () const

Static Public Member Functions
static bool	IsValidGridCoordinates (uint16 const x, uint16 const y)

Private Attributes
Map *	_map
uint32	_createdGridsCount
uint32	_loadedGridsCount
std::mutex	_gridLock
std::unique_ptr< MapGridType >	_mapGrid [MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS]

Detailed Description

Constructor & Destructor Documentation

MapGridManager()

MapGridManager::MapGridManager ( Map *  map )

inline

: _map(map), _createdGridsCount(0), _loadedGridsCount(0) { }

Member Function Documentation

CreateGrid()

void MapGridManager::CreateGrid	(	uint16 const	x,
		uint16 const	y
	)

{
    std::lock_guard<std::mutex> guard(_gridLock);
    if (IsGridCreated(x, y))
        return;
 
    // If we are an instance, ensure parent map has already created the grid before proceeding.
    // Note: grid loading is locked and is safe across multiple map threads in the
    // event of multiple child maps attempting to create the same parent map grid
    if (_map->GetInstanceId() != 0)
    {
        Map* parentMap = const_cast<Map*>(_map->GetParent());
        parentMap->EnsureGridCreated(GridCoord(x, y));
    }
 
    std::unique_ptr<MapGridType> grid = std::make_unique<MapGridType>(x, y);
    grid->link(_map);
 
    // Terrain is loading during create (should/can we move this to LoadGrid?)
    GridTerrainLoader loader(*grid, _map);
    loader.LoadTerrain();
 
    _mapGrid[x][y] = std::move(grid);
 
    ++_createdGridsCount;
}

References _createdGridsCount, _gridLock, _map, _mapGrid, Map::EnsureGridCreated(), Map::GetInstanceId(), Map::GetParent(), IsGridCreated(), and GridTerrainLoader::LoadTerrain().

Referenced by Map::EnsureGridCreated().

GetCreatedCellsInGridCount()

uint32 MapGridManager::GetCreatedCellsInGridCount	(	uint16 const	x,
		uint16 const	y
	)

{
    MapGridType* grid = GetGrid(x, y);
    if (grid)
        return grid->GetCreatedCellsCount();
 
    return 0;
}

References MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::GetCreatedCellsCount(), and GetGrid().

Referenced by Map::GetCreatedCellsInGridCount().

GetCreatedCellsInMapCount()

uint32 MapGridManager::GetCreatedCellsInMapCount

(

)

{
    uint32 count = 0;
    for (uint32 gridX = 0; gridX < MAX_NUMBER_OF_GRIDS; ++gridX)
    {
        for (uint32 gridY = 0; gridY < MAX_NUMBER_OF_GRIDS; ++gridY)
        {
            if (MapGridType* grid = GetGrid(gridX, gridY))
                count += grid->GetCreatedCellsCount();
        }
    }
    return count;
}

References GetGrid(), and MAX_NUMBER_OF_GRIDS.

Referenced by Map::GetCreatedCellsInMapCount().

GetCreatedGridsCount()

uint32 MapGridManager::GetCreatedGridsCount

(

)

{
    return _createdGridsCount;
}

References _createdGridsCount.

Referenced by Map::GetCreatedGridsCount().

GetGrid()

MapGridType * MapGridManager::GetGrid	(	uint16 const	x,
		uint16 const	y
	)

{
    if (!MapGridManager::IsValidGridCoordinates(x, y))
        return nullptr;
 
    return _mapGrid[x][y].get();
}

References _mapGrid, and IsValidGridCoordinates().

Referenced by GetCreatedCellsInGridCount(), GetCreatedCellsInMapCount(), Map::GetGridTerrainData(), Map::GetGridTerrainDataSharedPtr(), Map::GetMapGrid(), LoadGrid(), and UnloadGrid().

GetLoadedGridsCount()

uint32 MapGridManager::GetLoadedGridsCount

(

)

{
    return _loadedGridsCount;
}

References _loadedGridsCount.

Referenced by Map::GetLoadedGridsCount().

IsGridCreated()

bool MapGridManager::IsGridCreated	(	uint16 const	x,
		uint16 const	y
	)		const

{
    if (!MapGridManager::IsValidGridCoordinates(x, y))
        return false;
 
    return _mapGrid[x][y].get();
}

References _mapGrid, and IsValidGridCoordinates().

Referenced by CreateGrid(), and Map::IsGridCreated().

IsGridLoaded()

bool MapGridManager::IsGridLoaded	(	uint16 const	x,
		uint16 const	y
	)		const

{
    if (!MapGridManager::IsValidGridCoordinates(x, y))
        return false;
 
    return _mapGrid[x][y].get() && _mapGrid[x][y]->IsObjectDataLoaded();
}

References _mapGrid, and IsValidGridCoordinates().

Referenced by Map::IsGridLoaded().

IsGridsFullyCreated()

bool MapGridManager::IsGridsFullyCreated

(

)

const

{
    return _createdGridsCount == (MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS);
}

References _createdGridsCount, and MAX_NUMBER_OF_GRIDS.

IsGridsFullyLoaded()

bool MapGridManager::IsGridsFullyLoaded

(

)

const

{
    return _loadedGridsCount == (MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS);
}

References _loadedGridsCount, and MAX_NUMBER_OF_GRIDS.

Referenced by Map::LoadGridsInRange().

IsValidGridCoordinates()

static bool MapGridManager::IsValidGridCoordinates ( uint16 const  x, uint16 const  y  )

inlinestatic

{ return (x < MAX_NUMBER_OF_GRIDS && y < MAX_NUMBER_OF_GRIDS); }

References MAX_NUMBER_OF_GRIDS.

Referenced by GetGrid(), Map::GetGridTerrainData(), IsGridCreated(), and IsGridLoaded().

LoadGrid()

bool MapGridManager::LoadGrid	(	uint16 const	x,
		uint16 const	y
	)

{
    MapGridType* grid = GetGrid(x, y);
    if (!grid || grid->IsObjectDataLoaded())
        return false;
 
    // Must mark as loaded first, as GridObjectLoader spawning objects can attempt to recursively load the grid
    grid->SetObjectDataLoaded();
 
    GridObjectLoader loader(*grid, _map);
    loader.LoadAllCellsInGrid();
 
    ++_loadedGridsCount;
    return true;
}

References _loadedGridsCount, _map, GetGrid(), MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::IsObjectDataLoaded(), GridObjectLoader::LoadAllCellsInGrid(), and MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::SetObjectDataLoaded().

Referenced by Map::EnsureGridLoaded().

UnloadGrid()

void MapGridManager::UnloadGrid	(	uint16 const	x,
		uint16 const	y
	)

{
    MapGridType* grid = GetGrid(x, y);
    if (!grid)
        return;
 
    {
        GridObjectCleaner worker;
        TypeContainerVisitor<GridObjectCleaner, GridTypeMapContainer> visitor(worker);
        grid->VisitAllCells(visitor);
    }
 
    _map->RemoveAllObjectsInRemoveList();
 
    {
        GridObjectUnloader worker;
        TypeContainerVisitor<GridObjectUnloader, GridTypeMapContainer> visitor(worker);
        grid->VisitAllCells(visitor);
    }
 
    _mapGrid[x][y] = nullptr;
}

References _map, _mapGrid, GetGrid(), Map::RemoveAllObjectsInRemoveList(), and MapGrid< GRID_OBJECT_TYPES, FAR_VISIBLE_OBJECT_TYPES >::VisitAllCells().

Referenced by Map::UnloadGrid().

Member Data Documentation

_createdGridsCount

uint32 MapGridManager::_createdGridsCount

private

Referenced by CreateGrid(), GetCreatedGridsCount(), and IsGridsFullyCreated().

_gridLock

std::mutex MapGridManager::_gridLock

private

Referenced by CreateGrid().

_loadedGridsCount

uint32 MapGridManager::_loadedGridsCount

private

Referenced by GetLoadedGridsCount(), IsGridsFullyLoaded(), and LoadGrid().

_map

Map* MapGridManager::_map

private

Referenced by CreateGrid(), LoadGrid(), and UnloadGrid().

_mapGrid

std::unique_ptr<MapGridType> MapGridManager::_mapGrid[MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS]

private

Referenced by CreateGrid(), GetGrid(), IsGridCreated(), IsGridLoaded(), and UnloadGrid().

---

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

• azerothcore-wotlk/src/server/game/Grids/MapGridManager.h
• azerothcore-wotlk/src/server/game/Grids/MapGridManager.cpp