Core/Phasing: Rewrite GetTerrainMapId

14 files changed, 57 insertions, 84 deletions

diff --git a/src/common/Collision/Management/IVMapManager.h b/src/common/Collision/Management/IVMapManager.h
index 922549f53da..cec5657f5ed 100644
--- a/src/common/Collision/Management/IVMapManager.h
+++ b/src/common/Collision/Management/IVMapManager.h
@@ -94,8 +94,6 @@ namespace VMAP
             */
             virtual bool getAreaInfo(unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const=0;
             virtual bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const=0;
-
-            virtual int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const = 0;
     };
 
 }
diff --git a/src/common/Collision/Management/VMapManager2.cpp b/src/common/Collision/Management/VMapManager2.cpp
index 9e5955b8794..ae8052c83c4 100644
--- a/src/common/Collision/Management/VMapManager2.cpp
+++ b/src/common/Collision/Management/VMapManager2.cpp
@@ -306,15 +306,6 @@ namespace VMAP
         return false;
     }
 
-    int32 VMapManager2::GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const
-    {
-        auto instanceTree = GetMapTree(mapId);
-        if (instanceTree != iInstanceMapTrees.end())
-            return instanceTree->second->GetDistanceToClosestPrimaryTile(x, y);
-
-        return std::numeric_limits<int32>::max();
-    }
-
     WorldModel* VMapManager2::acquireModelInstance(const std::string& basepath, const std::string& filename)
     {
         //! Critical section, thread safe access to iLoadedModelFiles
diff --git a/src/common/Collision/Management/VMapManager2.h b/src/common/Collision/Management/VMapManager2.h
index fb23f6e239f..5bb556ccf64 100644
--- a/src/common/Collision/Management/VMapManager2.h
+++ b/src/common/Collision/Management/VMapManager2.h
@@ -123,8 +123,6 @@ namespace VMAP
             bool getAreaInfo(unsigned int pMapId, float x, float y, float& z, uint32& flags, int32& adtId, int32& rootId, int32& groupId) const override;
             bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 reqLiquidType, float& level, float& floor, uint32& type) const override;
 
-            int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const override;
-
             WorldModel* acquireModelInstance(const std::string& basepath, const std::string& filename);
             void releaseModelInstance(const std::string& filename);
 
diff --git a/src/common/Collision/Maps/MapTree.cpp b/src/common/Collision/Maps/MapTree.cpp
index 55ff1711a54..6404c6ce4bb 100644
--- a/src/common/Collision/Maps/MapTree.cpp
+++ b/src/common/Collision/Maps/MapTree.cpp
@@ -242,7 +242,6 @@ namespace VMAP
         TileFileOpenResult result;
         result.Name = basePath + getTileFileName(mapID, tileX, tileY);
         result.File = fopen(result.Name.c_str(), "rb");
-        result.IsPrimary = true;
         if (!result.File)
         {
             int32 parentMapId = vm->getParentMapId(mapID);
@@ -250,7 +249,6 @@ namespace VMAP
             {
                 result.Name = basePath + getTileFileName(parentMapId, tileX, tileY);
                 result.File = fopen(result.Name.c_str(), "rb");
-                result.IsPrimary = false;
             }
         }
 
@@ -372,7 +370,6 @@ namespace VMAP
         }
         iLoadedSpawns.clear();
         iLoadedTiles.clear();
-        iLoadedPrimaryTiles.clear();
     }
 
     //=========================================================
@@ -447,8 +444,6 @@ namespace VMAP
                 }
             }
             iLoadedTiles[packTileID(tileX, tileY)] = true;
-            if (fileResult.IsPrimary)
-                iLoadedPrimaryTiles.emplace_back(tileX, tileY);
             fclose(fileResult.File);
         }
         else
@@ -512,8 +507,6 @@ namespace VMAP
             }
         }
         iLoadedTiles.erase(tile);
-        iLoadedPrimaryTiles.erase(std::remove_if(iLoadedPrimaryTiles.begin(), iLoadedPrimaryTiles.end(),
-            [tileX, tileY](std::pair<uint32, uint32> const& p) { return p.first == tileX && p.second == tileY; }), iLoadedPrimaryTiles.end());
         TC_METRIC_EVENT("map_events", "UnloadMapTile",
             "Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
     }
@@ -523,13 +516,4 @@ namespace VMAP
         models = iTreeValues;
         count = iNTreeValues;
     }
-
-    int32 StaticMapTree::GetDistanceToClosestPrimaryTile(int32 x, int32 y) const
-    {
-        int32 minDistance = std::numeric_limits<int32>::max();
-        for (std::pair<int32, int32> const& primaryTile : iLoadedPrimaryTiles)
-            minDistance = std::min(minDistance, (primaryTile.first - x) * (primaryTile.first - x) + (primaryTile.second - y) * (primaryTile.second - y));
-
-        return minDistance;
-    }
 }
diff --git a/src/common/Collision/Maps/MapTree.h b/src/common/Collision/Maps/MapTree.h
index bf991c547c9..d762f804132 100644
--- a/src/common/Collision/Maps/MapTree.h
+++ b/src/common/Collision/Maps/MapTree.h
@@ -62,7 +62,6 @@ namespace VMAP
             {
                 FILE* File;
                 std::string Name;
-                bool IsPrimary;
             };
 
         private:
@@ -92,8 +91,6 @@ namespace VMAP
             uint32 numLoadedTiles() const { return uint32(iLoadedTiles.size()); }
             void getModelInstances(ModelInstance* &models, uint32 &count);
 
-            int32 GetDistanceToClosestPrimaryTile(int32 x, int32 y) const;
-
         private:
             StaticMapTree(StaticMapTree const& right) = delete;
             StaticMapTree& operator=(StaticMapTree const& right) = delete;
diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index 7d27d573cac..5745b9ab5db 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -2822,7 +2822,8 @@ void WorldObject::MovePositionToFirstCollision(Position &pos, float dist, float
     }
 
     destz = NormalizeZforCollision(this, destx, desty, pos.GetPositionZ());
-    bool col = VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(GetPhaseShift().GetTerrainMapId(GetMapId(), pos.m_positionX, pos.m_positionY), pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
+    bool col = VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(PhasingHandler::GetTerrainMapId(GetPhaseShift(), GetMap(), pos.m_positionX, pos.m_positionY),
+        pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
 
     // collision occured
     if (col)
diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp
index 0e161abdf98..0872ace1ac5 100644
--- a/src/server/game/Maps/Map.cpp
+++ b/src/server/game/Maps/Map.cpp
@@ -2550,13 +2550,19 @@ GridMap* Map::GetGrid(uint32 mapId, float x, float y)
     EnsureGridCreated(GridCoord((MAX_NUMBER_OF_GRIDS - 1) - gx, (MAX_NUMBER_OF_GRIDS - 1) - gy));
 
     GridMap* grid = GridMaps[gx][gy];
-    auto childMapItr = std::find_if(m_childTerrainMaps->begin(), m_childTerrainMaps->end(), [mapId](Map* childTerrainMap) {return childTerrainMap->GetId() == mapId; });
+    auto childMapItr = std::find_if(m_childTerrainMaps->begin(), m_childTerrainMaps->end(), [mapId](Map* childTerrainMap) { return childTerrainMap->GetId() == mapId; });
     if (childMapItr != m_childTerrainMaps->end() && (*childMapItr)->GridMaps[gx][gy]->fileExists())
         grid = (*childMapItr)->GridMaps[gx][gy];
 
     return grid;
 }
 
+bool Map::HasGrid(uint32 mapId, int32 gx, int32 gy) const
+{
+    auto childMapItr = std::find_if(m_childTerrainMaps->begin(), m_childTerrainMaps->end(), [mapId](Map* childTerrainMap) { return childTerrainMap->GetId() == mapId; });
+    return childMapItr != m_childTerrainMaps->end() && (*childMapItr)->GridMaps[gx][gy] && (*childMapItr)->GridMaps[gx][gy]->fileExists();
+}
+
 float Map::GetWaterOrGroundLevel(PhaseShift const& phaseShift, float x, float y, float z, float* ground /*= nullptr*/, bool /*swim = false*/) const
 {
     if (const_cast<Map*>(this)->GetGrid(x, y))
@@ -2579,7 +2585,7 @@ float Map::GetStaticHeight(PhaseShift const& phaseShift, float x, float y, float
 {
     // find raw .map surface under Z coordinates
     float mapHeight = VMAP_INVALID_HEIGHT_VALUE;
-    uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
+    uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
     if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(terrainMapId, x, y))
     {
         float gridHeight = gmap->getHeight(x, y);
@@ -2672,7 +2678,7 @@ bool Map::IsOutdoors(PhaseShift const& phaseShift, float x, float y, float z) co
 bool Map::GetAreaInfo(PhaseShift const& phaseShift, float x, float y, float z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const
 {
     float vmap_z = z;
-    uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
+    uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
     VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
     if (vmgr->getAreaInfo(terrainMapId, x, y, vmap_z, flags, adtId, rootId, groupId))
     {
@@ -2711,7 +2717,7 @@ uint32 Map::GetAreaId(PhaseShift const& phaseShift, float x, float y, float z, b
 
     if (!areaId)
     {
-        if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
+        if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
             areaId = gmap->getArea(x, y);
 
         // this used while not all *.map files generated (instances)
@@ -2754,7 +2760,7 @@ void Map::GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32&
 
 uint8 Map::GetTerrainType(PhaseShift const& phaseShift, float x, float y) const
 {
-    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
+    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
         return gmap->getTerrainType(x, y);
     else
         return 0;
@@ -2767,7 +2773,7 @@ ZLiquidStatus Map::getLiquidStatus(PhaseShift const& phaseShift, float x, float
     float liquid_level = INVALID_HEIGHT;
     float ground_level = INVALID_HEIGHT;
     uint32 liquid_type = 0;
-    uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
+    uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
     if (vmgr->GetLiquidLevel(terrainMapId, x, y, z, 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);
@@ -2848,7 +2854,7 @@ ZLiquidStatus Map::getLiquidStatus(PhaseShift const& phaseShift, float x, float
 
 float Map::GetWaterLevel(PhaseShift const& phaseShift, float x, float y) const
 {
-    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
+    if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
         return gmap->getLiquidLevel(x, y);
     else
         return 0;
@@ -2856,7 +2862,7 @@ float Map::GetWaterLevel(PhaseShift const& phaseShift, float x, float y) const
 
 bool Map::isInLineOfSight(PhaseShift const& phaseShift, float x1, float y1, float z1, float x2, float y2, float z2) const
 {
-    return VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(phaseShift.GetTerrainMapId(GetId(), x1, x2), x1, y1, z1, x2, y2, z2)
+    return VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(PhasingHandler::GetTerrainMapId(phaseShift, this, x1, y1), x1, y1, z1, x2, y2, z2)
         && _dynamicTree.isInLineOfSight({ x1, y1, z1 }, { x2, y2, z2 }, phaseShift);
 }
 
diff --git a/src/server/game/Maps/Map.h b/src/server/game/Maps/Map.h
index b2a0cb91551..5a256482d71 100644
--- a/src/server/game/Maps/Map.h
+++ b/src/server/game/Maps/Map.h
@@ -324,6 +324,7 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
 
         time_t GetGridExpiry() const { return i_gridExpiry; }
 
+        bool HasGrid(uint32 mapId, int32 gx, int32 gy) const;
         static bool ExistMap(uint32 mapid, int gx, int gy);
         static bool ExistVMap(uint32 mapid, int gx, int gy);
 
@@ -631,8 +632,6 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
         void setNGrid(NGridType* grid, uint32 x, uint32 y);
         void ScriptsProcess();
 
-        void UpdateActiveCells(const float &x, const float &y, const uint32 t_diff);
-
         void SendObjectUpdates();
 
     protected:
diff --git a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
index 210de91f8b0..c4cd065ccbf 100644
--- a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
+++ b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
@@ -23,6 +23,7 @@
 #include "ObjectAccessor.h"
 #include "MoveSplineInit.h"
 #include "MoveSpline.h"
+#include "PhasingHandler.h"
 #include "Player.h"
 #include "VMapFactory.h"
 
@@ -51,11 +52,9 @@ void FleeingMovementGenerator<T>::_setTargetLocation(T* owner)
 
     // Add LOS check for target point
     Position mypos = owner->GetPosition();
-    bool isInLOS = VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(owner->GetPhaseShift().GetTerrainMapId(owner->GetMapId(), mypos.m_positionX, mypos.m_positionY),
-                                                                                mypos.m_positionX,
-                                                                                mypos.m_positionY,
-                                                                                mypos.m_positionZ + 2.0f,
-                                                                                x, y, z + 2.0f);
+    bool isInLOS = VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(
+        PhasingHandler::GetTerrainMapId(owner->GetPhaseShift(), owner->GetMap(), mypos.m_positionX, mypos.m_positionY),
+        mypos.m_positionX, mypos.m_positionY, mypos.m_positionZ + 2.0f, x, y, z + 2.0f);
     if (!isInLOS)
     {
         i_nextCheckTime.Reset(200);
diff --git a/src/server/game/Movement/PathGenerator.cpp b/src/server/game/Movement/PathGenerator.cpp
index 16cfe366f4e..4c89bb99e2c 100644
--- a/src/server/game/Movement/PathGenerator.cpp
+++ b/src/server/game/Movement/PathGenerator.cpp
@@ -18,15 +18,16 @@
  */
 
 #include "PathGenerator.h"
-#include "Map.h"
 #include "Creature.h"
-#include "MMapFactory.h"
-#include "MMapManager.h"
-#include "Log.h"
-#include "DisableMgr.h"
 #include "DetourCommon.h"
 #include "DetourNavMeshQuery.h"
+#include "DisableMgr.h"
+#include "Log.h"
+#include "MMapFactory.h"
+#include "MMapManager.h"
+#include "Map.h"
 #include "Metric.h"
+#include "PhasingHandler.h"
 
 ////////////////// PathGenerator //////////////////
 PathGenerator::PathGenerator(const Unit* owner) :
@@ -39,7 +40,7 @@ PathGenerator::PathGenerator(const Unit* owner) :
 
     TC_LOG_DEBUG("maps", "++ PathGenerator::PathGenerator for %s", _sourceUnit->GetGUID().ToString().c_str());
 
-    uint32 mapId = _sourceUnit->GetPhaseShift().GetTerrainMapId(_sourceUnit->GetMapId(), _sourceUnit->GetPositionX(), _sourceUnit->GetPositionY());
+    uint32 mapId = PhasingHandler::GetTerrainMapId(_sourceUnit->GetPhaseShift(), _sourceUnit->GetMap(), _sourceUnit->GetPositionX(), _sourceUnit->GetPositionY());
     if (DisableMgr::IsPathfindingEnabled(_sourceUnit->GetMapId()))
     {
         MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();
diff --git a/src/server/game/Phasing/PhaseShift.cpp b/src/server/game/Phasing/PhaseShift.cpp
index d543ccd1f22..b2885ae15bb 100644
--- a/src/server/game/Phasing/PhaseShift.cpp
+++ b/src/server/game/Phasing/PhaseShift.cpp
@@ -17,8 +17,6 @@
 
 #include "PhaseShift.h"
 #include "Containers.h"
-#include "GridDefines.h"
-#include "VMapFactory.h"
 
 bool PhaseShift::AddPhase(uint32 phaseId, PhaseFlags flags, std::vector<Condition*> const* areaConditions, int32 references /*= 1*/)
 {
@@ -147,33 +145,6 @@ bool PhaseShift::CanSee(PhaseShift const& other) const
     return checkInversePhaseShift(other, *this);
 }
 
-uint32 PhaseShift::GetTerrainMapId(uint32 realMapId, float x, float y) const
-{
-    if (VisibleMapIds.empty())
-        return realMapId;
-
-    if (VisibleMapIds.size() == 1)
-        return VisibleMapIds.begin()->first;
-
-    GridCoord gridCoord = Trinity::ComputeGridCoord(x, y);
-    int32 gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
-    int32 gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
-
-    int32 minDistance = std::numeric_limits<int32>::max();
-    uint32 terrainMapId;
-    for (auto itr = VisibleMapIds.begin(); itr != VisibleMapIds.end(); ++itr)
-    {
-        int32 dist = VMAP::VMapFactory::createOrGetVMapManager()->GetDistanceToClosestPrimaryTile(itr->first, gx, gy);
-        if (dist < minDistance)
-        {
-            minDistance = dist;
-            terrainMapId = itr->first;
-        }
-    }
-
-    return terrainMapId;
-}
-
 void PhaseShift::ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references)
 {
     itr->References += references;
diff --git a/src/server/game/Phasing/PhaseShift.h b/src/server/game/Phasing/PhaseShift.h
index ca38614ed45..8755868ae9d 100644
--- a/src/server/game/Phasing/PhaseShift.h
+++ b/src/server/game/Phasing/PhaseShift.h
@@ -101,7 +101,6 @@ public:
     void ClearPhases();
 
     bool CanSee(PhaseShift const& other) const;
-    uint32 GetTerrainMapId(uint32 realMapId, float x, float y) const;
 
 protected:
     friend class PhasingHandler;
diff --git a/src/server/game/Phasing/PhasingHandler.cpp b/src/server/game/Phasing/PhasingHandler.cpp
index 44f0a9ff753..549093fecba 100644
--- a/src/server/game/Phasing/PhasingHandler.cpp
+++ b/src/server/game/Phasing/PhasingHandler.cpp
@@ -469,6 +469,32 @@ bool PhasingHandler::InDbPhaseShift(WorldObject const* object, uint8 phaseUseFla
     return object->GetPhaseShift().CanSee(phaseShift);
 }
 
+uint32 PhasingHandler::GetTerrainMapId(PhaseShift const& phaseShift, Map const* map, float x, float y)
+{
+    if (phaseShift.VisibleMapIds.empty())
+        return map->GetId();
+
+    if (phaseShift.VisibleMapIds.size() == 1)
+        return phaseShift.VisibleMapIds.begin()->first;
+
+    GridCoord gridCoord = Trinity::ComputeGridCoord(x, y);
+    int32 gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
+    int32 gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
+
+    int32 gxbegin = std::max(gx - 1, 0);
+    int32 gxend = std::min(gx + 1, MAX_NUMBER_OF_GRIDS);
+    int32 gybegin = std::max(gy - 1, 0);
+    int32 gyend = std::min(gy + 1, MAX_NUMBER_OF_GRIDS);
+
+    for (auto itr = phaseShift.VisibleMapIds.rbegin(); itr != phaseShift.VisibleMapIds.rend(); ++itr)
+        for (int32 gxi = gxbegin; gxi < gxend; ++gxi)
+            for (int32 gyi = gybegin; gyi < gyend; ++gyi)
+                if (map->HasGrid(itr->first, gxi, gyi))
+                    return itr->first;
+
+    return map->GetId();
+}
+
 void PhasingHandler::SetAlwaysVisible(PhaseShift& phaseShift, bool apply)
 {
     if (apply)
diff --git a/src/server/game/Phasing/PhasingHandler.h b/src/server/game/Phasing/PhasingHandler.h
index 9ee408ad26c..95f4357b30c 100644
--- a/src/server/game/Phasing/PhasingHandler.h
+++ b/src/server/game/Phasing/PhasingHandler.h
@@ -22,6 +22,7 @@
 #include <string>
 
 class ChatHandler;
+class Map;
 class PhaseShift;
 class Player;
 class WorldObject;
@@ -60,6 +61,8 @@ public:
     static void InitDbVisibleMapId(PhaseShift& phaseShift, int32 visibleMapId);
     static bool InDbPhaseShift(WorldObject const* object, uint8 phaseUseFlags, uint16 phaseId, uint32 phaseGroupId);
 
+    static uint32 GetTerrainMapId(PhaseShift const& phaseShift, Map const* map, float x, float y);
+
     static void SetAlwaysVisible(PhaseShift& phaseShift, bool apply);
     static void SetInversed(PhaseShift& phaseShift, bool apply);