Core/Phases: Mmaps now use the swapped terrain's mmtiles for all units if available.

1 files changed, 265 insertions, 15 deletions

diff --git a/src/server/collision/Management/MMapManager.cpp b/src/server/collision/Management/MMapManager.cpp
index 8c549017f12..6dcff9845f0 100644
--- a/src/server/collision/Management/MMapManager.cpp
+++ b/src/server/collision/Management/MMapManager.cpp
@@ -19,6 +19,8 @@
 #include "MMapManager.h"
 #include "Log.h"
 #include "World.h"
+#include "DBCStores.h"
+#include "MMapFactory.h"
 
 namespace MMAP
 {
@@ -76,8 +78,7 @@ namespace MMAP
         TC_LOG_INFO("maps", "MMAP:loadMapData: Loaded %03i.mmap", mapId);
 
         // store inside our map list
-        MMapData* mmap_data = new MMapData(mesh);
-        mmap_data->mmapLoadedTiles.clear();
+        MMapData* mmap_data = new MMapData(mesh, mapId);
 
         loadedMMaps.insert(std::pair<uint32, MMapData*>(mapId, mmap_data));
         return true;
@@ -100,7 +101,7 @@ namespace MMAP
 
         // check if we already have this tile loaded
         uint32 packedGridPos = packTileID(x, y);
-        if (mmap->mmapLoadedTiles.find(packedGridPos) != mmap->mmapLoadedTiles.end())
+        if (mmap->loadedTileRefs.find(packedGridPos) != mmap->loadedTileRefs.end())
             return false;
 
         // load this tile :: mmaps/MMMXXYY.mmtile
@@ -152,19 +153,120 @@ namespace MMAP
         dtTileRef tileRef = 0;
 
         // memory allocated for data is now managed by detour, and will be deallocated when the tile is removed
-        if (dtStatusSucceed(mmap->navMesh->addTile(data, fileHeader.size, DT_TILE_FREE_DATA, 0, &tileRef)))
+        if (dtStatusSucceed(mmap->navMesh->addTile(data, fileHeader.size, NULL/*DT_TILE_FREE_DATA*/, 0, &tileRef)))
         {
-            mmap->mmapLoadedTiles.insert(std::pair<uint32, dtTileRef>(packedGridPos, tileRef));
+            mmap->loadedTileRefs.insert(std::pair<uint32, dtTileRef>(packedGridPos, tileRef));
             ++loadedTiles;
             TC_LOG_INFO("maps", "MMAP:loadMap: Loaded mmtile %03i[%02i, %02i] into %03i[%02i, %02i]", mapId, x, y, mapId, header->x, header->y);
+
+            LoadPhaseTiles(mapId, x, y);
+
             return true;
         }
+        else
+        {
+            TC_LOG_ERROR("maps", "MMAP:loadMap: Could not load %03u%02i%02i.mmtile into navmesh", mapId, x, y);
+            dtFree(data);
+            return false;
+        }
 
-        TC_LOG_ERROR("maps", "MMAP:loadMap: Could not load %03u%02i%02i.mmtile into navmesh", mapId, x, y);
-        dtFree(data);
         return false;
     }
 
+    PhasedTile* MMapManager::LoadTile(uint32 mapId, int32 x, int32 y)
+    {
+        // load this tile :: mmaps/MMMXXYY.mmtile
+        uint32 pathLen = sWorld->GetDataPath().length() + strlen("mmaps/%03i%02i%02i.mmtile") + 1;
+        char *fileName = new char[pathLen];
+
+        snprintf(fileName, pathLen, (sWorld->GetDataPath() + "mmaps/%03i%02i%02i.mmtile").c_str(), mapId, x, y);
+
+        FILE* file = fopen(fileName, "rb");
+        if (!file)
+        {
+            // Not all tiles have phased versions, don't flood this msg
+            //TC_LOG_DEBUG("phase", "MMAP:LoadTile: Could not open mmtile file '%s'", fileName);
+            delete[] fileName;
+            return NULL;
+        }
+        delete[] fileName;
+
+        PhasedTile* pTile = new PhasedTile();
+
+        // read header
+        if (fread(&pTile->fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || pTile->fileHeader.mmapMagic != MMAP_MAGIC)
+        {
+            TC_LOG_ERROR("phase", "MMAP:LoadTile: Bad header in mmap %03u%02i%02i.mmtile", mapId, x, y);
+            fclose(file);
+            return NULL;
+        }
+
+        if (pTile->fileHeader.mmapVersion != MMAP_VERSION)
+        {
+            TC_LOG_ERROR("phase", "MMAP:LoadTile: %03u%02i%02i.mmtile was built with generator v%i, expected v%i",
+                mapId, x, y, pTile->fileHeader.mmapVersion, MMAP_VERSION);
+            fclose(file);
+            return NULL;
+        }
+
+        pTile->data = (unsigned char*)dtAlloc(pTile->fileHeader.size, DT_ALLOC_PERM);
+        ASSERT(pTile->data);
+
+        size_t result = fread(pTile->data, pTile->fileHeader.size, 1, file);
+        if (!result)
+        {
+            TC_LOG_ERROR("phase", "MMAP:LoadTile: Bad header or data in mmap %03u%02i%02i.mmtile", mapId, x, y);
+            fclose(file);
+            return NULL;
+        }
+
+        fclose(file);
+
+        return pTile;
+    }
+
+    void MMapManager::LoadPhaseTiles(uint32 mapId, int32 x, int32 y)
+    {
+        TC_LOG_DEBUG("phase", "MMAP:LoadPhaseTiles: Loading phased mmtiles for map %u, x: %i, y: %i", mapId, x, y);
+
+        uint32 packedGridPos = packTileID(x, y);
+
+        for (uint32 i = 0; i < sMapStore.GetNumRows(); ++i)
+        {
+            if (const MapEntry* const map = sMapStore.LookupEntry(i))
+            {
+                if (map->ParentMapID == mapId)
+                {
+                    PhasedTile* data = LoadTile(map->ID, x, y);
+                    // only a few tiles have terrain swaps, do not write error for them
+                    if (data)
+                    {
+                        TC_LOG_DEBUG("phase", "MMAP:LoadPhaseTiles: Loaded phased %03u%02i%02i.mmtile for root phase map %u", map->ID, x, y, mapId);
+                        _phaseTiles[map->ID][packedGridPos] = data;
+                    }
+                }
+            }
+        }
+    }
+
+    void MMapManager::UnloadPhaseTile(uint32 mapId, int32 x, int32 y)
+    {
+        TC_LOG_DEBUG("phase", "MMAP:UnloadPhaseTile: Unloading phased mmtile for map %u, x: %i, y: %i", mapId, x, y);
+
+        uint32 packedGridPos = packTileID(x, y);
+
+        const MapEntry* const map = sMapStore.LookupEntry(mapId); // map existence already checked when loading
+        uint32 rootMapId = map->ParentMapID;
+
+        if (_phaseTiles[mapId][packedGridPos])
+        {
+            TC_LOG_DEBUG("phase", "MMAP:UnloadPhaseTile: Unloaded phased %03u%02i%02i.mmtile for root phase map %u", mapId, x, y, rootMapId);
+            delete _phaseTiles[mapId][packedGridPos]->data;
+            delete _phaseTiles[mapId][packedGridPos];
+            _phaseTiles[mapId].erase(packedGridPos);
+        }
+    }
+
     bool MMapManager::unloadMap(uint32 mapId, int32 x, int32 y)
     {
         // check if we have this map loaded
@@ -179,14 +281,14 @@ namespace MMAP
 
         // check if we have this tile loaded
         uint32 packedGridPos = packTileID(x, y);
-        if (mmap->mmapLoadedTiles.find(packedGridPos) == mmap->mmapLoadedTiles.end())
+        if (mmap->loadedTileRefs.find(packedGridPos) == mmap->loadedTileRefs.end())
         {
             // file may not exist, therefore not loaded
             TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh tile. %03u%02i%02i.mmtile", mapId, x, y);
             return false;
         }
 
-        dtTileRef tileRef = mmap->mmapLoadedTiles[packedGridPos];
+        dtTileRef tileRef = mmap->loadedTileRefs[packedGridPos];
 
         // unload, and mark as non loaded
         if (dtStatusFailed(mmap->navMesh->removeTile(tileRef, NULL, NULL)))
@@ -199,9 +301,11 @@ namespace MMAP
         }
         else
         {
-            mmap->mmapLoadedTiles.erase(packedGridPos);
+            mmap->loadedTileRefs.erase(packedGridPos);
             --loadedTiles;
             TC_LOG_INFO("maps", "MMAP:unloadMap: Unloaded mmtile %03i[%02i, %02i] from %03i", mapId, x, y, mapId);
+
+            UnloadPhaseTile(mapId, x, y);
             return true;
         }
 
@@ -219,7 +323,7 @@ namespace MMAP
 
         // unload all tiles from given map
         MMapData* mmap = loadedMMaps[mapId];
-        for (MMapTileSet::iterator i = mmap->mmapLoadedTiles.begin(); i != mmap->mmapLoadedTiles.end(); ++i)
+        for (MMapTileSet::iterator i = mmap->loadedTileRefs.begin(); i != mmap->loadedTileRefs.end(); ++i)
         {
             uint32 x = (i->first >> 16);
             uint32 y = (i->first & 0x0000FFFF);
@@ -227,6 +331,7 @@ namespace MMAP
                 TC_LOG_ERROR("maps", "MMAP:unloadMap: Could not unload %03u%02i%02i.mmtile from navmesh", mapId, x, y);
             else
             {
+                UnloadPhaseTile(mapId, x, y);
                 --loadedTiles;
                 TC_LOG_INFO("maps", "MMAP:unloadMap: Unloaded mmtile %03i[%02i, %02i] from %03i", mapId, x, y, mapId);
             }
@@ -265,15 +370,15 @@ namespace MMAP
         return true;
     }
 
-    dtNavMesh const* MMapManager::GetNavMesh(uint32 mapId)
+    dtNavMesh const* MMapManager::GetNavMesh(uint32 mapId, TerrainSet swaps)
     {
         if (loadedMMaps.find(mapId) == loadedMMaps.end())
             return NULL;
 
-        return loadedMMaps[mapId]->navMesh;
+        return loadedMMaps[mapId]->GetNavMesh(swaps);
     }
 
-    dtNavMeshQuery const* MMapManager::GetNavMeshQuery(uint32 mapId, uint32 instanceId)
+    dtNavMeshQuery const* MMapManager::GetNavMeshQuery(uint32 mapId, uint32 instanceId, TerrainSet swaps)
     {
         if (loadedMMaps.find(mapId) == loadedMMaps.end())
             return NULL;
@@ -284,7 +389,7 @@ namespace MMAP
             // allocate mesh query
             dtNavMeshQuery* query = dtAllocNavMeshQuery();
             ASSERT(query);
-            if (dtStatusFailed(query->init(mmap->navMesh, 1024)))
+            if (dtStatusFailed(query->init(mmap->GetNavMesh(swaps), 1024)))
             {
                 dtFreeNavMeshQuery(query);
                 TC_LOG_ERROR("maps", "MMAP:GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId %03u instanceId %u", mapId, instanceId);
@@ -297,4 +402,149 @@ namespace MMAP
 
         return mmap->navMeshQueries[instanceId];
     }
+
+    MMapData::MMapData(dtNavMesh* mesh, uint32 mapId)
+    {
+        navMesh = mesh;
+        _mapId = mapId;
+    }
+
+    MMapData::~MMapData()
+    {
+        for (NavMeshQuerySet::iterator i = navMeshQueries.begin(); i != navMeshQueries.end(); ++i)
+            dtFreeNavMeshQuery(i->second);
+
+        dtFreeNavMesh(navMesh);
+
+        for (PhaseTileContainer::iterator i = _baseTiles.begin(); i != _baseTiles.end(); ++i)
+        {
+            delete (*i).second->data;
+            delete (*i).second;
+        }
+    }
+
+    void MMapData::RemoveSwap(PhasedTile* ptile, uint32 swap, uint32 packedXY)
+    {
+        uint32 x = (packedXY >> 16);
+        uint32 y = (packedXY & 0x0000FFFF);
+
+        if (loadedPhasedTiles[swap].find(packedXY) == loadedPhasedTiles[swap].end())
+        {
+            TC_LOG_DEBUG("phase", "MMapData::RemoveSwap: mmtile %03u[%02i, %02i] unload skipped, due to not loaded", swap, x, y);
+            return;
+        }
+        dtMeshHeader* header = (dtMeshHeader*)ptile->data;
+
+        // remove old tile
+        if (dtStatusFailed(navMesh->removeTile(loadedTileRefs[packedXY], NULL, NULL)))
+            TC_LOG_ERROR("phase", "MMapData::RemoveSwap: Could not unload phased %03u%02i%02i.mmtile from navmesh", swap, x, y);
+        else
+        {
+            TC_LOG_DEBUG("phase", "MMapData::RemoveSwap: Unloaded phased %03u%02i%02i.mmtile from navmesh", swap, x, y);
+
+            // restore base tile
+            if (dtStatusSucceed(navMesh->addTile(_baseTiles[packedXY]->data, _baseTiles[packedXY]->dataSize, NULL, 0, &loadedTileRefs[packedXY])))
+            {
+                TC_LOG_DEBUG("phase", "MMapData::RemoveSwap: Loaded base mmtile %03u[%02i, %02i] into %03i[%02i, %02i]", _mapId, x, y, _mapId, header->x, header->y);
+            }
+            else
+                TC_LOG_ERROR("phase", "MMapData::RemoveSwap: Could not load base %03u%02i%02i.mmtile to navmesh", _mapId, x, y);
+        }
+
+        loadedPhasedTiles[swap].erase(packedXY);
+
+        if (loadedPhasedTiles[swap].empty())
+        {
+            _activeSwaps.erase(swap);
+            TC_LOG_DEBUG("phase", "MMapData::RemoveSwap: Fully removed swap %u from map %u", swap, _mapId);
+        }
+    }
+
+    void MMapData::AddSwap(PhasedTile* ptile, uint32 swap, uint32 packedXY)
+    {
+
+        uint32 x = (packedXY >> 16);
+        uint32 y = (packedXY & 0x0000FFFF);
+
+        if (loadedTileRefs.find(packedXY) == loadedTileRefs.end())
+        {
+            TC_LOG_DEBUG("phase", "MMapData::AddSwap: phased mmtile %03u[%02i, %02i] load skipped, due to not loaded base tile on map %u", swap, x, y, _mapId);
+            return;
+        }
+        if (loadedPhasedTiles[swap].find(packedXY) != loadedPhasedTiles[swap].end())
+        {
+            TC_LOG_DEBUG("phase", "MMapData::AddSwap: WARNING! phased mmtile %03u[%02i, %02i] load skipped, due to already loaded on map %u", swap, x, y, _mapId);
+            return;
+        }
+
+
+        dtMeshHeader* header = (dtMeshHeader*)ptile->data;
+
+        const dtMeshTile* oldTile = navMesh->getTileByRef(loadedTileRefs[packedXY]);
+
+        uint32 old_x = oldTile->header->x;
+        uint32 old_y = oldTile->header->y;
+
+        // header xy is based on the swap map's tile set, wich doesn't have all the same tiles as root map, so copy the xy from the orignal header
+        memcpy(ptile->data + 8, (char*)&old_x, 4);
+        memcpy(ptile->data + 12, (char*)&old_y, 4);
+
+        // the removed tile's data
+        PhasedTile* pt = new PhasedTile();
+        // remove old tile
+        if (dtStatusFailed(navMesh->removeTile(loadedTileRefs[packedXY], &pt->data, &pt->dataSize)))
+            TC_LOG_ERROR("phase", "MMapData::AddSwap: Could not unload %03u%02i%02i.mmtile from navmesh", _mapId, x, y);
+        else
+        {
+            TC_LOG_DEBUG("phase", "MMapData::AddSwap: Unloaded %03u%02i%02i.mmtile from navmesh", _mapId, x, y);
+
+            // store the removed data first time, this is the origonal, non-phased tile
+            if (_baseTiles.find(packedXY) == _baseTiles.end())
+                _baseTiles[packedXY] = pt;
+
+            _activeSwaps.insert(swap);
+            loadedPhasedTiles[swap].insert(packedXY);
+
+            // add new swapped tile
+            if (dtStatusSucceed(navMesh->addTile(ptile->data, ptile->fileHeader.size, NULL, 0, &loadedTileRefs[packedXY])))
+            {
+                TC_LOG_DEBUG("phase", "MMapData::AddSwap: Loaded phased mmtile %03u[%02i, %02i] into %03i[%02i, %02i]", swap, x, y, _mapId, header->x, header->y);
+            }
+            else
+                TC_LOG_ERROR("phase", "MMapData::AddSwap: Could not load %03u%02i%02i.mmtile to navmesh", swap, x, y);
+        }
+    }
+
+    dtNavMesh* MMapData::GetNavMesh(TerrainSet swaps)
+    {
+        for (uint32 swap : _activeSwaps)
+        {
+            if (swaps.find(swap) == swaps.end()) // swap not active
+            {
+                PhaseTileContainer ptc = MMAP::MMapFactory::createOrGetMMapManager()->GetPhaseTileContainer(swap);
+                for (PhaseTileContainer::const_iterator itr = ptc.begin(); itr != ptc.end(); ++itr)
+                {
+                    RemoveSwap(itr->second, swap, itr->first); // remove swap
+                }
+            }
+        }
+        
+        if (!swaps.empty())
+        {
+            // for each of the calling unit's terrain swaps
+            for (uint32 swap : swaps)
+            {
+                // for each of the terrain swap's xy tiles
+                PhaseTileContainer ptc = MMAP::MMapFactory::createOrGetMMapManager()->GetPhaseTileContainer(swap);
+                for (PhaseTileContainer::const_iterator itr = ptc.begin(); itr != ptc.end(); ++itr)
+                {
+                    if (_activeSwaps.find(swap) == _activeSwaps.end()) // swap not active
+                    {
+                        AddSwap(itr->second, swap, itr->first); // add swap
+                    }
+                }
+            }
+        }
+        return navMesh;
+    }
 }