GridMap Class Reference

#include <Map.h>

Public Member Functions
	GridMap ()
	~GridMap ()
bool	loadData (const char *filename)
void	unloadData ()
uint16	getArea (float x, float y) const
float	getHeight (float x, float y) const
float	getMinHeight (float x, float y) const
float	getLiquidLevel (float x, float y) const
uint8	getTerrainType (float x, float y) const
ZLiquidStatus	getLiquidStatus (float x, float y, float z, uint8 ReqLiquidType, LiquidData *data=0)

Private Types
typedef float(GridMap::*	GetHeightPtr )(float x, float y) const

Private Member Functions
bool	loadAreaData (FILE *in, uint32 offset, uint32 size)
bool	loadHeightData (FILE *in, uint32 offset, uint32 size)
bool	loadLiquidData (FILE *in, uint32 offset, uint32 size)
float	getHeightFromFloat (float x, float y) const
float	getHeightFromUint16 (float x, float y) const
float	getHeightFromUint8 (float x, float y) const
float	getHeightFromFlat (float x, float y) const

Private Attributes
uint32	_flags
union {
float *   m_V9
uint16 *   m_uint16_V9
uint8 *   m_uint8_V9
};
union {
float *   m_V8
uint16 *   m_uint16_V8
uint8 *   m_uint8_V8
};
int16 *	_maxHeight
int16 *	_minHeight
float	_gridHeight
float	_gridIntHeightMultiplier
uint16 *	_areaMap
float	_liquidLevel
uint16 *	_liquidEntry
uint8 *	_liquidFlags
float *	_liquidMap
uint16	_gridArea
uint16	_liquidType
uint8	_liquidOffX
uint8	_liquidOffY
uint8	_liquidWidth
uint8	_liquidHeight
GetHeightPtr	_gridGetHeight

Member Typedef Documentation

typedef float(GridMap::* GridMap::GetHeightPtr)(float x, float y) const

private

Constructor & Destructor Documentation

GridMap::GridMap

(

)

{
 _flags = 0;
 // Area data
 _gridArea = 0;
 _areaMap = nullptr;
 // Height level data
 _gridHeight = INVALID_HEIGHT;
 _gridGetHeight = &GridMap::getHeightFromFlat;
 _gridIntHeightMultiplier = 0;
 m_V9 = nullptr;
 m_V8 = nullptr;
 _maxHeight = nullptr;
 _minHeight = nullptr;
 // Liquid data
 _liquidType = 0;
 _liquidOffX = 0;
 _liquidOffY = 0;
 _liquidWidth = 0;
 _liquidHeight = 0;
 _liquidLevel = INVALID_HEIGHT;
 _liquidEntry = nullptr;
 _liquidFlags = nullptr;
 _liquidMap = nullptr;
}

Here is the call graph for this function:

GridMap::~GridMap

(

)

{
 unloadData();
}

Here is the call graph for this function:

Member Function Documentation

uint16 GridMap::getArea	(	float	x,
		float	y
	)		const

{
 if (!_areaMap)
 return _gridArea;

 x = 16 * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = 16 * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);
 int lx = (int)x & 15;
 int ly = (int)y & 15;
 return _areaMap[lx*16 + ly];
}

Here is the caller graph for this function:

float GridMap::getHeight ( float  x, float  y  ) const

inline

{return (this->*_gridGetHeight)(x, y);}

Here is the caller graph for this function:

float GridMap::getHeightFromFlat ( float  x, float  y  ) const

private

{
 return _gridHeight;
}

Here is the caller graph for this function:

float GridMap::getHeightFromFloat ( float  x, float  y  ) const

private

{
 if (!m_V8 || !m_V9)
 return _gridHeight;

 x = MAP_RESOLUTION * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = MAP_RESOLUTION * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);

 int x_int = (int)x;
 int y_int = (int)y;
 x -= x_int;
 y -= y_int;
 x_int&=(MAP_RESOLUTION - 1);
 y_int&=(MAP_RESOLUTION - 1);

 // Height stored as: h5 - its v8 grid, h1-h4 - its v9 grid
 // +--------------> X
 // | h1-------h2 Coordinates is:
 // | | \ 1 / | h1 0, 0
 // | | \ / | h2 0, 1
 // | | 2 h5 3 | h3 1, 0
 // | | / \ | h4 1, 1
 // | | / 4 \ | h5 1/2, 1/2
 // | h3-------h4
 // V Y
 // For find height need
 // 1 - detect triangle
 // 2 - solve linear equation from triangle points
 // Calculate coefficients for solve h = a*x + b*y + c

 float a, b, c;
 // Select triangle:
 if (x+y < 1)
 {
 if (x > y)
 {
 // 1 triangle (h1, h2, h5 points)
 float h1 = m_V9[(x_int)*129 + y_int];
 float h2 = m_V9[(x_int+1)*129 + y_int];
 float h5 = 2 * m_V8[x_int*128 + y_int];
 a = h2-h1;
 b = h5-h1-h2;
 c = h1;
 }
 else
 {
 // 2 triangle (h1, h3, h5 points)
 float h1 = m_V9[x_int*129 + y_int ];
 float h3 = m_V9[x_int*129 + y_int+1];
 float h5 = 2 * m_V8[x_int*128 + y_int];
 a = h5 - h1 - h3;
 b = h3 - h1;
 c = h1;
 }
 }
 else
 {
 if (x > y)
 {
 // 3 triangle (h2, h4, h5 points)
 float h2 = m_V9[(x_int+1)*129 + y_int ];
 float h4 = m_V9[(x_int+1)*129 + y_int+1];
 float h5 = 2 * m_V8[x_int*128 + y_int];
 a = h2 + h4 - h5;
 b = h4 - h2;
 c = h5 - h4;
 }
 else
 {
 // 4 triangle (h3, h4, h5 points)
 float h3 = m_V9[(x_int)*129 + y_int+1];
 float h4 = m_V9[(x_int+1)*129 + y_int+1];
 float h5 = 2 * m_V8[x_int*128 + y_int];
 a = h4 - h3;
 b = h3 + h4 - h5;
 c = h5 - h4;
 }
 }
 // Calculate height
 return a * x + b * y + c;
}

Here is the caller graph for this function:

float GridMap::getHeightFromUint16 ( float  x, float  y  ) const

private

{
 if (!m_uint16_V8 || !m_uint16_V9)
 return _gridHeight;

 x = MAP_RESOLUTION * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = MAP_RESOLUTION * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);

 int x_int = (int)x;
 int y_int = (int)y;
 x -= x_int;
 y -= y_int;
 x_int&=(MAP_RESOLUTION - 1);
 y_int&=(MAP_RESOLUTION - 1);

 int32 a, b, c;
 uint16 *V9_h1_ptr = &m_uint16_V9[x_int*128 + x_int + y_int];
 if (x+y < 1)
 {
 if (x > y)
 {
 // 1 triangle (h1, h2, h5 points)
 int32 h1 = V9_h1_ptr[ 0];
 int32 h2 = V9_h1_ptr[129];
 int32 h5 = 2 * m_uint16_V8[x_int*128 + y_int];
 a = h2-h1;
 b = h5-h1-h2;
 c = h1;
 }
 else
 {
 // 2 triangle (h1, h3, h5 points)
 int32 h1 = V9_h1_ptr[0];
 int32 h3 = V9_h1_ptr[1];
 int32 h5 = 2 * m_uint16_V8[x_int*128 + y_int];
 a = h5 - h1 - h3;
 b = h3 - h1;
 c = h1;
 }
 }
 else
 {
 if (x > y)
 {
 // 3 triangle (h2, h4, h5 points)
 int32 h2 = V9_h1_ptr[129];
 int32 h4 = V9_h1_ptr[130];
 int32 h5 = 2 * m_uint16_V8[x_int*128 + y_int];
 a = h2 + h4 - h5;
 b = h4 - h2;
 c = h5 - h4;
 }
 else
 {
 // 4 triangle (h3, h4, h5 points)
 int32 h3 = V9_h1_ptr[ 1];
 int32 h4 = V9_h1_ptr[130];
 int32 h5 = 2 * m_uint16_V8[x_int*128 + y_int];
 a = h4 - h3;
 b = h3 + h4 - h5;
 c = h5 - h4;
 }
 }
 // Calculate height
 return (float)((a * x) + (b * y) + c)*_gridIntHeightMultiplier + _gridHeight;
}

Here is the caller graph for this function:

float GridMap::getHeightFromUint8 ( float  x, float  y  ) const

private

{
 if (!m_uint8_V8 || !m_uint8_V9)
 return _gridHeight;

 x = MAP_RESOLUTION * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = MAP_RESOLUTION * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);

 int x_int = (int)x;
 int y_int = (int)y;
 x -= x_int;
 y -= y_int;
 x_int&=(MAP_RESOLUTION - 1);
 y_int&=(MAP_RESOLUTION - 1);

 int32 a, b, c;
 uint8 *V9_h1_ptr = &m_uint8_V9[x_int*128 + x_int + y_int];
 if (x+y < 1)
 {
 if (x > y)
 {
 // 1 triangle (h1, h2, h5 points)
 int32 h1 = V9_h1_ptr[ 0];
 int32 h2 = V9_h1_ptr[129];
 int32 h5 = 2 * m_uint8_V8[x_int*128 + y_int];
 a = h2-h1;
 b = h5-h1-h2;
 c = h1;
 }
 else
 {
 // 2 triangle (h1, h3, h5 points)
 int32 h1 = V9_h1_ptr[0];
 int32 h3 = V9_h1_ptr[1];
 int32 h5 = 2 * m_uint8_V8[x_int*128 + y_int];
 a = h5 - h1 - h3;
 b = h3 - h1;
 c = h1;
 }
 }
 else
 {
 if (x > y)
 {
 // 3 triangle (h2, h4, h5 points)
 int32 h2 = V9_h1_ptr[129];
 int32 h4 = V9_h1_ptr[130];
 int32 h5 = 2 * m_uint8_V8[x_int*128 + y_int];
 a = h2 + h4 - h5;
 b = h4 - h2;
 c = h5 - h4;
 }
 else
 {
 // 4 triangle (h3, h4, h5 points)
 int32 h3 = V9_h1_ptr[ 1];
 int32 h4 = V9_h1_ptr[130];
 int32 h5 = 2 * m_uint8_V8[x_int*128 + y_int];
 a = h4 - h3;
 b = h3 + h4 - h5;
 c = h5 - h4;
 }
 }
 // Calculate height
 return (float)((a * x) + (b * y) + c)*_gridIntHeightMultiplier + _gridHeight;
}

Here is the caller graph for this function:

float GridMap::getLiquidLevel	(	float	x,
		float	y
	)		const

{
 if (!_liquidMap)
 return _liquidLevel;

 x = MAP_RESOLUTION * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = MAP_RESOLUTION * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);

 int cx_int = ((int)x & (MAP_RESOLUTION-1)) - _liquidOffY;
 int cy_int = ((int)y & (MAP_RESOLUTION-1)) - _liquidOffX;

 if (cx_int < 0 || cx_int >=_liquidHeight)
 return INVALID_HEIGHT;
 if (cy_int < 0 || cy_int >=_liquidWidth)
 return INVALID_HEIGHT;

 return _liquidMap[cx_int*_liquidWidth + cy_int];
}

ZLiquidStatus GridMap::getLiquidStatus ( float  x, float  y, float  z, uint8  ReqLiquidType, LiquidData *  data = 0  )

inline

{
 // Check water type (if no water return)
 if (!_liquidType && !_liquidFlags)
 return LIQUID_MAP_NO_WATER;

 // Get cell
 float cx = MAP_RESOLUTION * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 float cy = MAP_RESOLUTION * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);

 int x_int = (int)cx & (MAP_RESOLUTION-1);
 int y_int = (int)cy & (MAP_RESOLUTION-1);

 // Check water type in cell
 int idx=(x_int>>3)*16 + (y_int>>3);
 uint8 type = _liquidFlags ? _liquidFlags[idx] : _liquidType;
 uint32 entry = 0;
 if (_liquidEntry)
 {
 if (LiquidTypeEntry const* liquidEntry = sLiquidTypeStore.LookupEntry(_liquidEntry[idx]))
 {
 entry = liquidEntry->ID;
 type &= MAP_LIQUID_TYPE_DARK_WATER;
 uint32 liqTypeIdx = liquidEntry->Type;
 if (entry < 21)
 {
 if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(getArea(x, y)))
 {
 uint32 overrideLiquid = area->LiquidTypeID[liquidEntry->Type];
 if (!overrideLiquid && area->ParentAreaID)
 {
 area = sAreaTableStore.LookupEntry(area->ParentAreaID);
 if (area)
 overrideLiquid = area->LiquidTypeID[liquidEntry->Type];
 }

 if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(overrideLiquid))
 {
 entry = overrideLiquid;
 liqTypeIdx = liq->Type;
 }
 }
 }

 type |= 1 << liqTypeIdx;
 }
 }

 if (type == 0)
 return LIQUID_MAP_NO_WATER;

 // Check req liquid type mask
 if (ReqLiquidType && !(ReqLiquidType&type))
 return LIQUID_MAP_NO_WATER;

 // Check water level:
 // Check water height map
 int lx_int = x_int - _liquidOffY;
 int ly_int = y_int - _liquidOffX;
 if (lx_int < 0 || lx_int >=_liquidHeight)
 return LIQUID_MAP_NO_WATER;
 if (ly_int < 0 || ly_int >=_liquidWidth)
 return LIQUID_MAP_NO_WATER;

 // Get water level
 float liquid_level = _liquidMap ? _liquidMap[lx_int*_liquidWidth + ly_int] : _liquidLevel;
 // Get ground level (sub 0.2 for fix some errors)
 float ground_level = getHeight(x, y);

 // Check water level and ground level
 if (liquid_level < ground_level || z < ground_level - 2)
 return LIQUID_MAP_NO_WATER;

 // All ok in water -> store data
 if (data)
 {
 data->entry = entry;
 data->type_flags = type;
 data->level = liquid_level;
 data->depth_level = ground_level;
 }

 // For speed check as int values
 float delta = liquid_level - z;

 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;
 // Above water
 return LIQUID_MAP_ABOVE_WATER;
}

Here is the call graph for this function:

float GridMap::getMinHeight	(	float	x,
		float	y
	)		const

{
 if (!_minHeight)
 return -500.0f;

 static uint32 const indices[] =
 {
 3, 0, 4,
 0, 1, 4,
 1, 2, 4,
 2, 5, 4,
 5, 8, 4,
 8, 7, 4,
 7, 6, 4,
 6, 3, 4
 };

 static float const boundGridCoords[] =
 {
 0.0f, 0.0f,
 0.0f, -266.66666f,
 0.0f, -533.33331f,
 -266.66666f, 0.0f,
 -266.66666f, -266.66666f,
 -266.66666f, -533.33331f,
 -533.33331f, 0.0f,
 -533.33331f, -266.66666f,
 -533.33331f, -533.33331f
 };

 Cell cell(x, y);
 float gx = x - (int32(cell.GridX()) - CENTER_GRID_ID + 1) * SIZE_OF_GRIDS;
 float gy = y - (int32(cell.GridY()) - CENTER_GRID_ID + 1) * SIZE_OF_GRIDS;

 uint32 quarterIndex = 0;
 if (cell.CellY() < MAX_NUMBER_OF_CELLS / 2)
 {
 if (cell.CellX() < MAX_NUMBER_OF_CELLS / 2)
 {
 quarterIndex = 4 + (gy > gx);
 }
 else
 quarterIndex = 2 + ((-SIZE_OF_GRIDS - gx) > gy);
 }
 else if (cell.CellX() < MAX_NUMBER_OF_CELLS / 2)
 {
 quarterIndex = 6 + ((-SIZE_OF_GRIDS - gx) <= gy);
 }
 else
 quarterIndex = gx > gy;

 quarterIndex *= 3;

 return G3D::Plane(
 G3D::Vector3(boundGridCoords[indices[quarterIndex + 0] * 2 + 0], boundGridCoords[indices[quarterIndex + 0] * 2 + 1], _minHeight[indices[quarterIndex + 0]]),
 G3D::Vector3(boundGridCoords[indices[quarterIndex + 1] * 2 + 0], boundGridCoords[indices[quarterIndex + 1] * 2 + 1], _minHeight[indices[quarterIndex + 1]]),
 G3D::Vector3(boundGridCoords[indices[quarterIndex + 2] * 2 + 0], boundGridCoords[indices[quarterIndex + 2] * 2 + 1], _minHeight[indices[quarterIndex + 2]])
 ).distance(G3D::Vector3(gx, gy, 0.0f));
}

Here is the call graph for this function:

uint8 GridMap::getTerrainType	(	float	x,
		float	y
	)		const

{
 if (!_liquidFlags)
 return 0;

 x = 16 * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
 y = 16 * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);
 int lx = (int)x & 15;
 int ly = (int)y & 15;
 return _liquidFlags[lx*16 + ly];
}

bool GridMap::loadAreaData ( FILE *  in, uint32  offset, uint32  size  )

private

{
 map_areaHeader header;
 fseek(in, offset, SEEK_SET);

 if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapAreaMagic.asUInt)
 return false;

 _gridArea = header.gridArea;
 if (!(header.flags & MAP_AREA_NO_AREA))
 {
 _areaMap = new uint16[16 * 16];
 if (fread(_areaMap, sizeof(uint16), 16*16, in) != 16*16)
 return false;
 }
 return true;
}

Here is the caller graph for this function:

bool GridMap::loadData

(

const char *

filename

)

{
 // Unload old data if exist
 unloadData();

 map_fileheader header;
 // Not return error if file not found
 FILE* in = fopen(filename, "rb");
 if (!in)
 return true;

 if (fread(&header, sizeof(header), 1, in) != 1)
 {
 fclose(in);
 return false;
 }

 if (header.mapMagic.asUInt == MapMagic.asUInt && header.versionMagic.asUInt == MapVersionMagic.asUInt)
 {
 // load up area data
 if (header.areaMapOffset && !loadAreaData(in, header.areaMapOffset, header.areaMapSize))
 {
 TC_LOG_ERROR("maps", "Error loading map area data\n");
 fclose(in);
 return false;
 }
 // load up height data
 if (header.heightMapOffset && !loadHeightData(in, header.heightMapOffset, header.heightMapSize))
 {
 TC_LOG_ERROR("maps", "Error loading map height data\n");
 fclose(in);
 return false;
 }
 // load up liquid data
 if (header.liquidMapOffset && !loadLiquidData(in, header.liquidMapOffset, header.liquidMapSize))
 {
 TC_LOG_ERROR("maps", "Error loading map liquids data\n");
 fclose(in);
 return false;
 }
 fclose(in);
 return true;
 }

 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, 4, header.mapMagic.asChar, 4, header.versionMagic.asChar, 4, MapMagic.asChar, 4, MapVersionMagic.asChar);
 fclose(in);
 return false;
}

Here is the call graph for this function:

bool GridMap::loadHeightData ( FILE *  in, uint32  offset, uint32  size  )

private

{
 map_heightHeader header;
 fseek(in, offset, SEEK_SET);

 if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapHeightMagic.asUInt)
 return false;

 _gridHeight = header.gridHeight;
 if (!(header.flags & MAP_HEIGHT_NO_HEIGHT))
 {
 if ((header.flags & MAP_HEIGHT_AS_INT16))
 {
 m_uint16_V9 = new uint16 [129*129];
 m_uint16_V8 = new uint16 [128*128];
 if (fread(m_uint16_V9, sizeof(uint16), 129*129, in) != 129*129 ||
 fread(m_uint16_V8, sizeof(uint16), 128*128, in) != 128*128)
 return false;
 _gridIntHeightMultiplier = (header.gridMaxHeight - header.gridHeight) / 65535;
 _gridGetHeight = &GridMap::getHeightFromUint16;
 }
 else if ((header.flags & MAP_HEIGHT_AS_INT8))
 {
 m_uint8_V9 = new uint8 [129*129];
 m_uint8_V8 = new uint8 [128*128];
 if (fread(m_uint8_V9, sizeof(uint8), 129*129, in) != 129*129 ||
 fread(m_uint8_V8, sizeof(uint8), 128*128, in) != 128*128)
 return false;
 _gridIntHeightMultiplier = (header.gridMaxHeight - header.gridHeight) / 255;
 _gridGetHeight = &GridMap::getHeightFromUint8;
 }
 else
 {
 m_V9 = new float [129*129];
 m_V8 = new float [128*128];
 if (fread(m_V9, sizeof(float), 129*129, in) != 129*129 ||
 fread(m_V8, sizeof(float), 128*128, in) != 128*128)
 return false;
 _gridGetHeight = &GridMap::getHeightFromFloat;
 }
 }
 else
 _gridGetHeight = &GridMap::getHeightFromFlat;

 if (header.flags & MAP_HEIGHT_HAS_FLIGHT_BOUNDS)
 {
 _maxHeight = new int16[3 * 3];
 _minHeight = new int16[3 * 3];
 if (fread(_maxHeight, sizeof(int16), 3 * 3, in) != 3 * 3 ||
 fread(_minHeight, sizeof(int16), 3 * 3, in) != 3 * 3)
 return false;
 }

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool GridMap::loadLiquidData ( FILE *  in, uint32  offset, uint32  size  )

private

{
 map_liquidHeader header;
 fseek(in, offset, SEEK_SET);

 if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapLiquidMagic.asUInt)
 return false;

 _liquidType = header.liquidType;
 _liquidOffX = header.offsetX;
 _liquidOffY = header.offsetY;
 _liquidWidth = header.width;
 _liquidHeight = header.height;
 _liquidLevel = header.liquidLevel;

 if (!(header.flags & MAP_LIQUID_NO_TYPE))
 {
 _liquidEntry = new uint16[16*16];
 if (fread(_liquidEntry, sizeof(uint16), 16*16, in) != 16*16)
 return false;

 _liquidFlags = new uint8[16*16];
 if (fread(_liquidFlags, sizeof(uint8), 16*16, in) != 16*16)
 return false;
 }
 if (!(header.flags & MAP_LIQUID_NO_HEIGHT))
 {
 _liquidMap = new float[uint32(_liquidWidth) * uint32(_liquidHeight)];
 if (fread(_liquidMap, sizeof(float), _liquidWidth*_liquidHeight, in) != (uint32(_liquidWidth) * uint32(_liquidHeight)))
 return false;
 }
 return true;
}

Here is the caller graph for this function:

void GridMap::unloadData

(

)

{
 delete[] _areaMap;
 delete[] m_V9;
 delete[] m_V8;
 delete[] _maxHeight;
 delete[] _minHeight;
 delete[] _liquidEntry;
 delete[] _liquidFlags;
 delete[] _liquidMap;
 _areaMap = nullptr;
 m_V9 = nullptr;
 m_V8 = nullptr;
 _maxHeight = nullptr;
 _minHeight = nullptr;
 _liquidEntry = nullptr;
 _liquidFlags = nullptr;
 _liquidMap = nullptr;
 _gridGetHeight = &GridMap::getHeightFromFlat;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

union { ... }

union { ... }

uint16* GridMap::_areaMap

private

uint32 GridMap::_flags

private

uint16 GridMap::_gridArea

private

GetHeightPtr GridMap::_gridGetHeight

private

float GridMap::_gridHeight

private

float GridMap::_gridIntHeightMultiplier

private

uint16* GridMap::_liquidEntry

private

uint8* GridMap::_liquidFlags

private

uint8 GridMap::_liquidHeight

private

float GridMap::_liquidLevel

private

float* GridMap::_liquidMap

private

uint8 GridMap::_liquidOffX

private

uint8 GridMap::_liquidOffY

private

uint16 GridMap::_liquidType

private

uint8 GridMap::_liquidWidth

private

int16* GridMap::_maxHeight

private

int16* GridMap::_minHeight

private

uint16* GridMap::m_uint16_V8

uint16* GridMap::m_uint16_V9

uint8* GridMap::m_uint8_V8

uint8* GridMap::m_uint8_V9

float* GridMap::m_V8

float* GridMap::m_V9

---

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

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