GridTerrainLoader Class Reference

#include "GridTerrainLoader.h"

Public Member Functions
	GridTerrainLoader (MapGridType &grid, Map *map)
void	LoadTerrain ()

Static Public Member Functions
static bool	ExistMap (uint32 mapid, int gx, int gy)
static bool	ExistVMap (uint32 mapid, int gx, int gy)

Private Member Functions
void	LoadMap ()
void	LoadVMap ()
void	LoadMMap ()

Private Attributes
MapGridType &	_grid
Map *	_map

Detailed Description

Constructor & Destructor Documentation

GridTerrainLoader()

GridTerrainLoader::GridTerrainLoader ( MapGridType &  grid, Map *  map  )

inline

        : _grid(grid), _map(map) { }

Member Function Documentation

ExistMap()

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

static

{
    std::string const mapFileName = Acore::StringFormat("{}maps/{:03}{:02}{:02}.map", sWorld->GetDataPath(), mapid, gx, gy);
    std::ifstream fileStream(mapFileName, std::ios::binary);
    if (fileStream.fail())
    {
        LOG_DEBUG("maps", "Map file '{}': error opening file", mapFileName);
        return false;
    }
 
    map_fileheader header;
    if (!fileStream.read(reinterpret_cast<char*>(&header), sizeof(header)))
    {
        LOG_DEBUG("maps", "Map file '{}': unable to read header", mapFileName);
        return false;
    }
 
    if (header.mapMagic != MapMagic.asUInt || header.versionMagic != MapVersionMagic)
    {
        LOG_ERROR("maps", "Map file '{}' is from an incompatible map version ({:.4u} v{}), {:.4s} v{} is expected. Please pull your source, recompile tools and recreate maps using the updated mapextractor, then replace your old map files with new files.",
            mapFileName, 4, header.mapMagic, header.versionMagic, 4, MapMagic.asChar, MapVersionMagic);
        return false;
    }
 
    return true;
}

References u_map_magic::asChar, u_map_magic::asUInt, LOG_DEBUG, LOG_ERROR, MapMagic, map_fileheader::mapMagic, MapVersionMagic, Acore::StringFormat(), sWorld, and map_fileheader::versionMagic.

Referenced by MapMgr::ExistMapAndVMap(), and misc_commandscript::HandleGPSCommand().

ExistVMap()

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

static

{
    if (VMAP::IVMapMgr* vmgr = VMAP::VMapFactory::createOrGetVMapMgr())
    {
        if (vmgr->isMapLoadingEnabled())
        {
            VMAP::LoadResult result = vmgr->existsMap((sWorld->GetDataPath() + "vmaps").c_str(), mapid, gx, gy);
            std::string name = vmgr->getDirFileName(mapid, gx, gy);
            switch (result)
            {
            case VMAP::LoadResult::Success:
                break;
            case VMAP::LoadResult::FileNotFound:
                LOG_DEBUG("maps", "VMap file '{}' does not exist", (sWorld->GetDataPath() + "vmaps/" + name));
                LOG_DEBUG("maps", "Please place VMAP files (*.vmtree and *.vmtile) in the vmap directory ({}), or correct the DataDir setting in your worldserver.conf file.", (sWorld->GetDataPath() + "vmaps/"));
                return false;
            case VMAP::LoadResult::VersionMismatch:
                LOG_ERROR("maps", "VMap file '{}' couldn't be loaded", (sWorld->GetDataPath() + "vmaps/" + name));
                LOG_ERROR("maps", "This is because the version of the VMap file and the version of this module are different, please re-extract the maps with the tools compiled with this module.");
                return false;
            }
        }
    }
 
    return true;
}

References VMAP::VMapFactory::createOrGetVMapMgr(), VMAP::FileNotFound, LOG_DEBUG, LOG_ERROR, VMAP::Success, sWorld, and VMAP::VersionMismatch.

Referenced by MapMgr::ExistMapAndVMap(), and misc_commandscript::HandleGPSCommand().

LoadMap()

void GridTerrainLoader::LoadMap ( )

private

{
    // Instances will point to the parent maps terrain data
    if (_map->GetInstanceId() != 0)
    {
        // load grid map for base map
        Map* parentMap = const_cast<Map*>(_map->GetParent());
 
        // GetGridTerrainData will create the parent map grid
        _grid.SetTerrainData(parentMap->GetGridTerrainDataSharedPtr(GridCoord(_grid.GetX(), _grid.GetY())));
        return;
    }
 
    // map file name
    std::string const mapFileName = Acore::StringFormat("{}maps/{:03}{:02}{:02}.map", sWorld->GetDataPath(), _map->GetId(), _grid.GetX(), _grid.GetY());
 
    // loading data
    LOG_DEBUG("maps", "Loading map {}", mapFileName);
    std::unique_ptr<GridTerrainData> terrainData = std::make_unique<GridTerrainData>();
    TerrainMapDataReadResult loadResult = terrainData->Load(mapFileName);
    if (loadResult == TerrainMapDataReadResult::Success)
        _grid.SetTerrainData(std::move(terrainData));
    else
    {
        if (loadResult == TerrainMapDataReadResult::InvalidMagic)
            LOG_ERROR("maps", "Map file '{}' is from an incompatible clientversion. Please recreate using the mapextractor.", mapFileName);
        else
            LOG_DEBUG("maps", "Error (result: {}) loading map file: {}", uint32(loadResult), mapFileName);
    }
 
    sScriptMgr->OnLoadGridMap(_map, _grid.GetTerrainData(), _grid.GetX(), _grid.GetY());
}

References _grid, _map, Map::GetGridTerrainDataSharedPtr(), Map::GetId(), Map::GetInstanceId(), Map::GetParent(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetTerrainData(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetX(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetY(), InvalidMagic, LOG_DEBUG, LOG_ERROR, MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::SetTerrainData(), sScriptMgr, Acore::StringFormat(), Success, and sWorld.

Referenced by LoadTerrain().

LoadMMap()

void GridTerrainLoader::LoadMMap ( )

private

{
    if (!DisableMgr::IsPathfindingEnabled(_map))
        return;
 
    int mmapLoadResult = MMAP::MMapFactory::createOrGetMMapMgr()->loadMap(_map->GetId(), _grid.GetX(), _grid.GetY());
    switch (mmapLoadResult)
    {
    case MMAP::MMAP_LOAD_RESULT_OK:
        LOG_DEBUG("maps", "MMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    case MMAP::MMAP_LOAD_RESULT_ERROR:
        LOG_DEBUG("maps", "Could not load MMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    case MMAP::MMAP_LOAD_RESULT_IGNORED:
        LOG_DEBUG("maps", "Ignored MMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    }
}

References _grid, _map, MMAP::MMapFactory::createOrGetMMapMgr(), Map::GetId(), Map::GetMapName(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetX(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetY(), DisableMgr::IsPathfindingEnabled(), MMAP::MMapMgr::loadMap(), LOG_DEBUG, MMAP::MMAP_LOAD_RESULT_ERROR, MMAP::MMAP_LOAD_RESULT_IGNORED, and MMAP::MMAP_LOAD_RESULT_OK.

Referenced by LoadTerrain().

LoadTerrain()

void GridTerrainLoader::LoadTerrain

(

)

{
    LoadMap();
    if (_map->GetInstanceId() == 0)
    {
        LoadVMap();
        LoadMMap();
    }
}

References _map, Map::GetInstanceId(), LoadMap(), LoadMMap(), and LoadVMap().

Referenced by MapGridManager::CreateGrid().

LoadVMap()

void GridTerrainLoader::LoadVMap ( )

private

{
    int vmapLoadResult = VMAP::VMapFactory::createOrGetVMapMgr()->loadMap((sWorld->GetDataPath() + "vmaps").c_str(), _map->GetId(), _grid.GetX(), _grid.GetY());
    switch (vmapLoadResult)
    {
    case VMAP::VMAP_LOAD_RESULT_OK:
        LOG_DEBUG("maps", "VMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    case VMAP::VMAP_LOAD_RESULT_ERROR:
        LOG_DEBUG("maps", "Could not load VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    case VMAP::VMAP_LOAD_RESULT_IGNORED:
        LOG_DEBUG("maps", "Ignored VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
            _map->GetMapName(), _map->GetId(), _grid.GetX(), _grid.GetY(), _grid.GetX(), _grid.GetY());
        break;
    }
}

References _grid, _map, VMAP::VMapFactory::createOrGetVMapMgr(), Map::GetId(), Map::GetMapName(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetX(), MapGrid< WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES >::GetY(), VMAP::VMapMgr2::loadMap(), LOG_DEBUG, sWorld, VMAP::VMAP_LOAD_RESULT_ERROR, VMAP::VMAP_LOAD_RESULT_IGNORED, and VMAP::VMAP_LOAD_RESULT_OK.

Referenced by LoadTerrain().

Member Data Documentation

_grid

MapGridType& GridTerrainLoader::_grid

private

Referenced by LoadMap(), LoadMMap(), and LoadVMap().

_map

Map* GridTerrainLoader::_map

private

Referenced by LoadMap(), LoadMMap(), LoadTerrain(), and LoadVMap().

---

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

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