GridMap Class Reference

#include "Map.h"

Public Member Functions
	GridMap ()
	~GridMap ()
bool	loadData (char *filaname)
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
LiquidData const	GetLiquidData (float x, float y, float z, float collisionHeight, uint8 ReqLiquidType) const

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)
bool	loadHolesData (FILE *in, uint32 offset, uint32 size)
bool	isHole (int row, int col) const
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	_liquidGlobalEntry
uint8	_liquidGlobalFlags
uint8	_liquidOffX
uint8	_liquidOffY
uint8	_liquidWidth
uint8	_liquidHeight
uint16 *	_holes
GetHeightPtr	_gridGetHeight

Detailed Description

Member Typedef Documentation

GetHeightPtr

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

private

Constructor & Destructor Documentation

GridMap()

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
    _liquidGlobalEntry = 0;
    _liquidGlobalFlags = 0;
    _liquidOffX   = 0;
    _liquidOffY   = 0;
    _liquidWidth  = 0;
    _liquidHeight = 0;
    _liquidLevel = INVALID_HEIGHT;
    _liquidEntry = nullptr;
    _liquidFlags = nullptr;
    _liquidMap  = nullptr;
    _holes = nullptr;
}

References _areaMap, _flags, _gridArea, _gridGetHeight, _gridHeight, _gridIntHeightMultiplier, _holes, _liquidEntry, _liquidFlags, _liquidGlobalEntry, _liquidGlobalFlags, _liquidHeight, _liquidLevel, _liquidMap, _liquidOffX, _liquidOffY, _liquidWidth, _maxHeight, _minHeight, getHeightFromFlat(), INVALID_HEIGHT, m_V8, and m_V9.

~GridMap()

GridMap::~GridMap

(

)

{
    unloadData();
}

References unloadData().

Member Function Documentation

getArea()

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

{
    if (!_areaMap)
        return _gridArea;
 
    x = 16 * (32 - x / SIZE_OF_GRIDS);
    y = 16 * (32 - y / SIZE_OF_GRIDS);
    int lx = (int)x & 15;
    int ly = (int)y & 15;
    return _areaMap[lx * 16 + ly];
}

References _areaMap, _gridArea, and SIZE_OF_GRIDS.

Referenced by Map::GetFullTerrainStatusForPosition(), and GetLiquidData().

getHeight()

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

inline

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

Referenced by Map::GetFullTerrainStatusForPosition(), and GetLiquidData().

getHeightFromFlat()

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

private

{
    return _gridHeight;
}

References _gridHeight.

Referenced by GridMap(), loadHeightData(), and unloadData().

getHeightFromFloat()

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

private

{
    if (!m_V8 || !m_V9)
        return _gridHeight;
 
    x = MAP_RESOLUTION * (32 - x / SIZE_OF_GRIDS);
    y = MAP_RESOLUTION * (32 - 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);
 
    if (isHole(x_int, y_int))
        return INVALID_HEIGHT;
 
    // 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;
}

References _gridHeight, INVALID_HEIGHT, isHole(), m_V8, m_V9, MAP_RESOLUTION, and SIZE_OF_GRIDS.

Referenced by loadHeightData().

getHeightFromUint16()

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

private

{
    if (!m_uint16_V8 || !m_uint16_V9)
        return _gridHeight;
 
    x = MAP_RESOLUTION * (32 - x / SIZE_OF_GRIDS);
    y = MAP_RESOLUTION * (32 - 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);
 
    if (isHole(x_int, y_int))
        return INVALID_HEIGHT;
 
    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;
}

References _gridHeight, _gridIntHeightMultiplier, INVALID_HEIGHT, isHole(), m_uint16_V8, m_uint16_V9, MAP_RESOLUTION, and SIZE_OF_GRIDS.

Referenced by loadHeightData().

getHeightFromUint8()

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

private

{
    if (!m_uint8_V8 || !m_uint8_V9)
        return _gridHeight;
 
    x = MAP_RESOLUTION * (32 - x / SIZE_OF_GRIDS);
    y = MAP_RESOLUTION * (32 - 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);
 
    if (isHole(x_int, y_int))
        return INVALID_HEIGHT;
 
    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;
}

References _gridHeight, _gridIntHeightMultiplier, INVALID_HEIGHT, isHole(), m_uint8_V8, m_uint8_V9, MAP_RESOLUTION, and SIZE_OF_GRIDS.

Referenced by loadHeightData().

GetLiquidData()

LiquidData const GridMap::GetLiquidData ( float  x, float  y, float  z, float  collisionHeight, uint8  ReqLiquidType  ) const

inline

{
    LiquidData liquidData;
 
    // Check water type (if no water return)
    if (_liquidGlobalFlags || _liquidFlags)
    {
        // Get cell
        float cx = MAP_RESOLUTION * (32 - x / SIZE_OF_GRIDS);
        float cy = MAP_RESOLUTION * (32 - 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] : _liquidGlobalFlags;
        uint32 entry = _liquidEntry ? _liquidEntry[idx] : _liquidGlobalEntry;
        if (LiquidTypeEntry const* liquidEntry = sLiquidTypeStore.LookupEntry(entry))
        {
            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->LiquidTypeOverride[liquidEntry->Type];
                    if (!overrideLiquid && area->zone)
                    {
                        area = sAreaTableStore.LookupEntry(area->zone);
                        if (area)
                            overrideLiquid = area->LiquidTypeOverride[liquidEntry->Type];
                    }
 
                    if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(overrideLiquid))
                    {
                        entry      = overrideLiquid;
                        liqTypeIdx = liq->Type;
                    }
                }
            }
 
            type |= 1 << liqTypeIdx;
        }
 
         // Check req liquid type mask
        if (type != 0 && (!ReqLiquidType || (ReqLiquidType & type) != 0))
        {
            // 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 && ly_int >= 0 && ly_int < _liquidWidth)
            {
                // Get water level
                float liquid_level = _liquidMap ? _liquidMap[lx_int * _liquidWidth + ly_int] : _liquidLevel;
                // Get ground level
                float ground_level = getHeight(x, y);
 
                // Check water level and ground level (sub 0.2 for fix some errors)
                if (liquid_level >= ground_level && z >= ground_level - 0.2f)
                {
                    // All ok in water -> store data
                    liquidData.Entry  = entry;
                    liquidData.Flags = type;
                    liquidData.Level = liquid_level;
                    liquidData.DepthLevel = ground_level;
 
                    // For speed check as int values
                    float delta = liquid_level - z;
 
                    if (delta > collisionHeight)
                        liquidData.Status = LIQUID_MAP_UNDER_WATER;
                    else if (delta > 0.0f)
                        liquidData.Status = LIQUID_MAP_IN_WATER;
                    else if (delta > -0.1f)
                        liquidData.Status = LIQUID_MAP_WATER_WALK;
                    else
                        liquidData.Status = LIQUID_MAP_ABOVE_WATER;
                }
            }
        }
    }
 
    return liquidData;
}

References _liquidEntry, _liquidFlags, _liquidGlobalEntry, _liquidGlobalFlags, _liquidLevel, _liquidMap, _liquidOffX, _liquidOffY, _liquidWidth, LiquidData::DepthLevel, LiquidData::Entry, LiquidData::Flags, getArea(), getHeight(), LiquidData::Level, LIQUID_MAP_ABOVE_WATER, LIQUID_MAP_IN_WATER, LIQUID_MAP_UNDER_WATER, LIQUID_MAP_WATER_WALK, MAP_LIQUID_TYPE_DARK_WATER, MAP_RESOLUTION, sAreaTableStore, SIZE_OF_GRIDS, sLiquidTypeStore, and LiquidData::Status.

Referenced by Map::GetFullTerrainStatusForPosition().

getLiquidLevel()

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

{
    if (!_liquidMap)
        return _liquidLevel;
 
    x = MAP_RESOLUTION * (32 - x / SIZE_OF_GRIDS);
    y = MAP_RESOLUTION * (32 - 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];
}

References _liquidHeight, _liquidLevel, _liquidMap, _liquidOffX, _liquidOffY, _liquidWidth, INVALID_HEIGHT, MAP_RESOLUTION, and SIZE_OF_GRIDS.

getMinHeight()

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));
}

References _minHeight, Cell::CellX(), Cell::CellY(), CENTER_GRID_ID, Cell::GridX(), Cell::GridY(), MAX_NUMBER_OF_CELLS, and SIZE_OF_GRIDS.

isHole()

bool GridMap::isHole ( int  row, int  col  ) const

private

{
    if (!_holes)
        return false;
 
    int cellRow = row / 8; // 8 squares per cell
    int cellCol = col / 8;
    int holeRow = row % 8 / 2;
    int holeCol = (col - (cellCol * 8)) / 2;
 
    uint16 hole = _holes[cellRow * 16 + cellCol];
 
    return (hole & holetab_h[holeCol] & holetab_v[holeRow]) != 0;
}

References _holes, holetab_h, and holetab_v.

Referenced by getHeightFromFloat(), getHeightFromUint16(), and getHeightFromUint8().

loadAreaData()

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;
}

References _areaMap, _gridArea, u_map_magic::asUInt, map_areaHeader::flags, map_areaHeader::fourcc, map_areaHeader::gridArea, MAP_AREA_NO_AREA, and MapAreaMagic.

Referenced by loadData().

loadData()

bool GridMap::loadData

(

char *

filaname

)

{
    // 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 == MapMagic.asUInt && header.versionMagic == MapVersionMagic)
    {
        // loadup area data
        if (header.areaMapOffset && !loadAreaData(in, header.areaMapOffset, header.areaMapSize))
        {
            LOG_ERROR("maps", "Error loading map area data\n");
            fclose(in);
            return false;
        }
        // loadup height data
        if (header.heightMapOffset && !loadHeightData(in, header.heightMapOffset, header.heightMapSize))
        {
            LOG_ERROR("maps", "Error loading map height data\n");
            fclose(in);
            return false;
        }
        // loadup liquid data
        if (header.liquidMapOffset && !loadLiquidData(in, header.liquidMapOffset, header.liquidMapSize))
        {
            LOG_ERROR("maps", "Error loading map liquids data\n");
            fclose(in);
            return false;
        }
        // loadup holes data (if any. check header.holesOffset)
        if (header.holesSize && !loadHolesData(in, header.holesOffset, header.holesSize))
        {
            LOG_ERROR("maps", "Error loading map holes data\n");
            fclose(in);
            return false;
        }
        fclose(in);
        return true;
    }
    LOG_ERROR("maps", "Map file '{}' is from an incompatible clientversion. Please recreate using the mapextractor.", filename);
    fclose(in);
    return false;
}

References map_fileheader::areaMapOffset, map_fileheader::areaMapSize, u_map_magic::asUInt, map_fileheader::heightMapOffset, map_fileheader::heightMapSize, map_fileheader::holesOffset, map_fileheader::holesSize, map_fileheader::liquidMapOffset, map_fileheader::liquidMapSize, loadAreaData(), loadHeightData(), loadHolesData(), loadLiquidData(), LOG_ERROR, MapMagic, map_fileheader::mapMagic, MapVersionMagic, unloadData(), and map_fileheader::versionMagic.

loadHeightData()

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;
}

References _gridGetHeight, _gridHeight, _gridIntHeightMultiplier, _maxHeight, _minHeight, u_map_magic::asUInt, map_heightHeader::flags, map_heightHeader::fourcc, getHeightFromFlat(), getHeightFromFloat(), getHeightFromUint16(), getHeightFromUint8(), map_heightHeader::gridHeight, map_heightHeader::gridMaxHeight, m_uint16_V8, m_uint16_V9, m_uint8_V8, m_uint8_V9, m_V8, m_V9, MAP_HEIGHT_AS_INT16, MAP_HEIGHT_AS_INT8, MAP_HEIGHT_HAS_FLIGHT_BOUNDS, MAP_HEIGHT_NO_HEIGHT, and MapHeightMagic.

Referenced by loadData().

loadHolesData()

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

private

{
    if (fseek(in, offset, SEEK_SET) != 0)
        return false;
 
    _holes = new uint16[16 * 16];
    if (fread(_holes, sizeof(uint16), 16 * 16, in) != 16 * 16)
        return false;
 
    return true;
}

References _holes.

Referenced by loadData().

loadLiquidData()

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;
 
    _liquidGlobalEntry = header.liquidType;
    _liquidGlobalFlags = header.liquidFlags;
    _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;
}

References _liquidEntry, _liquidFlags, _liquidGlobalEntry, _liquidGlobalFlags, _liquidHeight, _liquidLevel, _liquidMap, _liquidOffX, _liquidOffY, _liquidWidth, u_map_magic::asUInt, map_liquidHeader::flags, map_liquidHeader::fourcc, map_liquidHeader::height, map_liquidHeader::liquidFlags, map_liquidHeader::liquidLevel, map_liquidHeader::liquidType, MAP_LIQUID_NO_HEIGHT, MAP_LIQUID_NO_TYPE, MapLiquidMagic, map_liquidHeader::offsetX, map_liquidHeader::offsetY, and map_liquidHeader::width.

Referenced by loadData().

unloadData()

void GridMap::unloadData

(

)

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

References _areaMap, _gridGetHeight, _holes, _liquidEntry, _liquidFlags, _liquidMap, _maxHeight, _minHeight, getHeightFromFlat(), m_V8, and m_V9.

Referenced by loadData(), Map::UnloadGrid(), and ~GridMap().

Member Data Documentation

union { ... } GridMap::@292

union { ... } GridMap::@294

_areaMap

uint16* GridMap::_areaMap

private

Referenced by getArea(), GridMap(), loadAreaData(), and unloadData().

_flags

uint32 GridMap::_flags

private

Referenced by GridMap().

_gridArea

uint16 GridMap::_gridArea

private

Referenced by getArea(), GridMap(), and loadAreaData().

_gridGetHeight

GetHeightPtr GridMap::_gridGetHeight

private

Referenced by GridMap(), loadHeightData(), and unloadData().

_gridHeight

float GridMap::_gridHeight

private

Referenced by getHeightFromFlat(), getHeightFromFloat(), getHeightFromUint16(), getHeightFromUint8(), GridMap(), and loadHeightData().

_gridIntHeightMultiplier

float GridMap::_gridIntHeightMultiplier

private

Referenced by getHeightFromUint16(), getHeightFromUint8(), GridMap(), and loadHeightData().

_holes

uint16* GridMap::_holes

private

Referenced by GridMap(), isHole(), loadHolesData(), and unloadData().

_liquidEntry

uint16* GridMap::_liquidEntry

private

Referenced by GetLiquidData(), GridMap(), loadLiquidData(), and unloadData().

_liquidFlags

uint8* GridMap::_liquidFlags

private

Referenced by GetLiquidData(), GridMap(), loadLiquidData(), and unloadData().

_liquidGlobalEntry

uint16 GridMap::_liquidGlobalEntry

private

Referenced by GetLiquidData(), GridMap(), and loadLiquidData().

_liquidGlobalFlags

uint8 GridMap::_liquidGlobalFlags

private

Referenced by GetLiquidData(), GridMap(), and loadLiquidData().

_liquidHeight

uint8 GridMap::_liquidHeight

private

Referenced by getLiquidLevel(), GridMap(), and loadLiquidData().

_liquidLevel

float GridMap::_liquidLevel

private

Referenced by GetLiquidData(), getLiquidLevel(), GridMap(), and loadLiquidData().

_liquidMap

float* GridMap::_liquidMap

private

Referenced by GetLiquidData(), getLiquidLevel(), GridMap(), loadLiquidData(), and unloadData().

_liquidOffX

uint8 GridMap::_liquidOffX

private

Referenced by GetLiquidData(), getLiquidLevel(), GridMap(), and loadLiquidData().

_liquidOffY

uint8 GridMap::_liquidOffY

private

Referenced by GetLiquidData(), getLiquidLevel(), GridMap(), and loadLiquidData().

_liquidWidth

uint8 GridMap::_liquidWidth

private

Referenced by GetLiquidData(), getLiquidLevel(), GridMap(), and loadLiquidData().

_maxHeight

int16* GridMap::_maxHeight

private

Referenced by GridMap(), loadHeightData(), and unloadData().

_minHeight

int16* GridMap::_minHeight

private

Referenced by getMinHeight(), GridMap(), loadHeightData(), and unloadData().

m_uint16_V8

uint16* GridMap::m_uint16_V8

Referenced by getHeightFromUint16(), and loadHeightData().

m_uint16_V9

uint16* GridMap::m_uint16_V9

Referenced by getHeightFromUint16(), and loadHeightData().

m_uint8_V8

uint8* GridMap::m_uint8_V8

Referenced by getHeightFromUint8(), and loadHeightData().

m_uint8_V9

uint8* GridMap::m_uint8_V9

Referenced by getHeightFromUint8(), and loadHeightData().

m_V8

float* GridMap::m_V8

Referenced by getHeightFromFloat(), GridMap(), loadHeightData(), and unloadData().

m_V9

float* GridMap::m_V9

Referenced by getHeightFromFloat(), GridMap(), loadHeightData(), and unloadData().