aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/common/Collision/Maps/MapDefines.cpp24
-rw-r--r--src/common/Collision/Maps/MapDefines.h123
-rw-r--r--src/server/game/Entities/Object/Object.cpp2
-rw-r--r--src/server/game/Entities/Player/Player.cpp8
-rw-r--r--src/server/game/Entities/Unit/Unit.cpp2
-rw-r--r--src/server/game/Maps/Map.cpp96
-rw-r--r--src/server/game/Maps/Map.h92
-rw-r--r--src/server/game/Movement/PathGenerator.cpp14
-rw-r--r--src/server/game/Spells/Spell.cpp2
-rw-r--r--src/server/scripts/Commands/cs_misc.cpp4
-rw-r--r--src/tools/map_extractor/System.cpp159
-rw-r--r--src/tools/mmaps_generator/TerrainBuilder.cpp94
-rw-r--r--src/tools/mmaps_generator/TerrainBuilder.h4
13 files changed, 289 insertions, 335 deletions
diff --git a/src/common/Collision/Maps/MapDefines.cpp b/src/common/Collision/Maps/MapDefines.cpp
new file mode 100644
index 00000000000..4ce96e3ad39
--- /dev/null
+++ b/src/common/Collision/Maps/MapDefines.cpp
@@ -0,0 +1,24 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "MapDefines.h"
+
+u_map_magic const MapMagic = { 'M','A','P','S' };
+u_map_magic const MapVersionMagic = { 'v','1','.','9' };
+u_map_magic const MapAreaMagic = { 'A','R','E','A' };
+u_map_magic const MapHeightMagic = { 'M','H','G','T' };
+u_map_magic const MapLiquidMagic = { 'M','L','I','Q' };
diff --git a/src/common/Collision/Maps/MapDefines.h b/src/common/Collision/Maps/MapDefines.h
new file mode 100644
index 00000000000..304a1da8985
--- /dev/null
+++ b/src/common/Collision/Maps/MapDefines.h
@@ -0,0 +1,123 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MapDefines_h__
+#define MapDefines_h__
+
+#include "Define.h"
+#include "EnumFlag.h"
+#include <array>
+
+/// Represents a map magic value of 4 bytes (used in versions)
+using u_map_magic = std::array<char, 4>;
+
+TC_COMMON_API extern u_map_magic const MapMagic;
+TC_COMMON_API extern u_map_magic const MapVersionMagic;
+TC_COMMON_API extern u_map_magic const MapAreaMagic;
+TC_COMMON_API extern u_map_magic const MapHeightMagic;
+TC_COMMON_API extern u_map_magic const MapLiquidMagic;
+
+// ******************************************
+// Map file format defines
+// ******************************************
+struct map_fileheader
+{
+ u_map_magic mapMagic;
+ u_map_magic versionMagic;
+ uint32 buildMagic;
+ uint32 areaMapOffset;
+ uint32 areaMapSize;
+ uint32 heightMapOffset;
+ uint32 heightMapSize;
+ uint32 liquidMapOffset;
+ uint32 liquidMapSize;
+ uint32 holesOffset;
+ uint32 holesSize;
+};
+
+enum class map_areaHeaderFlags : uint16
+{
+ None = 0x0000,
+ NoArea = 0x0001
+};
+
+DEFINE_ENUM_FLAG(map_areaHeaderFlags);
+
+struct map_areaHeader
+{
+ u_map_magic areaMagic;
+ EnumFlag<map_areaHeaderFlags> flags = map_areaHeaderFlags::None;
+ uint16 gridArea;
+};
+
+enum class map_heightHeaderFlags : uint32
+{
+ None = 0x0000,
+ NoHeight = 0x0001,
+ HeightAsInt16 = 0x0002,
+ HeightAsInt8 = 0x0004,
+ HasFlightBounds = 0x0008
+};
+
+DEFINE_ENUM_FLAG(map_heightHeaderFlags);
+
+struct map_heightHeader
+{
+ u_map_magic heightMagic;
+ EnumFlag<map_heightHeaderFlags> flags = map_heightHeaderFlags::None;
+ float gridHeight;
+ float gridMaxHeight;
+};
+
+enum class map_liquidHeaderFlags : uint8
+{
+ None = 0x0000,
+ NoType = 0x0001,
+ NoHeight = 0x0002
+};
+
+DEFINE_ENUM_FLAG(map_liquidHeaderFlags);
+
+enum class map_liquidHeaderTypeFlags : uint8
+{
+ NoWater = 0x00,
+ Water = 0x01,
+ Ocean = 0x02,
+ Magma = 0x04,
+ Slime = 0x08,
+
+ DarkWater = 0x10,
+
+ AllLiquids = Water | Ocean | Magma | Slime
+};
+
+DEFINE_ENUM_FLAG(map_liquidHeaderTypeFlags);
+
+struct map_liquidHeader
+{
+ u_map_magic liquidMagic;
+ EnumFlag<map_liquidHeaderFlags> flags = map_liquidHeaderFlags::None;
+ EnumFlag<map_liquidHeaderTypeFlags> liquidFlags = map_liquidHeaderTypeFlags::NoWater;
+ uint16 liquidType;
+ uint8 offsetX;
+ uint8 offsetY;
+ uint8 width;
+ uint8 height;
+ float liquidLevel;
+};
+
+#endif // MapDefines_h__
diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index 44e63f22155..d81cc5fd86d 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -930,7 +930,7 @@ void WorldObject::CleanupsBeforeDelete(bool /*finalCleanup*/)
void WorldObject::UpdatePositionData()
{
PositionFullTerrainStatus data;
- GetMap()->GetFullTerrainStatusForPosition(_phaseShift, GetPositionX(), GetPositionY(), GetPositionZ(), data, MAP_ALL_LIQUIDS);
+ GetMap()->GetFullTerrainStatusForPosition(_phaseShift, GetPositionX(), GetPositionY(), GetPositionZ(), data, map_liquidHeaderTypeFlags::AllLiquids);
ProcessPositionDataChanged(data);
}
diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index d6f7cfb7bad..417e41482e5 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -25794,7 +25794,7 @@ void Player::ProcessTerrainStatusUpdate(ZLiquidStatus status, Optional<LiquidDat
if (status && liquidData)
{
// Breath bar state (under water in any liquid type)
- if (liquidData->type_flags & MAP_ALL_LIQUIDS)
+ if (liquidData->type_flags.HasFlag(map_liquidHeaderTypeFlags::AllLiquids))
{
if (status & LIQUID_MAP_UNDER_WATER)
m_MirrorTimerFlags |= UNDERWATER_INWATER;
@@ -25803,13 +25803,13 @@ void Player::ProcessTerrainStatusUpdate(ZLiquidStatus status, Optional<LiquidDat
}
// Fatigue bar state (if not on flight path or transport)
- if ((liquidData->type_flags & MAP_LIQUID_TYPE_DARK_WATER) && !IsInFlight() && !GetTransport())
+ if (liquidData->type_flags.HasFlag(map_liquidHeaderTypeFlags::DarkWater) && !IsInFlight() && !GetTransport())
m_MirrorTimerFlags |= UNDERWATER_INDARKWATER;
else
m_MirrorTimerFlags &= ~UNDERWATER_INDARKWATER;
// Lava state (any contact)
- if (liquidData->type_flags & MAP_LIQUID_TYPE_MAGMA)
+ if (liquidData->type_flags.HasFlag(map_liquidHeaderTypeFlags::Magma))
{
if (status & MAP_LIQUID_STATUS_IN_CONTACT)
m_MirrorTimerFlags |= UNDERWATER_INLAVA;
@@ -25818,7 +25818,7 @@ void Player::ProcessTerrainStatusUpdate(ZLiquidStatus status, Optional<LiquidDat
}
// Slime state (any contact)
- if (liquidData->type_flags & MAP_LIQUID_TYPE_SLIME)
+ if (liquidData->type_flags.HasFlag(map_liquidHeaderTypeFlags::Slime))
{
if (status & MAP_LIQUID_STATUS_IN_CONTACT)
m_MirrorTimerFlags |= UNDERWATER_INSLIME;
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index e933ea7b38c..c37c7ea82fe 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -8009,7 +8009,7 @@ MountCapabilityEntry const* Unit::GetMountCapability(uint32 mountType) const
mountFlags = areaTable->MountFlags;
LiquidData liquid;
- ZLiquidStatus liquidStatus = GetMap()->GetLiquidStatus(GetPhaseShift(), GetPositionX(), GetPositionY(), GetPositionZ(), MAP_ALL_LIQUIDS, &liquid);
+ ZLiquidStatus liquidStatus = GetMap()->GetLiquidStatus(GetPhaseShift(), GetPositionX(), GetPositionY(), GetPositionZ(), map_liquidHeaderTypeFlags::AllLiquids, &liquid);
isSubmerged = (liquidStatus & LIQUID_MAP_UNDER_WATER) != 0 || HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
isInWater = (liquidStatus & (LIQUID_MAP_IN_WATER | LIQUID_MAP_UNDER_WATER)) != 0;
diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp
index 697015cfe3f..671292fe479 100644
--- a/src/server/game/Maps/Map.cpp
+++ b/src/server/game/Maps/Map.cpp
@@ -56,12 +56,6 @@
#include "Hacks/boost_1_74_fibonacci_heap.h"
BOOST_1_74_FIBONACCI_HEAP_MSVC_COMPILE_FIX(RespawnListContainer::value_type)
-u_map_magic MapMagic = { {'M','A','P','S'} };
-u_map_magic MapVersionMagic = { {'v','1','.','9'} };
-u_map_magic MapAreaMagic = { {'A','R','E','A'} };
-u_map_magic MapHeightMagic = { {'M','H','G','T'} };
-u_map_magic MapLiquidMagic = { {'M','L','I','Q'} };
-
#define DEFAULT_GRID_EXPIRY 300
#define MAX_GRID_LOAD_TIME 50
#define MAX_CREATURE_ATTACK_RADIUS (45.0f * sWorld->getRate(RATE_CREATURE_AGGRO))
@@ -106,14 +100,14 @@ void Map::DiscoverGridMapFiles()
// tile list is optional
if (FILE* tileList = fopen(tileListName.c_str(), "rb"))
{
- u_map_magic mapMagic;
- u_map_magic versionMagic;
+ u_map_magic mapMagic = { };
+ u_map_magic versionMagic = { };
uint32 build;
- char tilesData[MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS];
- if (fread(&mapMagic.asUInt, sizeof(u_map_magic), 1, tileList) == 1
- && mapMagic.asUInt == MapMagic.asUInt
- && fread(&versionMagic.asUInt, sizeof(u_map_magic), 1, tileList) == 1
- && versionMagic.asUInt == MapVersionMagic.asUInt
+ char tilesData[MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS] = { };
+ if (fread(mapMagic.data(), mapMagic.size(), 1, tileList) == 1
+ && mapMagic == MapMagic
+ && fread(versionMagic.data(), versionMagic.size(), 1, tileList) == 1
+ && versionMagic == MapVersionMagic
&& fread(&build, sizeof(build), 1, tileList) == 1
&& fread(&tilesData[0], MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS, 1, tileList) == 1)
{
@@ -158,11 +152,11 @@ bool Map::ExistMap(uint32 mapid, int gx, int gy, bool log /*= true*/)
map_fileheader header;
if (fread(&header, sizeof(header), 1, file) == 1)
{
- if (header.mapMagic.asUInt != MapMagic.asUInt || header.versionMagic.asUInt != MapVersionMagic.asUInt)
+ if (header.mapMagic != MapMagic || header.versionMagic != MapVersionMagic)
{
if (log)
TC_LOG_ERROR("maps", "Map file '%s' is from an incompatible map version (%.*s %.*s), %.*s %.*s is expected. Please pull your source, recompile tools and recreate maps using the updated mapextractor, then replace your old map files with new files. If you still have problems search on forum for error TCE00018.",
- fileName.c_str(), 4, header.mapMagic.asChar, 4, header.versionMagic.asChar, 4, MapMagic.asChar, 4, MapVersionMagic.asChar);
+ fileName.c_str(), 4, header.mapMagic.data(), 4, header.versionMagic.data(), 4, MapMagic.data(), 4, MapVersionMagic.data());
}
else
ret = true;
@@ -1842,7 +1836,7 @@ GridMap::GridMap()
_minHeightPlanes = nullptr;
// Liquid data
_liquidGlobalEntry = 0;
- _liquidGlobalFlags = 0;
+ _liquidGlobalFlags = map_liquidHeaderTypeFlags::NoWater;
_liquidOffX = 0;
_liquidOffY = 0;
_liquidWidth = 0;
@@ -1875,7 +1869,7 @@ GridMap::LoadResult GridMap::loadData(char const* filename)
return LoadResult::InvalidFile;
}
- if (header.mapMagic.asUInt == MapMagic.asUInt && header.versionMagic.asUInt == MapVersionMagic.asUInt)
+ if (header.mapMagic == MapMagic && header.versionMagic == MapVersionMagic)
{
// load up area data
if (header.areaMapOffset && !loadAreaData(in, header.areaMapOffset, header.areaMapSize))
@@ -1903,7 +1897,7 @@ GridMap::LoadResult GridMap::loadData(char const* filename)
}
TC_LOG_ERROR("maps", "Map file '%s' is from an incompatible map version (%.*s %.*s), %.*s %.*s is expected. Please pull your source, recompile tools and recreate maps using the updated mapextractor, then replace your old map files with new files. If you still have problems search on forum for error TCE00018.",
- filename, 4, header.mapMagic.asChar, 4, header.versionMagic.asChar, 4, MapMagic.asChar, 4, MapVersionMagic.asChar);
+ filename, 4, header.mapMagic.data(), 4, header.versionMagic.data(), 4, MapMagic.data(), 4, MapVersionMagic.data());
fclose(in);
return LoadResult::InvalidFile;
}
@@ -1932,11 +1926,11 @@ bool GridMap::loadAreaData(FILE* in, uint32 offset, uint32 /*size*/)
map_areaHeader header;
fseek(in, offset, SEEK_SET);
- if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapAreaMagic.asUInt)
+ if (fread(&header, sizeof(header), 1, in) != 1 || header.areaMagic != MapAreaMagic)
return false;
_gridArea = header.gridArea;
- if (!(header.flags & MAP_AREA_NO_AREA))
+ if (!header.flags.HasFlag(map_areaHeaderFlags::NoArea))
{
_areaMap = new uint16[16 * 16];
if (fread(_areaMap, sizeof(uint16), 16*16, in) != 16*16)
@@ -1950,13 +1944,13 @@ bool GridMap::loadHeightData(FILE* in, uint32 offset, uint32 /*size*/)
map_heightHeader header;
fseek(in, offset, SEEK_SET);
- if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapHeightMagic.asUInt)
+ if (fread(&header, sizeof(header), 1, in) != 1 || header.heightMagic != MapHeightMagic)
return false;
_gridHeight = header.gridHeight;
- if (!(header.flags & MAP_HEIGHT_NO_HEIGHT))
+ if (!header.flags.HasFlag(map_heightHeaderFlags::NoHeight))
{
- if ((header.flags & MAP_HEIGHT_AS_INT16))
+ if (header.flags.HasFlag(map_heightHeaderFlags::HeightAsInt16))
{
m_uint16_V9 = new uint16 [129*129];
m_uint16_V8 = new uint16 [128*128];
@@ -1966,7 +1960,7 @@ bool GridMap::loadHeightData(FILE* in, uint32 offset, uint32 /*size*/)
_gridIntHeightMultiplier = (header.gridMaxHeight - header.gridHeight) / 65535;
_gridGetHeight = &GridMap::getHeightFromUint16;
}
- else if ((header.flags & MAP_HEIGHT_AS_INT8))
+ else if (header.flags.HasFlag(map_heightHeaderFlags::HeightAsInt8))
{
m_uint8_V9 = new uint8 [129*129];
m_uint8_V8 = new uint8 [128*128];
@@ -1989,7 +1983,7 @@ bool GridMap::loadHeightData(FILE* in, uint32 offset, uint32 /*size*/)
else
_gridGetHeight = &GridMap::getHeightFromFlat;
- if (header.flags & MAP_HEIGHT_HAS_FLIGHT_BOUNDS)
+ if (header.flags.HasFlag(map_heightHeaderFlags::HasFlightBounds))
{
std::array<int16, 9> maxHeights;
std::array<int16, 9> minHeights;
@@ -2039,7 +2033,7 @@ bool GridMap::loadLiquidData(FILE* in, uint32 offset, uint32 /*size*/)
map_liquidHeader header;
fseek(in, offset, SEEK_SET);
- if (fread(&header, sizeof(header), 1, in) != 1 || header.fourcc != MapLiquidMagic.asUInt)
+ if (fread(&header, sizeof(header), 1, in) != 1 || header.liquidMagic != MapLiquidMagic)
return false;
_liquidGlobalEntry = header.liquidType;
@@ -2050,17 +2044,17 @@ bool GridMap::loadLiquidData(FILE* in, uint32 offset, uint32 /*size*/)
_liquidHeight = header.height;
_liquidLevel = header.liquidLevel;
- if (!(header.flags & MAP_LIQUID_NO_TYPE))
+ if (!header.flags.HasFlag(map_liquidHeaderFlags::NoType))
{
_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)
+ _liquidFlags = new map_liquidHeaderTypeFlags[16*16];
+ if (fread(_liquidFlags, sizeof(map_liquidHeaderTypeFlags), 16*16, in) != 16*16)
return false;
}
- if (!(header.flags & MAP_LIQUID_NO_HEIGHT))
+ if (!header.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
{
_liquidMap = new float[uint32(_liquidWidth) * uint32(_liquidHeight)];
if (fread(_liquidMap, sizeof(float), _liquidWidth*_liquidHeight, in) != (uint32(_liquidWidth) * uint32(_liquidHeight)))
@@ -2352,10 +2346,10 @@ float GridMap::getLiquidLevel(float x, float y) const
}
// Why does this return LIQUID data?
-uint8 GridMap::getTerrainType(float x, float y) const
+map_liquidHeaderTypeFlags GridMap::getTerrainType(float x, float y) const
{
if (!_liquidFlags)
- return 0;
+ return map_liquidHeaderTypeFlags::NoWater;
x = 16 * (CENTER_GRID_ID - x/SIZE_OF_GRIDS);
y = 16 * (CENTER_GRID_ID - y/SIZE_OF_GRIDS);
@@ -2365,10 +2359,10 @@ uint8 GridMap::getTerrainType(float x, float y) const
}
// Get water state on map
-inline ZLiquidStatus GridMap::GetLiquidStatus(float x, float y, float z, uint8 ReqLiquidType, LiquidData* data, float collisionHeight)
+inline ZLiquidStatus GridMap::GetLiquidStatus(float x, float y, float z, Optional<map_liquidHeaderTypeFlags> ReqLiquidType, LiquidData* data, float collisionHeight)
{
// Check water type (if no water return)
- if (!_liquidGlobalFlags && !_liquidFlags)
+ if (_liquidGlobalFlags == map_liquidHeaderTypeFlags::NoWater && !_liquidFlags)
return LIQUID_MAP_NO_WATER;
// Get cell
@@ -2380,11 +2374,11 @@ inline ZLiquidStatus GridMap::GetLiquidStatus(float x, float y, float z, uint8 R
// Check water type in cell
int idx=(x_int>>3)*16 + (y_int>>3);
- uint8 type = _liquidFlags ? _liquidFlags[idx] : _liquidGlobalFlags;
+ map_liquidHeaderTypeFlags type = _liquidFlags ? _liquidFlags[idx] : _liquidGlobalFlags;
uint32 entry = _liquidEntry ? _liquidEntry[idx] : _liquidGlobalEntry;
if (LiquidTypeEntry const* liquidEntry = sLiquidTypeStore.LookupEntry(entry))
{
- type &= MAP_LIQUID_TYPE_DARK_WATER;
+ type &= map_liquidHeaderTypeFlags::DarkWater;
uint32 liqTypeIdx = liquidEntry->SoundBank;
if (entry < 21)
{
@@ -2406,14 +2400,14 @@ inline ZLiquidStatus GridMap::GetLiquidStatus(float x, float y, float z, uint8 R
}
}
- type |= 1 << liqTypeIdx;
+ type |= map_liquidHeaderTypeFlags(1 << liqTypeIdx);
}
- if (type == 0)
+ if (type == map_liquidHeaderTypeFlags::NoWater)
return LIQUID_MAP_NO_WATER;
// Check req liquid type mask
- if (ReqLiquidType && !(ReqLiquidType&type))
+ if (ReqLiquidType && (*ReqLiquidType & type) == map_liquidHeaderTypeFlags::NoWater)
return LIQUID_MAP_NO_WATER;
// Check water level:
@@ -2438,7 +2432,7 @@ inline ZLiquidStatus GridMap::GetLiquidStatus(float x, float y, float z, uint8 R
if (data)
{
data->entry = entry;
- data->type_flags = type;
+ data->type_flags = type;
data->level = liquid_level;
data->depth_level = ground_level;
}
@@ -2490,7 +2484,7 @@ float Map::GetWaterOrGroundLevel(PhaseShift const& phaseShift, float x, float y,
LiquidData liquid_status;
- ZLiquidStatus res = GetLiquidStatus(phaseShift, x, y, ground_z, MAP_ALL_LIQUIDS, &liquid_status, collisionHeight);
+ ZLiquidStatus res = GetLiquidStatus(phaseShift, x, y, ground_z, map_liquidHeaderTypeFlags::AllLiquids, &liquid_status, collisionHeight);
switch (res)
{
case LIQUID_MAP_ABOVE_WATER:
@@ -2703,15 +2697,15 @@ void Map::GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32&
zoneid = area->ParentAreaID;
}
-uint8 Map::GetTerrainType(PhaseShift const& phaseShift, float x, float y)
+map_liquidHeaderTypeFlags Map::GetTerrainType(PhaseShift const& phaseShift, float x, float y)
{
if (GridMap* gmap = GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
return gmap->getTerrainType(x, y);
else
- return 0;
+ return map_liquidHeaderTypeFlags::NoWater;
}
-ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float y, float z, uint8 ReqLiquidType, LiquidData* data, float collisionHeight)
+ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float y, float z, map_liquidHeaderTypeFlags ReqLiquidType, LiquidData* data, float collisionHeight)
{
ZLiquidStatus result = LIQUID_MAP_NO_WATER;
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
@@ -2719,7 +2713,7 @@ ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float
float ground_level = INVALID_HEIGHT;
uint32 liquid_type = 0;
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
- if (vmgr->GetLiquidLevel(terrainMapId, x, y, z, ReqLiquidType, liquid_level, ground_level, liquid_type))
+ if (vmgr->GetLiquidLevel(terrainMapId, x, y, z, AsUnderlyingType(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
@@ -2760,7 +2754,7 @@ ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float
data->depth_level = ground_level;
data->entry = liquid_type;
- data->type_flags = 1 << liquidFlagType;
+ data->type_flags = map_liquidHeaderTypeFlags(1 << liquidFlagType);
}
float delta = liquid_level - z;
@@ -2797,12 +2791,12 @@ ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float
return result;
}
-void Map::GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, float x, float y, float z, PositionFullTerrainStatus& data, uint8 reqLiquidType, float collisionHeight)
+void Map::GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, float x, float y, float z, PositionFullTerrainStatus& data, map_liquidHeaderTypeFlags reqLiquidType, float collisionHeight)
{
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::AreaAndLiquidData vmapData;
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
- vmgr->getAreaAndLiquidData(terrainMapId, x, y, z, reqLiquidType, vmapData);
+ vmgr->getAreaAndLiquidData(terrainMapId, x, y, z, AsUnderlyingType(reqLiquidType), vmapData);
if (vmapData.areaInfo)
data.areaInfo = boost::in_place(vmapData.areaInfo->adtId, vmapData.areaInfo->rootId, vmapData.areaInfo->groupId, vmapData.areaInfo->mogpFlags);
@@ -2870,7 +2864,7 @@ void Map::GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, float x,
data.liquidInfo->level = vmapData.liquidInfo->level;
data.liquidInfo->depth_level = vmapData.floorZ;
data.liquidInfo->entry = liquidType;
- data.liquidInfo->type_flags = 1 << liquidFlagType;
+ data.liquidInfo->type_flags = map_liquidHeaderTypeFlags(1 << liquidFlagType);
float delta = vmapData.liquidInfo->level - z;
if (delta > collisionHeight)
@@ -2934,12 +2928,12 @@ bool Map::IsInWater(PhaseShift const& phaseShift, float x, float y, float pZ, Li
{
LiquidData liquid_status;
LiquidData* liquid_ptr = data ? data : &liquid_status;
- return (GetLiquidStatus(phaseShift, x, y, pZ, MAP_ALL_LIQUIDS, liquid_ptr) & (LIQUID_MAP_IN_WATER | LIQUID_MAP_UNDER_WATER)) != 0;
+ return (GetLiquidStatus(phaseShift, x, y, pZ, map_liquidHeaderTypeFlags::AllLiquids, liquid_ptr) & (LIQUID_MAP_IN_WATER | LIQUID_MAP_UNDER_WATER)) != 0;
}
bool Map::IsUnderWater(PhaseShift const& phaseShift, float x, float y, float z)
{
- return (GetLiquidStatus(phaseShift, x, y, z, MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN) & LIQUID_MAP_UNDER_WATER) != 0;
+ return (GetLiquidStatus(phaseShift, x, y, z, map_liquidHeaderTypeFlags::Water | map_liquidHeaderTypeFlags::Ocean) & LIQUID_MAP_UNDER_WATER) != 0;
}
char const* Map::GetMapName() const
diff --git a/src/server/game/Maps/Map.h b/src/server/game/Maps/Map.h
index 0c85a237771..c3f87671069 100644
--- a/src/server/game/Maps/Map.h
+++ b/src/server/game/Maps/Map.h
@@ -25,6 +25,7 @@
#include "DynamicTree.h"
#include "GridDefines.h"
#include "GridRefManager.h"
+#include "MapDefines.h"
#include "MapRefManager.h"
#include "ObjectGuid.h"
#include "Optional.h"
@@ -80,69 +81,6 @@ struct ScriptAction
ScriptInfo const* script; ///> pointer to static script data
};
-/// Represents a map magic value of 4 bytes (used in versions)
-union u_map_magic
-{
- char asChar[4]; ///> Non-null terminated string
- uint32 asUInt; ///> uint32 representation
-};
-
-// ******************************************
-// Map file format defines
-// ******************************************
-struct map_fileheader
-{
- u_map_magic mapMagic;
- u_map_magic versionMagic;
- uint32 buildMagic;
- uint32 areaMapOffset;
- uint32 areaMapSize;
- uint32 heightMapOffset;
- uint32 heightMapSize;
- uint32 liquidMapOffset;
- uint32 liquidMapSize;
- uint32 holesOffset;
- uint32 holesSize;
-};
-
-#define MAP_AREA_NO_AREA 0x0001
-
-struct map_areaHeader
-{
- uint32 fourcc;
- uint16 flags;
- uint16 gridArea;
-};
-
-#define MAP_HEIGHT_NO_HEIGHT 0x0001
-#define MAP_HEIGHT_AS_INT16 0x0002
-#define MAP_HEIGHT_AS_INT8 0x0004
-#define MAP_HEIGHT_HAS_FLIGHT_BOUNDS 0x0008
-
-struct map_heightHeader
-{
- uint32 fourcc;
- uint32 flags;
- float gridHeight;
- float gridMaxHeight;
-};
-
-#define MAP_LIQUID_NO_TYPE 0x0001
-#define MAP_LIQUID_NO_HEIGHT 0x0002
-
-struct map_liquidHeader
-{
- uint32 fourcc;
- uint8 flags;
- uint8 liquidFlags;
- uint16 liquidType;
- uint8 offsetX;
- uint8 offsetY;
- uint8 width;
- uint8 height;
- float liquidLevel;
-};
-
enum ZLiquidStatus : uint32
{
LIQUID_MAP_NO_WATER = 0x00000000,
@@ -155,19 +93,9 @@ enum ZLiquidStatus : uint32
#define MAP_LIQUID_STATUS_SWIMMING (LIQUID_MAP_IN_WATER | LIQUID_MAP_UNDER_WATER)
#define MAP_LIQUID_STATUS_IN_CONTACT (MAP_LIQUID_STATUS_SWIMMING | LIQUID_MAP_WATER_WALK)
-#define MAP_LIQUID_TYPE_NO_WATER 0x00
-#define MAP_LIQUID_TYPE_WATER 0x01
-#define MAP_LIQUID_TYPE_OCEAN 0x02
-#define MAP_LIQUID_TYPE_MAGMA 0x04
-#define MAP_LIQUID_TYPE_SLIME 0x08
-
-#define MAP_ALL_LIQUIDS (MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN | MAP_LIQUID_TYPE_MAGMA | MAP_LIQUID_TYPE_SLIME)
-
-#define MAP_LIQUID_TYPE_DARK_WATER 0x10
-
struct LiquidData
{
- uint32 type_flags;
+ EnumFlag<map_liquidHeaderTypeFlags> type_flags = map_liquidHeaderTypeFlags::NoWater;
uint32 entry;
float level;
float depth_level;
@@ -215,11 +143,11 @@ class TC_GAME_API GridMap
// Liquid data
float _liquidLevel;
uint16* _liquidEntry;
- uint8* _liquidFlags;
+ map_liquidHeaderTypeFlags* _liquidFlags;
float* _liquidMap;
uint16 _gridArea;
uint16 _liquidGlobalEntry;
- uint8 _liquidGlobalFlags;
+ map_liquidHeaderTypeFlags _liquidGlobalFlags;
uint8 _liquidOffX;
uint8 _liquidOffY;
uint8 _liquidWidth;
@@ -255,8 +183,8 @@ public:
inline float getHeight(float x, float y) const {return (this->*_gridGetHeight)(x, y);}
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 = nullptr, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
+ map_liquidHeaderTypeFlags getTerrainType(float x, float y) const;
+ ZLiquidStatus GetLiquidStatus(float x, float y, float z, Optional<map_liquidHeaderTypeFlags> ReqLiquidType, LiquidData* data = nullptr, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
};
#pragma pack(push, 1)
@@ -401,9 +329,9 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
void AddChildTerrainMap(Map* map) { m_childTerrainMaps->push_back(map); map->m_parentTerrainMap = this; }
void UnlinkAllChildTerrainMaps() { m_childTerrainMaps->clear(); }
- void GetFullTerrainStatusForPosition(float x, float y, float z, PositionFullTerrainStatus& data, uint8 reqLiquidType = MAP_ALL_LIQUIDS, float collisionHeight = 2.03128f) const; // DEFAULT_COLLISION_HEIGHT in Object.h
- void GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, float x, float y, float z, PositionFullTerrainStatus& data, uint8 reqLiquidType = MAP_ALL_LIQUIDS, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
- ZLiquidStatus GetLiquidStatus(PhaseShift const& phaseShift, float x, float y, float z, uint8 ReqLiquidType, LiquidData* data = nullptr, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
+ void GetFullTerrainStatusForPosition(float x, float y, float z, PositionFullTerrainStatus& data, map_liquidHeaderTypeFlags reqLiquidType = map_liquidHeaderTypeFlags::AllLiquids, float collisionHeight = 2.03128f) const; // DEFAULT_COLLISION_HEIGHT in Object.h
+ void GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, float x, float y, float z, PositionFullTerrainStatus& data, map_liquidHeaderTypeFlags reqLiquidType = map_liquidHeaderTypeFlags::AllLiquids, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
+ ZLiquidStatus GetLiquidStatus(PhaseShift const& phaseShift, float x, float y, float z, map_liquidHeaderTypeFlags ReqLiquidType, LiquidData* data = nullptr, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h
bool GetAreaInfo(PhaseShift const& phaseShift, float x, float y, float z, uint32& mogpflags, int32& adtId, int32& rootId, int32& groupId);
uint32 GetAreaId(PhaseShift const& phaseShift, float x, float y, float z, bool *isOutdoors = nullptr);
@@ -415,7 +343,7 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
bool IsOutdoors(PhaseShift const& phaseShift, float x, float y, float z);
- uint8 GetTerrainType(PhaseShift const& phaseShift, float x, float y);
+ map_liquidHeaderTypeFlags GetTerrainType(PhaseShift const& phaseShift, float x, float y);
float GetWaterLevel(PhaseShift const& phaseShift, float x, float y);
bool IsInWater(PhaseShift const& phaseShift, float x, float y, float z, LiquidData* data = nullptr);
bool IsUnderWater(PhaseShift const& phaseShift, float x, float y, float z);
diff --git a/src/server/game/Movement/PathGenerator.cpp b/src/server/game/Movement/PathGenerator.cpp
index 5124c5c4bea..bcd5a82ca91 100644
--- a/src/server/game/Movement/PathGenerator.cpp
+++ b/src/server/game/Movement/PathGenerator.cpp
@@ -184,7 +184,7 @@ void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 con
// Check both start and end points, if they're both in water, then we can *safely* let the creature move
for (uint32 i = 0; i < _pathPoints.size(); ++i)
{
- ZLiquidStatus status = _sourceUnit->GetMap()->GetLiquidStatus(_sourceUnit->GetPhaseShift(), _pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z, MAP_ALL_LIQUIDS, nullptr, _sourceUnit->GetCollisionHeight());
+ ZLiquidStatus status = _sourceUnit->GetMap()->GetLiquidStatus(_sourceUnit->GetPhaseShift(), _pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z, map_liquidHeaderTypeFlags::AllLiquids, nullptr, _sourceUnit->GetCollisionHeight());
// One of the points is not in the water, cancel movement.
if (status == LIQUID_MAP_NO_WATER)
{
@@ -647,18 +647,18 @@ void PathGenerator::UpdateFilter()
NavTerrainFlag PathGenerator::GetNavTerrain(float x, float y, float z)
{
LiquidData data;
- ZLiquidStatus liquidStatus = _sourceUnit->GetMap()->GetLiquidStatus(_sourceUnit->GetPhaseShift(), x, y, z, MAP_ALL_LIQUIDS, &data, _sourceUnit->GetCollisionHeight());
+ ZLiquidStatus liquidStatus = _sourceUnit->GetMap()->GetLiquidStatus(_sourceUnit->GetPhaseShift(), x, y, z, map_liquidHeaderTypeFlags::AllLiquids, &data, _sourceUnit->GetCollisionHeight());
if (liquidStatus == LIQUID_MAP_NO_WATER)
return NAV_GROUND;
- data.type_flags &= ~MAP_LIQUID_TYPE_DARK_WATER;
+ data.type_flags &= map_liquidHeaderTypeFlags::DarkWater;
switch (data.type_flags)
{
- case MAP_LIQUID_TYPE_WATER:
- case MAP_LIQUID_TYPE_OCEAN:
+ case map_liquidHeaderTypeFlags::Water:
+ case map_liquidHeaderTypeFlags::Ocean:
return NAV_WATER;
- case MAP_LIQUID_TYPE_MAGMA:
- case MAP_LIQUID_TYPE_SLIME:
+ case map_liquidHeaderTypeFlags::Magma:
+ case map_liquidHeaderTypeFlags::Slime:
return NAV_MAGMA_SLIME;
default:
return NAV_GROUND;
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index f545df5ddc9..65a92309a8d 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -1355,7 +1355,7 @@ void Spell::SelectImplicitCasterDestTargets(SpellEffIndex effIndex, SpellImplici
float ground = m_caster->GetMapHeight(x, y, z);
float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
LiquidData liquidData;
- if (m_caster->GetMap()->GetLiquidStatus(m_caster->GetPhaseShift(), x, y, z, MAP_ALL_LIQUIDS, &liquidData, m_caster->GetCollisionHeight()))
+ if (m_caster->GetMap()->GetLiquidStatus(m_caster->GetPhaseShift(), x, y, z, map_liquidHeaderTypeFlags::AllLiquids, &liquidData, m_caster->GetCollisionHeight()))
liquidLevel = liquidData.level;
if (liquidLevel <= ground) // When there is no liquid Map::GetWaterOrGroundLevel returns ground level
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index c70567b1746..4cc34449eb0 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -298,9 +298,9 @@ public:
zoneX, zoneY, groundZ, floorZ, haveMap, haveVMap, haveMMap);
LiquidData liquidStatus;
- ZLiquidStatus status = map->GetLiquidStatus(object->GetPhaseShift(), object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), MAP_ALL_LIQUIDS, &liquidStatus);
+ ZLiquidStatus status = map->GetLiquidStatus(object->GetPhaseShift(), object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), map_liquidHeaderTypeFlags::AllLiquids, &liquidStatus);
if (status)
- handler->PSendSysMessage(LANG_LIQUID_STATUS, liquidStatus.level, liquidStatus.depth_level, liquidStatus.entry, liquidStatus.type_flags, status);
+ handler->PSendSysMessage(LANG_LIQUID_STATUS, liquidStatus.level, liquidStatus.depth_level, liquidStatus.entry, uint32(liquidStatus.type_flags.AsUnderlyingType()), status);
PhasingHandler::PrintToChat(handler, object->GetPhaseShift());
diff --git a/src/tools/map_extractor/System.cpp b/src/tools/map_extractor/System.cpp
index 6876b58a7cc..c419d0bf806 100644
--- a/src/tools/map_extractor/System.cpp
+++ b/src/tools/map_extractor/System.cpp
@@ -22,6 +22,7 @@
#include "DB2Meta.h"
#include "DBFilesClientList.h"
#include "ExtractorDB2LoadInfo.h"
+#include "MapDefines.h"
#include "StringFormat.h"
#include "adt.h"
#include "wdt.h"
@@ -390,74 +391,6 @@ bool ReadCinematicCameraDBC()
// Adt file convertor function and data
//
-// Map file format data
-static char const* MAP_MAGIC = "MAPS";
-static char const* MAP_VERSION_MAGIC = "v1.9";
-static char const* MAP_AREA_MAGIC = "AREA";
-static char const* MAP_HEIGHT_MAGIC = "MHGT";
-static char const* MAP_LIQUID_MAGIC = "MLIQ";
-
-struct map_fileheader
-{
- uint32 mapMagic;
- uint32 versionMagic;
- uint32 buildMagic;
- uint32 areaMapOffset;
- uint32 areaMapSize;
- uint32 heightMapOffset;
- uint32 heightMapSize;
- uint32 liquidMapOffset;
- uint32 liquidMapSize;
- uint32 holesOffset;
- uint32 holesSize;
-};
-
-#define MAP_AREA_NO_AREA 0x0001
-
-struct map_areaHeader
-{
- uint32 fourcc;
- uint16 flags;
- uint16 gridArea;
-};
-
-#define MAP_HEIGHT_NO_HEIGHT 0x0001
-#define MAP_HEIGHT_AS_INT16 0x0002
-#define MAP_HEIGHT_AS_INT8 0x0004
-#define MAP_HEIGHT_HAS_FLIGHT_BOUNDS 0x0008
-
-struct map_heightHeader
-{
- uint32 fourcc;
- uint32 flags;
- float gridHeight;
- float gridMaxHeight;
-};
-
-#define MAP_LIQUID_TYPE_NO_WATER 0x00
-#define MAP_LIQUID_TYPE_WATER 0x01
-#define MAP_LIQUID_TYPE_OCEAN 0x02
-#define MAP_LIQUID_TYPE_MAGMA 0x04
-#define MAP_LIQUID_TYPE_SLIME 0x08
-
-#define MAP_LIQUID_TYPE_DARK_WATER 0x10
-
-#define MAP_LIQUID_NO_TYPE 0x0001
-#define MAP_LIQUID_NO_HEIGHT 0x0002
-
-struct map_liquidHeader
-{
- uint32 fourcc;
- uint8 flags;
- uint8 liquidFlags;
- uint16 liquidType;
- uint8 offsetX;
- uint8 offsetY;
- uint8 width;
- uint8 height;
- float liquidLevel;
-};
-
float selectUInt8StepStore(float maxDiff)
{
return 255 / maxDiff;
@@ -478,7 +411,7 @@ uint8 uint8_V8[ADT_GRID_SIZE][ADT_GRID_SIZE];
uint8 uint8_V9[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
uint16 liquid_entry[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
-uint8 liquid_flags[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
+map_liquidHeaderTypeFlags liquid_flags[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
bool liquid_show[ADT_GRID_SIZE][ADT_GRID_SIZE];
float liquid_height[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
uint8 holes[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID][8];
@@ -523,9 +456,9 @@ bool TransformToHighRes(uint16 lowResHoles, uint8 hiResHoles[8])
bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const& outputPath, int gx, int gy, uint32 build, bool ignoreDeepWater)
{
// Prepare map header
- map_fileheader map;
- map.mapMagic = *reinterpret_cast<uint32 const*>(MAP_MAGIC);
- map.versionMagic = *reinterpret_cast<uint32 const*>(MAP_VERSION_MAGIC);
+ map_fileheader map{};
+ map.mapMagic = MapMagic;
+ map.versionMagic = MapVersionMagic;
map.buildMagic = build;
// Get area flags data
@@ -630,7 +563,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
{
liquid_show[cy][cx] = true;
if (!ignoreDeepWater && liquid->flags[y][x] & (1 << 7))
- liquid_flags[mcnk->iy][mcnk->ix] |= MAP_LIQUID_TYPE_DARK_WATER;
+ liquid_flags[mcnk->iy][mcnk->ix] |= map_liquidHeaderTypeFlags::DarkWater;
++count;
}
}
@@ -640,20 +573,20 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
if (c_flag & (1 << 2))
{
liquid_entry[mcnk->iy][mcnk->ix] = 1;
- liquid_flags[mcnk->iy][mcnk->ix] |= MAP_LIQUID_TYPE_WATER; // water
+ liquid_flags[mcnk->iy][mcnk->ix] |= map_liquidHeaderTypeFlags::Water; // water
}
if (c_flag & (1 << 3))
{
liquid_entry[mcnk->iy][mcnk->ix] = 2;
- liquid_flags[mcnk->iy][mcnk->ix] |= MAP_LIQUID_TYPE_OCEAN; // ocean
+ liquid_flags[mcnk->iy][mcnk->ix] |= map_liquidHeaderTypeFlags::Ocean; // ocean
}
if (c_flag & (1 << 4))
{
liquid_entry[mcnk->iy][mcnk->ix] = 3;
- liquid_flags[mcnk->iy][mcnk->ix] |= MAP_LIQUID_TYPE_MAGMA; // magma/slime
+ liquid_flags[mcnk->iy][mcnk->ix] |= map_liquidHeaderTypeFlags::Magma; // magma/slime
}
- if (!count && liquid_flags[mcnk->iy][mcnk->ix])
+ if (!count && liquid_flags[mcnk->iy][mcnk->ix] != map_liquidHeaderTypeFlags::NoWater)
fprintf(stderr, "Wrong liquid detect in MCLQ chunk");
for (int y = 0; y <= ADT_CELL_SIZE; ++y)
@@ -717,16 +650,16 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
liquid_entry[i][j] = h2o->GetLiquidType(h);
switch (LiquidTypes.at(liquid_entry[i][j]).SoundBank)
{
- case LIQUID_TYPE_WATER: liquid_flags[i][j] |= MAP_LIQUID_TYPE_WATER; break;
- case LIQUID_TYPE_OCEAN: liquid_flags[i][j] |= MAP_LIQUID_TYPE_OCEAN; if (!ignoreDeepWater && attrs.Deep) liquid_flags[i][j] |= MAP_LIQUID_TYPE_DARK_WATER; break;
- case LIQUID_TYPE_MAGMA: liquid_flags[i][j] |= MAP_LIQUID_TYPE_MAGMA; break;
- case LIQUID_TYPE_SLIME: liquid_flags[i][j] |= MAP_LIQUID_TYPE_SLIME; break;
+ case LIQUID_TYPE_WATER: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Water; break;
+ case LIQUID_TYPE_OCEAN: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Ocean; if (!ignoreDeepWater && attrs.Deep) liquid_flags[i][j] |= map_liquidHeaderTypeFlags::DarkWater; break;
+ case LIQUID_TYPE_MAGMA: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Magma; break;
+ case LIQUID_TYPE_SLIME: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Slime; break;
default:
printf("\nCan't find Liquid type %u for map %s [%u,%u]\nchunk %d,%d\n", h->LiquidType, mapName.c_str(), gx, gy, i, j);
break;
}
- if (!count && liquid_flags[i][j])
+ if (!count && liquid_flags[i][j] != map_liquidHeaderTypeFlags::NoWater)
printf("Wrong liquid detect in MH2O chunk");
int32 pos = 0;
@@ -773,8 +706,8 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
map.areaMapSize = sizeof(map_areaHeader);
map_areaHeader areaHeader;
- areaHeader.fourcc = *reinterpret_cast<uint32 const*>(MAP_AREA_MAGIC);
- areaHeader.flags = 0;
+ areaHeader.areaMagic = MapAreaMagic;
+ areaHeader.flags = map_areaHeaderFlags::None;
if (fullAreaData)
{
areaHeader.gridArea = 0;
@@ -782,7 +715,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
}
else
{
- areaHeader.flags |= MAP_AREA_NO_AREA;
+ areaHeader.flags |= map_areaHeaderFlags::NoArea;
areaHeader.gridArea = static_cast<uint16>(areaId);
}
@@ -831,26 +764,26 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
map.heightMapSize = sizeof(map_heightHeader);
map_heightHeader heightHeader;
- heightHeader.fourcc = *reinterpret_cast<uint32 const*>(MAP_HEIGHT_MAGIC);
- heightHeader.flags = 0;
+ heightHeader.heightMagic = MapHeightMagic;
+ heightHeader.flags = map_heightHeaderFlags::None;
heightHeader.gridHeight = minHeight;
heightHeader.gridMaxHeight = maxHeight;
if (maxHeight == minHeight)
- heightHeader.flags |= MAP_HEIGHT_NO_HEIGHT;
+ heightHeader.flags |= map_heightHeaderFlags::NoHeight;
// Not need store if flat surface
if (CONF_allow_float_to_int && (maxHeight - minHeight) < CONF_flat_height_delta_limit)
- heightHeader.flags |= MAP_HEIGHT_NO_HEIGHT;
+ heightHeader.flags |= map_heightHeaderFlags::NoHeight;
if (hasFlightBox)
{
- heightHeader.flags |= MAP_HEIGHT_HAS_FLIGHT_BOUNDS;
+ heightHeader.flags |= map_heightHeaderFlags::HasFlightBounds;
map.heightMapSize += sizeof(flight_box_max) + sizeof(flight_box_min);
}
// Try store as packed in uint16 or uint8 values
- if (!(heightHeader.flags & MAP_HEIGHT_NO_HEIGHT))
+ if (!heightHeader.flags.HasFlag(map_heightHeaderFlags::NoHeight))
{
float step = 0;
// Try Store as uint values
@@ -859,18 +792,18 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
float diff = maxHeight - minHeight;
if (diff < CONF_float_to_int8_limit) // As uint8 (max accuracy = CONF_float_to_int8_limit/256)
{
- heightHeader.flags |= MAP_HEIGHT_AS_INT8;
+ heightHeader.flags |= map_heightHeaderFlags::HeightAsInt8;
step = selectUInt8StepStore(diff);
}
else if (diff < CONF_float_to_int16_limit) // As uint16 (max accuracy = CONF_float_to_int16_limit/65536)
{
- heightHeader.flags |= MAP_HEIGHT_AS_INT16;
+ heightHeader.flags |= map_heightHeaderFlags::HeightAsInt16;
step = selectUInt16StepStore(diff);
}
}
// Pack it to int values if need
- if (heightHeader.flags&MAP_HEIGHT_AS_INT8)
+ if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt8))
{
for (int y=0; y<ADT_GRID_SIZE; y++)
for(int x=0;x<ADT_GRID_SIZE;x++)
@@ -880,7 +813,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
uint8_V9[y][x] = uint8((V9[y][x] - minHeight) * step + 0.5f);
map.heightMapSize+= sizeof(uint8_V9) + sizeof(uint8_V8);
}
- else if (heightHeader.flags&MAP_HEIGHT_AS_INT16)
+ else if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt16))
{
for (int y=0; y<ADT_GRID_SIZE; y++)
for(int x=0;x<ADT_GRID_SIZE;x++)
@@ -898,7 +831,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
// Pack liquid data
//============================================
uint16 firstLiquidType = liquid_entry[0][0];
- uint8 firstLiquidFlag = liquid_flags[0][0];
+ map_liquidHeaderTypeFlags firstLiquidFlag = liquid_flags[0][0];
bool fullType = false;
for (int y = 0; y < ADT_CELLS_PER_GRID; y++)
{
@@ -916,7 +849,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
map_liquidHeader liquidHeader;
// no water data (if all grid have 0 liquid type)
- if (firstLiquidFlag == 0 && !fullType)
+ if (firstLiquidFlag == map_liquidHeaderTypeFlags::NoWater && !fullType)
{
// No liquid data
map.liquidMapOffset = 0;
@@ -948,8 +881,8 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
}
map.liquidMapOffset = map.heightMapOffset + map.heightMapSize;
map.liquidMapSize = sizeof(map_liquidHeader);
- liquidHeader.fourcc = *reinterpret_cast<uint32 const*>(MAP_LIQUID_MAGIC);
- liquidHeader.flags = 0;
+ liquidHeader.liquidMagic = MapLiquidMagic;
+ liquidHeader.flags = map_liquidHeaderFlags::None;
liquidHeader.liquidType = 0;
liquidHeader.offsetX = minX;
liquidHeader.offsetY = minY;
@@ -958,16 +891,16 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
liquidHeader.liquidLevel = minHeight;
if (maxHeight == minHeight)
- liquidHeader.flags |= MAP_LIQUID_NO_HEIGHT;
+ liquidHeader.flags |= map_liquidHeaderFlags::NoHeight;
// Not need store if flat surface
if (CONF_allow_float_to_int && (maxHeight - minHeight) < CONF_flat_liquid_delta_limit)
- liquidHeader.flags |= MAP_LIQUID_NO_HEIGHT;
+ liquidHeader.flags |= map_liquidHeaderFlags::NoHeight;
if (!fullType)
- liquidHeader.flags |= MAP_LIQUID_NO_TYPE;
+ liquidHeader.flags |= map_liquidHeaderFlags::NoType;
- if (liquidHeader.flags & MAP_LIQUID_NO_TYPE)
+ if (liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoType))
{
liquidHeader.liquidFlags = firstLiquidFlag;
liquidHeader.liquidType = firstLiquidType;
@@ -975,7 +908,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
else
map.liquidMapSize += sizeof(liquid_entry) + sizeof(liquid_flags);
- if (!(liquidHeader.flags & MAP_LIQUID_NO_HEIGHT))
+ if (!liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
map.liquidMapSize += sizeof(float)*liquidHeader.width*liquidHeader.height;
}
@@ -1005,19 +938,19 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
outFile.write(reinterpret_cast<char const*>(&map), sizeof(map));
// Store area data
outFile.write(reinterpret_cast<char const*>(&areaHeader), sizeof(areaHeader));
- if (!(areaHeader.flags & MAP_AREA_NO_AREA))
+ if (!areaHeader.flags.HasFlag(map_areaHeaderFlags::NoArea))
outFile.write(reinterpret_cast<char const*>(area_ids), sizeof(area_ids));
// Store height data
outFile.write(reinterpret_cast<char const*>(&heightHeader), sizeof(heightHeader));
- if (!(heightHeader.flags & MAP_HEIGHT_NO_HEIGHT))
+ if (!heightHeader.flags.HasFlag(map_heightHeaderFlags::NoHeight))
{
- if (heightHeader.flags & MAP_HEIGHT_AS_INT16)
+ if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt16))
{
outFile.write(reinterpret_cast<char const*>(uint16_V9), sizeof(uint16_V9));
outFile.write(reinterpret_cast<char const*>(uint16_V8), sizeof(uint16_V8));
}
- else if (heightHeader.flags & MAP_HEIGHT_AS_INT8)
+ else if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt8))
{
outFile.write(reinterpret_cast<char const*>(uint8_V9), sizeof(uint8_V9));
outFile.write(reinterpret_cast<char const*>(uint8_V8), sizeof(uint8_V8));
@@ -1029,7 +962,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
}
}
- if (heightHeader.flags & MAP_HEIGHT_HAS_FLIGHT_BOUNDS)
+ if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HasFlightBounds))
{
outFile.write(reinterpret_cast<char*>(flight_box_max), sizeof(flight_box_max));
outFile.write(reinterpret_cast<char*>(flight_box_min), sizeof(flight_box_min));
@@ -1039,13 +972,13 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
if (map.liquidMapOffset)
{
outFile.write(reinterpret_cast<char const*>(&liquidHeader), sizeof(liquidHeader));
- if (!(liquidHeader.flags & MAP_LIQUID_NO_TYPE))
+ if (!liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoType))
{
outFile.write(reinterpret_cast<char const*>(liquid_entry), sizeof(liquid_entry));
outFile.write(reinterpret_cast<char const*>(liquid_flags), sizeof(liquid_flags));
}
- if (!(liquidHeader.flags & MAP_LIQUID_NO_HEIGHT))
+ if (!liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
{
for (int y = 0; y < liquidHeader.height; y++)
outFile.write(reinterpret_cast<char const*>(&liquid_height[y + liquidHeader.offsetY][liquidHeader.offsetX]), sizeof(float) * liquidHeader.width);
@@ -1162,8 +1095,8 @@ void ExtractMaps(uint32 build)
if (FILE* tileList = fopen(Trinity::StringFormat("%s/maps/%04u.tilelist", output_path.string().c_str(), map_ids[z].Id).c_str(), "wb"))
{
- fwrite(MAP_MAGIC, 1, strlen(MAP_MAGIC), tileList);
- fwrite(MAP_VERSION_MAGIC, 1, strlen(MAP_VERSION_MAGIC), tileList);
+ fwrite(MapMagic.data(), 1, MapMagic.size(), tileList);
+ fwrite(MapVersionMagic.data(), 1, MapVersionMagic.size(), tileList);
fwrite(&build, sizeof(build), 1, tileList);
fwrite(existingTiles.to_string().c_str(), 1, existingTiles.size(), tileList);
fclose(tileList);
diff --git a/src/tools/mmaps_generator/TerrainBuilder.cpp b/src/tools/mmaps_generator/TerrainBuilder.cpp
index c9f0638fb1a..30981ec0f6e 100644
--- a/src/tools/mmaps_generator/TerrainBuilder.cpp
+++ b/src/tools/mmaps_generator/TerrainBuilder.cpp
@@ -17,65 +17,14 @@
#include "TerrainBuilder.h"
#include "MapBuilder.h"
+#include "MapDefines.h"
#include "MapTree.h"
#include "MMapDefines.h"
#include "ModelInstance.h"
+#include "Util.h"
#include "VMapFactory.h"
#include "VMapManager2.h"
-// ******************************************
-// Map file format defines
-// ******************************************
-struct map_fileheader
-{
- uint32 mapMagic;
- uint32 versionMagic;
- uint32 buildMagic;
- uint32 areaMapOffset;
- uint32 areaMapSize;
- uint32 heightMapOffset;
- uint32 heightMapSize;
- uint32 liquidMapOffset;
- uint32 liquidMapSize;
- uint32 holesOffset;
- uint32 holesSize;
-};
-
-#define MAP_HEIGHT_NO_HEIGHT 0x0001
-#define MAP_HEIGHT_AS_INT16 0x0002
-#define MAP_HEIGHT_AS_INT8 0x0004
-
-struct map_heightHeader
-{
- uint32 fourcc;
- uint32 flags;
- float gridHeight;
- float gridMaxHeight;
-};
-
-#define MAP_LIQUID_NO_TYPE 0x0001
-#define MAP_LIQUID_NO_HEIGHT 0x0002
-
-struct map_liquidHeader
-{
- uint32 fourcc;
- uint8 flags;
- uint8 liquidFlags;
- uint16 liquidType;
- uint8 offsetX;
- uint8 offsetY;
- uint8 width;
- uint8 height;
- float liquidLevel;
-};
-
-#define MAP_LIQUID_TYPE_NO_WATER 0x00
-#define MAP_LIQUID_TYPE_WATER 0x01
-#define MAP_LIQUID_TYPE_OCEAN 0x02
-#define MAP_LIQUID_TYPE_MAGMA 0x04
-#define MAP_LIQUID_TYPE_SLIME 0x08
-#define MAP_LIQUID_TYPE_DARK_WATER 0x10
-
namespace MMAP
{
char const* MAP_VERSION_MAGIC = "v1.9";
@@ -150,7 +99,7 @@ namespace MMAP
map_fileheader fheader;
if (fread(&fheader, sizeof(map_fileheader), 1, mapFile) != 1 ||
- fheader.versionMagic != *((uint32 const*)(MAP_VERSION_MAGIC)))
+ fheader.versionMagic != MapVersionMagic)
{
fclose(mapFile);
printf("%s is the wrong version, please extract new .map files\n", mapFileName);
@@ -164,7 +113,7 @@ namespace MMAP
bool haveLiquid = false;
if (fread(&hheader, sizeof(map_heightHeader), 1, mapFile) == 1)
{
- haveTerrain = !(hheader.flags & MAP_HEIGHT_NO_HEIGHT);
+ haveTerrain = !hheader.flags.HasFlag(map_heightHeaderFlags::NoHeight);
haveLiquid = fheader.liquidMapOffset && !m_skipLiquid;
}
@@ -180,7 +129,7 @@ namespace MMAP
memset(holes, 0, sizeof(holes));
uint16 liquid_entry[16][16];
memset(liquid_entry, 0, sizeof(liquid_entry));
- uint8 liquid_flags[16][16];
+ map_liquidHeaderTypeFlags liquid_flags[16][16];
memset(liquid_flags, 0, sizeof(liquid_flags));
G3D::Array<int> ltriangles;
G3D::Array<int> ttriangles;
@@ -192,7 +141,7 @@ namespace MMAP
float V9[V9_SIZE_SQ], V8[V8_SIZE_SQ];
int expected = V9_SIZE_SQ + V8_SIZE_SQ;
- if (hheader.flags & MAP_HEIGHT_AS_INT8)
+ if (hheader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt8))
{
uint8 v9[V9_SIZE_SQ];
uint8 v8[V8_SIZE_SQ];
@@ -210,7 +159,7 @@ namespace MMAP
for (int i = 0; i < V8_SIZE_SQ; ++i)
V8[i] = (float)v8[i]*heightMultiplier + hheader.gridHeight;
}
- else if (hheader.flags & MAP_HEIGHT_AS_INT16)
+ else if (hheader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt16))
{
uint16 v9[V9_SIZE_SQ];
uint16 v8[V8_SIZE_SQ];
@@ -291,7 +240,7 @@ namespace MMAP
float* liquid_map = nullptr;
- if (!(lheader.flags & MAP_LIQUID_NO_TYPE))
+ if (!lheader.flags.HasFlag(map_liquidHeaderFlags::NoType))
{
if (fread(liquid_entry, sizeof(liquid_entry), 1, mapFile) != 1)
printf("TerrainBuilder::loadMap: Failed to read some data expected 1, read 0\n");
@@ -304,7 +253,7 @@ namespace MMAP
std::fill_n(&liquid_flags[0][0], 16 * 16, lheader.liquidFlags);
}
- if (!(lheader.flags & MAP_LIQUID_NO_HEIGHT))
+ if (!lheader.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
{
uint32 toRead = lheader.width * lheader.height;
liquid_map = new float [toRead];
@@ -324,7 +273,7 @@ namespace MMAP
int row, col;
// generate coordinates
- if (!(lheader.flags & MAP_LIQUID_NO_HEIGHT))
+ if (!lheader.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
{
int j = 0;
for (int i = 0; i < V9_SIZE_SQ; ++i)
@@ -409,7 +358,8 @@ namespace MMAP
// default is true, will change to false if needed
useTerrain = true;
useLiquid = true;
- uint8 liquidType = MAP_LIQUID_TYPE_NO_WATER;
+ EnumFlag<map_liquidHeaderTypeFlags> liquidType = map_liquidHeaderTypeFlags::NoWater;
+ uint8 navLiquidType = NAV_AREA_EMPTY;
// if there is no liquid, don't use liquid
if (!meshData.liquidVerts.size() || !ltriangles.size())
@@ -417,16 +367,16 @@ namespace MMAP
else
{
liquidType = getLiquidType(i, liquid_flags);
- if (liquidType & MAP_LIQUID_TYPE_DARK_WATER)
+ if (liquidType.HasFlag(map_liquidHeaderTypeFlags::DarkWater))
{
// players should not be here, so logically neither should creatures
useTerrain = false;
useLiquid = false;
}
- else if ((liquidType & (MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN)) != 0)
- liquidType = NAV_AREA_WATER;
- else if ((liquidType & (MAP_LIQUID_TYPE_MAGMA | MAP_LIQUID_TYPE_SLIME)) != 0)
- liquidType = NAV_AREA_MAGMA_SLIME;
+ else if (liquidType.HasFlag(map_liquidHeaderTypeFlags::Water | map_liquidHeaderTypeFlags::Ocean))
+ navLiquidType = NAV_AREA_WATER;
+ else if (liquidType.HasFlag(map_liquidHeaderTypeFlags::Magma | map_liquidHeaderTypeFlags::Slime))
+ navLiquidType = NAV_AREA_MAGMA_SLIME;
else
useLiquid = false;
}
@@ -512,7 +462,7 @@ namespace MMAP
// store the result
if (useLiquid)
{
- meshData.liquidType.append(liquidType);
+ meshData.liquidType.append(navLiquidType);
for (int k = 0; k < 3; ++k)
meshData.liquidTris.append(ltris[k]);
}
@@ -624,7 +574,7 @@ namespace MMAP
}
/**************************************************************************/
- uint8 TerrainBuilder::getLiquidType(int square, const uint8 liquid_type[16][16])
+ map_liquidHeaderTypeFlags TerrainBuilder::getLiquidType(int square, map_liquidHeaderTypeFlags const (&liquid_type)[16][16])
{
int row = square / 128;
int col = square % 128;
@@ -716,10 +666,10 @@ namespace MMAP
uint8 type = NAV_AREA_EMPTY;
// convert liquid type to NavTerrain
- uint32 liquidFlags = vmapManager->GetLiquidFlagsPtr(liquid->GetType());
- if ((liquidFlags & (MAP_LIQUID_TYPE_WATER | MAP_LIQUID_TYPE_OCEAN)) != 0)
+ EnumFlag<map_liquidHeaderTypeFlags> liquidFlags = map_liquidHeaderTypeFlags(vmapManager->GetLiquidFlagsPtr(liquid->GetType()));
+ if (liquidFlags.HasFlag(map_liquidHeaderTypeFlags::Water | map_liquidHeaderTypeFlags::Ocean))
type = NAV_AREA_WATER;
- else if ((liquidFlags & (MAP_LIQUID_TYPE_MAGMA | MAP_LIQUID_TYPE_SLIME)) != 0)
+ else if (liquidFlags.HasFlag(map_liquidHeaderTypeFlags::Magma | map_liquidHeaderTypeFlags::Slime))
type = NAV_AREA_MAGMA_SLIME;
// indexing is weird...
diff --git a/src/tools/mmaps_generator/TerrainBuilder.h b/src/tools/mmaps_generator/TerrainBuilder.h
index 54f48098e09..a41cc705df5 100644
--- a/src/tools/mmaps_generator/TerrainBuilder.h
+++ b/src/tools/mmaps_generator/TerrainBuilder.h
@@ -25,6 +25,8 @@
#include <G3D/Vector3.h>
#include <G3D/Matrix3.h>
+enum class map_liquidHeaderTypeFlags : uint8;
+
namespace MMAP
{
enum Spot
@@ -119,7 +121,7 @@ namespace MMAP
void getLiquidCoord(int index, int index2, float xOffset, float yOffset, float* coord, float* v);
/// Get the liquid type for a specific position
- uint8 getLiquidType(int square, const uint8 liquid_type[16][16]);
+ map_liquidHeaderTypeFlags getLiquidType(int square, map_liquidHeaderTypeFlags const (&liquid_type)[16][16]);
// hide parameterless and copy constructor
TerrainBuilder() = delete;