9 files changed, 534 insertions, 11 deletions

diff --git a/src/server/game/CMakeLists.txt b/src/server/game/CMakeLists.txt
index ccd18ef8e62..8ebf8075eeb 100644
--- a/src/server/game/CMakeLists.txt
+++ b/src/server/game/CMakeLists.txt
@@ -37,7 +37,7 @@ target_include_directories(game-interface
 target_link_libraries(game-interface
   INTERFACE
     shared
-    Detour)
+    mmaps_common)
 
 add_library(game
   ${PRIVATE_SOURCES})
diff --git a/src/server/game/Entities/GameObject/GameObject.cpp b/src/server/game/Entities/GameObject/GameObject.cpp
index e09930d9fd1..3102dac861e 100644
--- a/src/server/game/Entities/GameObject/GameObject.cpp
+++ b/src/server/game/Entities/GameObject/GameObject.cpp
@@ -4014,7 +4014,7 @@ void GameObject::UpdateModel()
         modelCollisionEnabled = GetGoType() == GAMEOBJECT_TYPE_CHEST ? getLootState() == GO_READY : (GetGoState() == GO_STATE_READY || IsTransport());
 
     RemoveFlag(GO_FLAG_MAP_OBJECT);
-    m_model = nullptr;
+    std::unique_ptr<GameObjectModel> oldModel = std::exchange(m_model, nullptr);
 
     CreateModel();
     if (m_model)
@@ -4023,6 +4023,23 @@ void GameObject::UpdateModel()
         if (modelCollisionEnabled)
             m_model->EnableCollision(modelCollisionEnabled);
     }
+
+    switch (GetGoType())
+    {
+        // Only update navmesh when display id changes and not on spawn
+        // default state of destructible buildings is intended to be baked in the mesh produced by mmaps_generator
+        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
+        case GAMEOBJECT_TYPE_TRAPDOOR:
+        case GAMEOBJECT_TYPE_PHASEABLE_MO:
+        case GAMEOBJECT_TYPE_SIEGEABLE_MO:
+            if (m_model)
+                GetMap()->RequestRebuildNavMeshOnGameObjectModelChange(*m_model, GetPhaseShift());
+            else if (oldModel)
+                GetMap()->RequestRebuildNavMeshOnGameObjectModelChange(*oldModel, GetPhaseShift());
+            break;
+        default:
+            break;
+    }
 }
 
 bool GameObject::IsLootAllowedFor(Player const* player) const
@@ -4499,6 +4516,7 @@ public:
     bool IsInPhase(PhaseShift const& phaseShift) const override { return _owner->GetPhaseShift().CanSee(phaseShift); }
     G3D::Vector3 GetPosition() const override { return G3D::Vector3(_owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZ()); }
     G3D::Quat GetRotation() const override { return G3D::Quat(_owner->GetLocalRotation().x, _owner->GetLocalRotation().y, _owner->GetLocalRotation().z, _owner->GetLocalRotation().w); }
+    int64 GetPackedRotation() const override { return _owner->GetPackedLocalRotation(); }
     float GetScale() const override { return _owner->GetObjectScale(); }
     void DebugVisualizeCorner(G3D::Vector3 const& corner) const override { _owner->SummonCreature(1, corner.x, corner.y, corner.z, 0, TEMPSUMMON_MANUAL_DESPAWN); }
 
@@ -4538,8 +4556,20 @@ void GameObject::CreateModel()
         if (m_model->IsMapObject())
             SetFlag(GO_FLAG_MAP_OBJECT);
 
-        if (GetGoType() == GAMEOBJECT_TYPE_DOOR)
-            m_model->DisableLosBlocking(GetGOInfo()->door.NotLOSBlocking);
+        switch (GetGoType())
+        {
+            case GAMEOBJECT_TYPE_DOOR:
+                m_model->DisableLosBlocking(GetGOInfo()->door.NotLOSBlocking);
+                break;
+            case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
+            case GAMEOBJECT_TYPE_TRAPDOOR:
+            case GAMEOBJECT_TYPE_PHASEABLE_MO:
+            case GAMEOBJECT_TYPE_SIEGEABLE_MO:
+                m_model->IncludeInNavMesh(true);
+                break;
+            default:
+                break;
+        }
     }
 }
 
diff --git a/src/server/game/Maps/DynamicMMapTileBuilder.cpp b/src/server/game/Maps/DynamicMMapTileBuilder.cpp
new file mode 100644
index 00000000000..49205597853
--- /dev/null
+++ b/src/server/game/Maps/DynamicMMapTileBuilder.cpp
@@ -0,0 +1,381 @@
+/*
+ * 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 "DynamicMMapTileBuilder.h"
+#include "Containers.h"
+#include "DB2Stores.h"
+#include "DeadlineTimer.h"
+#include "GameObjectModel.h"
+#include "GameTime.h"
+#include "Hash.h"
+#include "IoContext.h"
+#include "Log.h"
+#include "MMapDefines.h"
+#include "MMapManager.h"
+#include "Map.h"
+#include "VMapFactory.h"
+#include "VMapManager.h"
+#include "World.h"
+#include "advstd.h"
+#include <thread>
+
+namespace
+{
+struct TileCacheKeyObject
+{
+    uint32 DisplayId;
+    int16 Scale;
+    std::array<int16, 3> Position;
+    int64 Rotation;
+
+    friend std::strong_ordering operator<=>(TileCacheKeyObject const&, TileCacheKeyObject const&) = default;
+    friend bool operator==(TileCacheKeyObject const&, TileCacheKeyObject const&) = default;
+};
+
+struct TileCacheKey
+{
+    uint32 TerrainMapId;
+    uint32 X;
+    uint32 Y;
+    std::size_t CachedHash; // computing the hash is expensive - store it
+    std::vector<TileCacheKeyObject> Objects;
+
+    friend bool operator==(TileCacheKey const&, TileCacheKey const&) = default;
+};
+}
+
+template <>
+struct std::hash<TileCacheKey>
+{
+    static std::size_t Compute(TileCacheKey const& key) noexcept
+    {
+        size_t hashVal = 0;
+        Trinity::hash_combine(hashVal, key.TerrainMapId);
+        Trinity::hash_combine(hashVal, key.X);
+        Trinity::hash_combine(hashVal, key.Y);
+        for (TileCacheKeyObject const& object : key.Objects)
+        {
+            Trinity::hash_combine(hashVal, object.DisplayId);
+            Trinity::hash_combine(hashVal, object.Scale);
+            Trinity::hash_combine(hashVal, object.Position[0]);
+            Trinity::hash_combine(hashVal, object.Position[1]);
+            Trinity::hash_combine(hashVal, object.Position[2]);
+            Trinity::hash_combine(hashVal, object.Rotation);
+        }
+        return hashVal;
+    }
+
+    std::size_t operator()(TileCacheKey const& key) const noexcept
+    {
+        return key.CachedHash;
+    }
+};
+
+namespace
+{
+std::unique_ptr<VMAP::VMapManager> CreateVMapManager(uint32 mapId)
+{
+    std::unique_ptr<VMAP::VMapManager> vmgr = std::make_unique<VMAP::VMapManager>();
+
+    do
+    {
+        MapEntry const* mapEntry = sMapStore.AssertEntry(mapId);
+        if (!mapEntry)
+            break;
+
+        vmgr->InitializeThreadUnsafe(mapId, mapEntry->ParentMapID);
+        if (mapEntry->ParentMapID < 0)
+            break;
+
+        mapId = mapEntry->ParentMapID;
+    } while (true);
+
+    VMAP::VMapManager* globalManager = VMAP::VMapFactory::createOrGetVMapManager();
+    vmgr->GetLiquidFlagsPtr = globalManager->GetLiquidFlagsPtr;
+    vmgr->IsVMAPDisabledForPtr = globalManager->IsVMAPDisabledForPtr;
+    vmgr->LoadPathOnlyModels = globalManager->LoadPathOnlyModels;
+    return vmgr;
+}
+
+struct TileCache
+{
+    static TileCache* Instance()
+    {
+        static TileCache tc;
+        return &tc;
+    }
+
+    struct Tile
+    {
+        std::shared_ptr<MMAP::DynamicTileBuilder::AsyncTileResult> Data;
+        TimePoint LastAccessed;
+    };
+
+    static constexpr TimePoint::duration CACHE_CLEANUP_INTERVAL = 5min;
+    static constexpr TimePoint::duration CACHE_MAX_AGE = 30min;
+
+    std::mutex TilesMutex;
+    std::unordered_map<TileCacheKey, Tile> Tiles;
+
+    TileCache() :
+        _taskContext(1),
+        _cacheCleanupTimer(_taskContext, CACHE_CLEANUP_INTERVAL)
+    {
+        MMAP::CreateVMapManager = &CreateVMapManager;
+
+        // init timer
+        OnCacheCleanupTimerTick({});
+
+        // start the worker
+        _builderThread = std::thread([this] { _taskContext.run(); });
+    }
+
+    TileCache(TileCache const&) = delete;
+    TileCache(TileCache&&) = delete;
+
+    TileCache& operator=(TileCache const&) = delete;
+    TileCache& operator=(TileCache&&) = delete;
+
+    ~TileCache()
+    {
+        _cacheCleanupTimer.cancel();
+        _builderThread.join();
+    }
+
+    template <typename Task>
+    auto StartTask(Task&& task)
+    {
+        return Trinity::Asio::post(_taskContext, std::forward<Task>(task));
+    }
+
+private:
+    void OnCacheCleanupTimerTick(boost::system::error_code const& error)
+    {
+        if (error)
+            return;
+
+        TimePoint now = GameTime::Now();
+        RemoveOldCacheEntries(now - CACHE_MAX_AGE);
+        _cacheCleanupTimer.expires_at(now + CACHE_CLEANUP_INTERVAL);
+        _cacheCleanupTimer.async_wait([this](boost::system::error_code const& error) { OnCacheCleanupTimerTick(error); });
+    }
+
+    void RemoveOldCacheEntries(TimePoint oldestPreservedEntryTimestamp)
+    {
+        std::lock_guard lock(TilesMutex);
+        Trinity::Containers::EraseIf(Tiles, [=](std::unordered_map<TileCacheKey, Tile>::value_type const& kv)
+        {
+            return kv.second.LastAccessed < oldestPreservedEntryTimestamp;
+        });
+    }
+
+    Trinity::Asio::IoContext _taskContext;
+    Trinity::Asio::DeadlineTimer _cacheCleanupTimer;
+    std::thread _builderThread;
+};
+}
+
+namespace MMAP
+{
+struct DynamicTileBuilder::TileId
+{
+    uint32 TerrainMapId;
+    uint32 X;
+    uint32 Y;
+
+    friend bool operator==(TileId const&, TileId const&) = default;
+};
+
+struct TileBuildRequest
+{
+    DynamicTileBuilder::TileId Id;
+    std::weak_ptr<DynamicTileBuilder::AsyncTileResult> Result;
+    dtNavMesh* NavMesh;
+};
+
+bool InvokeAsyncCallbackIfReady(TileBuildRequest& request)
+{
+    std::shared_ptr<DynamicTileBuilder::AsyncTileResult> result = request.Result.lock();
+    if (!result)
+        return true;    // expired, mark as complete and do nothing
+
+    if (!result->IsReady.load(std::memory_order::acquire))
+        return false;
+
+    TileBuilder::TileResult const& tileResult = result->Result;
+    if (tileResult.data)
+    {
+        dtMeshHeader const* header = reinterpret_cast<dtMeshHeader const*>(tileResult.data.get());
+
+        if (dtTileRef tileRef = request.NavMesh->getTileRefAt(header->x, header->y, 0))
+        {
+            TC_LOG_INFO("maps.mmapgen", "[Map {:04}] [{:02},{:02}]: Swapping new tile", request.Id.TerrainMapId, request.Id.Y, request.Id.X);
+
+            request.NavMesh->removeTile(tileRef, nullptr, nullptr);
+
+            unsigned char* data = static_cast<unsigned char*>(dtAlloc(tileResult.size, DT_ALLOC_PERM));
+            std::memcpy(data, tileResult.data.get(), tileResult.size);
+
+            request.NavMesh->addTile(data, tileResult.size, DT_TILE_FREE_DATA, tileRef, nullptr);
+        }
+    }
+
+    return true;
+}
+
+static constexpr auto SetAsyncCallbackReady = [](DynamicTileBuilder::AsyncTileResult* result)
+{
+    result->IsReady.store(true, std::memory_order::release);
+};
+
+DynamicTileBuilder::DynamicTileBuilder(Map* map, dtNavMesh* navMesh) : TileBuilder(sWorld->GetDataPath(), sWorld->GetDataPath(), {}, {}, false, false, false, nullptr),
+    m_map(map), m_navMesh(navMesh), m_rebuildCheckTimer(1s)
+{
+}
+
+DynamicTileBuilder::~DynamicTileBuilder() = default;
+
+void DynamicTileBuilder::AddTile(uint32 terrainMapId, uint32 tileX, uint32 tileY)
+{
+    TileId id = { .TerrainMapId = terrainMapId, .X = tileX, .Y = tileY };
+    if (!advstd::ranges::contains(m_tilesToRebuild, id))
+        m_tilesToRebuild.push_back(id);
+}
+
+void DynamicTileBuilder::Update(Milliseconds diff)
+{
+    m_rebuildCheckTimer.Update(diff);
+    if (m_rebuildCheckTimer.Passed())
+    {
+        for (TileId const& tileId : m_tilesToRebuild)
+            m_tiles.AddCallback({ .Id = tileId, .Result = BuildTile(tileId.TerrainMapId, tileId.X, tileId.Y), .NavMesh = m_navMesh });
+
+        m_tilesToRebuild.clear();
+        m_rebuildCheckTimer.Reset(1s);
+    }
+
+    m_tiles.ProcessReadyCallbacks();
+}
+
+std::weak_ptr<DynamicTileBuilder::AsyncTileResult> DynamicTileBuilder::BuildTile(uint32 terrainMapId, uint32 tileX, uint32 tileY)
+{
+    std::vector<std::shared_ptr<GameObjectModel const>> gameObjectModelReferences; // hold strong refs to models
+    for (GameObjectModel const* gameObjectModel : m_map->GetGameObjectModelsInGrid(tileX, tileY))
+    {
+        if (!gameObjectModel->IsMapObject() || !gameObjectModel->IsIncludedInNavMesh())
+            continue;
+
+        std::shared_ptr<VMAP::WorldModel const> worldModel = gameObjectModel->GetWorldModel();
+        if (!worldModel)
+            continue;
+
+        gameObjectModelReferences.emplace_back(worldModel, gameObjectModel);
+    }
+
+    TileCacheKey cacheKey{ .TerrainMapId = terrainMapId, .X = tileX, .Y = tileY, .CachedHash = 0, .Objects = std::vector<TileCacheKeyObject>(gameObjectModelReferences.size()) };
+    for (std::size_t i = 0; i < gameObjectModelReferences.size(); ++i)
+    {
+        GameObjectModel const* gameObjectModel = gameObjectModelReferences[i].get();
+        TileCacheKeyObject& object = cacheKey.Objects[i];
+        object.DisplayId = gameObjectModel->GetDisplayId();
+        object.Scale = int16(gameObjectModel->GetScale() * 1024.0f);
+        object.Position = [](G3D::Vector3 const& pos) -> std::array<int16, 3>
+        {
+            return { int16(pos.x), int16(pos.y), int16(pos.z) };
+        }(gameObjectModel->GetPosition());
+        object.Rotation = gameObjectModel->GetPackedRotation();
+    }
+
+    // Ensure spawn order is stable after adding/removing gameobjects from the map for hash calculation
+    std::ranges::sort(cacheKey.Objects);
+
+    cacheKey.CachedHash = std::hash<TileCacheKey>::Compute(cacheKey);
+
+    TileCache* tileCache = TileCache::Instance();
+    std::lock_guard lock(tileCache->TilesMutex);
+    auto [itr, isNew] = tileCache->Tiles.try_emplace(std::move(cacheKey));
+    itr->second.LastAccessed = GameTime::Now();
+    if (!isNew)
+        return itr->second.Data;
+
+    itr->second.Data = std::make_shared<AsyncTileResult>();
+    tileCache->StartTask([result = itr->second.Data, hash = cacheKey.CachedHash, selfRef = weak_from_this(), terrainMapId, tileX, tileY, gameObjectModelReferences = std::move(gameObjectModelReferences)]() mutable
+    {
+        auto isReadyGuard = Trinity::make_unique_ptr_with_deleter<SetAsyncCallbackReady>(result.get());
+
+        std::shared_ptr<DynamicTileBuilder> self = selfRef.lock();
+        if (!self)
+            return;
+
+        // get navmesh params
+        dtNavMeshParams params;
+        std::vector<OffMeshData> offMeshConnections;
+        if (MMapManager::parseNavMeshParamsFile(sWorld->GetDataPath(), terrainMapId, &params, &offMeshConnections) != LoadResult::Success)
+            return;
+
+        std::unique_ptr<VMAP::VMapManager> vmapManager = CreateVMapManager(terrainMapId);
+
+        MeshData meshData;
+
+        // get heightmap data
+        self->m_terrainBuilder.loadMap(terrainMapId, tileX, tileY, meshData, vmapManager.get());
+
+        // get model data
+        self->m_terrainBuilder.loadVMap(terrainMapId, tileX, tileY, meshData, vmapManager.get());
+
+        for (std::shared_ptr<GameObjectModel const> const& gameObjectModel : gameObjectModelReferences)
+        {
+            G3D::Vector3 position = gameObjectModel->GetPosition();
+            position.x = -position.x;
+            position.y = -position.y;
+
+            G3D::Matrix3 invRotation = (G3D::Quat(0, 0, 1, 0) * gameObjectModel->GetRotation()).toRotationMatrix().inverse();
+
+            self->m_terrainBuilder.loadVMapModel(gameObjectModel->GetWorldModel().get(), position, invRotation, gameObjectModel->GetScale(),
+                meshData, vmapManager.get());
+        }
+
+        // if there is no data, give up now
+        if (meshData.solidVerts.empty() && meshData.liquidVerts.empty())
+            return;
+
+        // remove unused vertices
+        TerrainBuilder::cleanVertices(meshData.solidVerts, meshData.solidTris);
+        TerrainBuilder::cleanVertices(meshData.liquidVerts, meshData.liquidTris);
+
+        // gather all mesh data for final data check, and bounds calculation
+        std::vector<float> allVerts(meshData.liquidVerts.size() + meshData.solidVerts.size());
+        std::ranges::copy(meshData.liquidVerts, allVerts.begin());
+        std::ranges::copy(meshData.solidVerts, allVerts.begin() + std::ssize(meshData.liquidVerts));
+
+        // get bounds of current tile
+        float bmin[3], bmax[3];
+        getTileBounds(tileX, tileY, allVerts.data(), allVerts.size() / 3, bmin, bmax);
+
+        self->m_terrainBuilder.loadOffMeshConnections(terrainMapId, tileX, tileY, meshData, offMeshConnections);
+
+        // build navmesh tile
+        std::string debugSuffix = Trinity::StringFormat("_{:016X}", hash);
+
+        result->Result = self->buildMoveMapTile(terrainMapId, tileX, tileY, meshData, bmin, bmax, &params);
+        if (self->m_debugOutput && result->Result.data)
+            self->saveMoveMapTileToFile(terrainMapId, tileX, tileY, nullptr, result->Result, debugSuffix);
+    });
+
+    return itr->second.Data;
+}
+}
diff --git a/src/server/game/Maps/DynamicMMapTileBuilder.h b/src/server/game/Maps/DynamicMMapTileBuilder.h
new file mode 100644
index 00000000000..bbf10a3750a
--- /dev/null
+++ b/src/server/game/Maps/DynamicMMapTileBuilder.h
@@ -0,0 +1,69 @@
+/*
+ * 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 TRINITYCORE_DYNAMIC_MMAP_TILE_BUILDER_H
+#define TRINITYCORE_DYNAMIC_MMAP_TILE_BUILDER_H
+
+#include "AsyncCallbackProcessor.h"
+#include "TileBuilder.h"
+#include "Timer.h"
+#include <atomic>
+
+class Map;
+
+namespace MMAP
+{
+struct TileBuildRequest;
+bool InvokeAsyncCallbackIfReady(TileBuildRequest& request);
+
+class DynamicTileBuilder : public TileBuilder, public std::enable_shared_from_this<DynamicTileBuilder>
+{
+public:
+    explicit DynamicTileBuilder(Map* map, dtNavMesh* navMesh);
+    DynamicTileBuilder(DynamicTileBuilder const& other) = delete;
+    DynamicTileBuilder(DynamicTileBuilder&& other) = delete;
+    DynamicTileBuilder& operator=(DynamicTileBuilder const& other) = delete;
+    DynamicTileBuilder& operator=(DynamicTileBuilder&& other) = delete;
+    ~DynamicTileBuilder();
+
+    void AddTile(uint32 terrainMapId, uint32 tileX, uint32 tileY);
+
+    void Update(Milliseconds diff);
+
+    struct AsyncTileResult
+    {
+        TileResult Result;
+        std::atomic<bool> IsReady;
+    };
+
+private:
+    std::weak_ptr<AsyncTileResult> BuildTile(uint32 terrainMapId, uint32 tileX, uint32 tileY);
+
+    Map* m_map;
+    dtNavMesh* m_navMesh;
+
+    struct TileId;
+    std::vector<TileId> m_tilesToRebuild;
+
+    TimeTracker m_rebuildCheckTimer;
+
+    friend TileBuildRequest;
+    AsyncCallbackProcessor<TileBuildRequest> m_tiles;
+};
+}
+
+#endif // TRINITYCORE_DYNAMIC_MMAP_TILE_BUILDER_H
diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp
index 3a8e3c4cc56..c886f41ae44 100644
--- a/src/server/game/Maps/Map.cpp
+++ b/src/server/game/Maps/Map.cpp
@@ -25,6 +25,7 @@
 #include "DB2Stores.h"
 #include "DatabaseEnv.h"
 #include "DynamicTree.h"
+#include "DynamicMMapTileBuilder.h"
 #include "GameObjectModel.h"
 #include "GameTime.h"
 #include "GridNotifiers.h"
@@ -36,6 +37,7 @@
 #include "InstanceScenario.h"
 #include "InstanceScript.h"
 #include "Log.h"
+#include "MMapManager.h"
 #include "MapManager.h"
 #include "MapUtils.h"
 #include "Metric.h"
@@ -154,6 +156,9 @@ i_scriptLock(false), _respawnTimes(std::make_unique<RespawnListContainer>()), _r
 
     m_terrain->LoadMMapInstance(GetId(), GetInstanceId());
 
+    if (MMAP::MMapManager::isRebuildingTilesEnabledOnMap(GetId()))
+        m_mmapTileRebuilder = std::make_shared<MMAP::DynamicTileBuilder>(this, MMAP::MMapManager::instance()->GetNavMesh(GetId(), GetInstanceId()));
+
     _worldStateValues = sWorldStateMgr->GetInitialWorldStatesForMap(this);
 }
 
@@ -290,6 +295,7 @@ void Map::EnsureGridCreated(GridCoord const& p)
         int gy = (MAX_NUMBER_OF_GRIDS - 1) - p.y_coord;
 
         m_terrain->LoadMapAndVMap(gx, gy);
+        m_terrain->LoadMMap(GetInstanceId(), gx, gy);
     }
 }
 
@@ -647,6 +653,9 @@ void Map::UpdatePlayerZoneStats(uint32 oldZone, uint32 newZone)
 void Map::Update(uint32 t_diff)
 {
     _dynamicTree.update(t_diff);
+    if (m_mmapTileRebuilder)
+        m_mmapTileRebuilder->Update(Milliseconds(t_diff));
+
     /// update worldsessions for existing players
     for (m_mapRefIter = m_mapRefManager.begin(); m_mapRefIter != m_mapRefManager.end(); ++m_mapRefIter)
     {
@@ -1763,6 +1772,28 @@ bool Map::getObjectHitPos(PhaseShift const& phaseShift, float x1, float y1, floa
     return result;
 }
 
+void Map::RequestRebuildNavMeshOnGameObjectModelChange(GameObjectModel const& model, PhaseShift const& phaseShift)
+{
+    if (!m_mmapTileRebuilder)
+        return;
+
+    uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, GetId(), m_terrain.get(), model.GetPosition().x, model.GetPosition().y);
+
+    G3D::AABox const& bounds = model.getBounds();
+
+    GridCoord low = Trinity::ComputeGridCoord(bounds.high().x, bounds.high().y);
+    low.x_coord = (MAX_NUMBER_OF_GRIDS - 1) - low.x_coord;
+    low.y_coord = (MAX_NUMBER_OF_GRIDS - 1) - low.y_coord;
+
+    GridCoord high = Trinity::ComputeGridCoord(bounds.low().x, bounds.low().y);
+    high.x_coord = (MAX_NUMBER_OF_GRIDS - 1) - high.x_coord;
+    high.y_coord = (MAX_NUMBER_OF_GRIDS - 1) - high.y_coord;
+
+    for (uint32 x = low.x_coord; x <= high.x_coord; ++x)
+        for (uint32 y = low.y_coord; y <= high.y_coord; ++y)
+            m_mmapTileRebuilder->AddTile(terrainMapId, x, y);
+}
+
 TransferAbortParams Map::PlayerCannotEnter(uint32 mapid, Player* player)
 {
     MapEntry const* entry = sMapStore.LookupEntry(mapid);
diff --git a/src/server/game/Maps/Map.h b/src/server/game/Maps/Map.h
index 0241c6d0b62..c3fcfeb1aa4 100644
--- a/src/server/game/Maps/Map.h
+++ b/src/server/game/Maps/Map.h
@@ -83,6 +83,7 @@ enum class ItemContext : uint8;
 namespace Trinity { struct ObjectUpdater; }
 namespace Vignettes { struct VignetteData; }
 namespace VMAP { enum class ModelIgnoreFlags : uint32; }
+namespace MMAP { class DynamicTileBuilder; }
 
 enum TransferAbortReason : uint32
 {
@@ -496,12 +497,15 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
         void RemoveGameObjectModel(GameObjectModel const& model) { _dynamicTree.remove(model); }
         void InsertGameObjectModel(GameObjectModel const& model) { _dynamicTree.insert(model); }
         bool ContainsGameObjectModel(GameObjectModel const& model) const { return _dynamicTree.contains(model);}
+        std::span<GameObjectModel const* const> GetGameObjectModelsInGrid(uint32 gx, uint32 gy) const { return _dynamicTree.getModelsInGrid(gx, gy); }
         float GetGameObjectFloor(PhaseShift const& phaseShift, float x, float y, float z, float maxSearchDist = DEFAULT_HEIGHT_SEARCH) const
         {
             return _dynamicTree.getHeight(x, y, z, maxSearchDist, phaseShift);
         }
         bool getObjectHitPos(PhaseShift const& phaseShift, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float modifyDist);
 
+        void RequestRebuildNavMeshOnGameObjectModelChange(GameObjectModel const& model, PhaseShift const& phaseShift);
+
         virtual ObjectGuid::LowType GetOwnerGuildId(uint32 /*team*/ = TEAM_OTHER) const { return UI64LIT(0); }
         /*
             RESPAWN TIMES
@@ -647,6 +651,7 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
         uint32 m_unloadTimer;
         float m_VisibleDistance;
         DynamicMapTree _dynamicTree;
+        std::shared_ptr<MMAP::DynamicTileBuilder> m_mmapTileRebuilder;
 
         MapRefManager m_mapRefManager;
         MapRefManager::iterator m_mapRefIter;
diff --git a/src/server/game/Maps/TerrainMgr.cpp b/src/server/game/Maps/TerrainMgr.cpp
index 19dd852baca..4233f08e072 100644
--- a/src/server/game/Maps/TerrainMgr.cpp
+++ b/src/server/game/Maps/TerrainMgr.cpp
@@ -25,7 +25,6 @@
 #include "MMapManager.h"
 #include "PhasingHandler.h"
 #include "Random.h"
-#include "ScriptMgr.h"
 #include "Util.h"
 #include "VMapFactory.h"
 #include "VMapManager.h"
@@ -144,7 +143,7 @@ bool TerrainInfo::ExistVMap(uint32 mapid, int32 gx, int32 gy)
 
 bool TerrainInfo::HasChildTerrainGridFile(uint32 mapId, int32 gx, int32 gy) const
 {
-    auto childMapItr = std::find_if(_childTerrain.begin(), _childTerrain.end(), [mapId](std::shared_ptr<TerrainInfo> const& childTerrain) { return childTerrain->GetId() == mapId; });
+    auto childMapItr = std::ranges::find(_childTerrain, mapId, [](std::shared_ptr<TerrainInfo> const& childTerrain) { return childTerrain->GetId(); });
     return childMapItr != _childTerrain.end() && (*childMapItr)->_gridFileExists[GetBitsetIndex(gx, gy)];
 }
 
@@ -171,11 +170,18 @@ void TerrainInfo::LoadMMapInstance(uint32 mapId, uint32 instanceId)
         childTerrain->LoadMMapInstanceImpl(mapId, instanceId);
 }
 
+void TerrainInfo::LoadMMap(uint32 instanceId, int32 gx, int32 gy)
+{
+    LoadMMapImpl(instanceId, gx, gy);
+
+    for (std::shared_ptr<TerrainInfo> const& childTerrain : _childTerrain)
+        childTerrain->LoadMMapImpl(instanceId, gx, gy);
+}
+
 void TerrainInfo::LoadMapAndVMapImpl(int32 gx, int32 gy)
 {
     LoadMap(gx, gy);
     LoadVMap(gx, gy);
-    LoadMMap(gx, gy);
 
     for (std::shared_ptr<TerrainInfo> const& childTerrain : _childTerrain)
         childTerrain->LoadMapAndVMapImpl(gx, gy);
@@ -233,12 +239,12 @@ void TerrainInfo::LoadVMap(int32 gx, int32 gy)
     }
 }
 
-void TerrainInfo::LoadMMap(int32 gx, int32 gy)
+void TerrainInfo::LoadMMapImpl(uint32 instanceId, int32 gx, int32 gy)
 {
     if (!DisableMgr::IsPathfindingEnabled(GetId()))
         return;
 
-    switch (MMAP::LoadResult mmapLoadResult = MMAP::MMapManager::instance()->loadMap(sWorld->GetDataPath(), GetId(), gx, gy))
+    switch (MMAP::LoadResult mmapLoadResult = MMAP::MMapManager::instance()->loadMap(sWorld->GetDataPath(), GetId(), instanceId, gx, gy))
     {
         case MMAP::LoadResult::Success:
             TC_LOG_DEBUG("mmaps.tiles", "MMAP loaded name:{}, id:{}, x:{}, y:{} (mmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
diff --git a/src/server/game/Maps/TerrainMgr.h b/src/server/game/Maps/TerrainMgr.h
index b4b5c5e4f89..f0e35556f22 100644
--- a/src/server/game/Maps/TerrainMgr.h
+++ b/src/server/game/Maps/TerrainMgr.h
@@ -58,13 +58,14 @@ public:
 
     void LoadMapAndVMap(int32 gx, int32 gy);
     void LoadMMapInstance(uint32 mapId, uint32 instanceId);
+    void LoadMMap(uint32 instanceId, int32 gx, int32 gy);
 
 private:
     void LoadMapAndVMapImpl(int32 gx, int32 gy);
     void LoadMMapInstanceImpl(uint32 mapId, uint32 instanceId);
     void LoadMap(int32 gx, int32 gy);
     void LoadVMap(int32 gx, int32 gy);
-    void LoadMMap(int32 gx, int32 gy);
+    void LoadMMapImpl(uint32 instanceId, int32 gx, int32 gy);
 
 public:
     void UnloadMap(int32 gx, int32 gy);
diff --git a/src/server/game/Movement/PathGenerator.cpp b/src/server/game/Movement/PathGenerator.cpp
index 49f2f0150fa..8f44c3fcc29 100644
--- a/src/server/game/Movement/PathGenerator.cpp
+++ b/src/server/game/Movement/PathGenerator.cpp
@@ -43,7 +43,7 @@ PathGenerator::PathGenerator(WorldObject const* owner) :
     {
         MMAP::MMapManager* mmap = MMAP::MMapManager::instance();
         _navMeshQuery = mmap->GetNavMeshQuery(mapId, _source->GetMapId(), _source->GetInstanceId());
-        _navMesh = _navMeshQuery ? _navMeshQuery->getAttachedNavMesh() : mmap->GetNavMesh(mapId);
+        _navMesh = _navMeshQuery ? _navMeshQuery->getAttachedNavMesh() : mmap->GetNavMesh(mapId, _source->GetInstanceId());
     }
 
     CreateFilter();