aboutsummaryrefslogtreecommitdiff
path: root/src/server
diff options
context:
space:
mode:
Diffstat (limited to 'src/server')
-rw-r--r--src/server/game/CMakeLists.txt2
-rw-r--r--src/server/game/Entities/GameObject/GameObject.cpp36
-rw-r--r--src/server/game/Maps/DynamicMMapTileBuilder.cpp381
-rw-r--r--src/server/game/Maps/DynamicMMapTileBuilder.h69
-rw-r--r--src/server/game/Maps/Map.cpp31
-rw-r--r--src/server/game/Maps/Map.h5
-rw-r--r--src/server/game/Maps/TerrainMgr.cpp16
-rw-r--r--src/server/game/Maps/TerrainMgr.h3
-rw-r--r--src/server/game/Movement/PathGenerator.cpp2
-rw-r--r--src/server/scripts/Commands/cs_misc.cpp2
-rw-r--r--src/server/scripts/Commands/cs_mmaps.cpp10
11 files changed, 540 insertions, 17 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();
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index 5e87cf376fb..f824e35850c 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -258,7 +258,7 @@ public:
uint32 haveMap = TerrainInfo::ExistMap(mapId, gridX, gridY) ? 1 : 0;
uint32 haveVMap = TerrainInfo::ExistVMap(mapId, gridX, gridY) ? 1 : 0;
- uint32 haveMMap = (DisableMgr::IsPathfindingEnabled(mapId) && MMAP::MMapManager::instance()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId())) ? 1 : 0;
+ uint32 haveMMap = (DisableMgr::IsPathfindingEnabled(mapId) && MMAP::MMapManager::instance()->GetNavMesh(object->GetMapId(), object->GetInstanceId())) ? 1 : 0;
if (haveVMap)
{
diff --git a/src/server/scripts/Commands/cs_mmaps.cpp b/src/server/scripts/Commands/cs_mmaps.cpp
index b7734a8c505..ec2ada1971d 100644
--- a/src/server/scripts/Commands/cs_mmaps.cpp
+++ b/src/server/scripts/Commands/cs_mmaps.cpp
@@ -66,7 +66,8 @@ public:
static bool HandleMmapPathCommand(ChatHandler* handler, char const* args)
{
- if (!MMAP::MMapManager::instance()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
+ Player* player = handler->GetSession()->GetPlayer();
+ if (!MMAP::MMapManager::instance()->GetNavMesh(player->GetMapId(), player->GetInstanceId()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
@@ -75,7 +76,6 @@ public:
handler->PSendSysMessage("mmap path:");
// units
- Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
@@ -144,7 +144,7 @@ public:
handler->PSendSysMessage("%04u_%02i_%02i.mmtile", terrainMapId, gx, gy);
handler->PSendSysMessage("tileloc [%i, %i]", gy, gx);
- dtNavMesh const* navmesh = MMAP::MMapManager::instance()->GetNavMesh(terrainMapId);
+ dtNavMesh const* navmesh = MMAP::MMapManager::instance()->GetNavMesh(terrainMapId, player->GetInstanceId());
dtNavMeshQuery const* navmeshquery = MMAP::MMapManager::instance()->GetNavMeshQuery(terrainMapId, player->GetMapId(), player->GetInstanceId());
if (!navmesh || !navmeshquery)
{
@@ -195,7 +195,7 @@ public:
{
Player* player = handler->GetSession()->GetPlayer();
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(player->GetPhaseShift(), player->GetMapId(), player->GetMap()->GetTerrain(), player->GetPositionX(), player->GetPositionY());
- dtNavMesh const* navmesh = MMAP::MMapManager::instance()->GetNavMesh(terrainMapId);
+ dtNavMesh const* navmesh = MMAP::MMapManager::instance()->GetNavMesh(terrainMapId, player->GetInstanceId());
dtNavMeshQuery const* navmeshquery = MMAP::MMapManager::instance()->GetNavMeshQuery(terrainMapId, player->GetMapId(), player->GetInstanceId());
if (!navmesh || !navmeshquery)
{
@@ -227,7 +227,7 @@ public:
MMAP::MMapManager* manager = MMAP::MMapManager::instance();
handler->PSendSysMessage(" %u maps loaded with %u tiles overall", manager->getLoadedMapsCount(), manager->getLoadedTilesCount());
- dtNavMesh const* navmesh = manager->GetNavMesh(terrainMapId);
+ dtNavMesh const* navmesh = manager->GetNavMesh(terrainMapId, player->GetInstanceId());
if (!navmesh)
{
handler->PSendSysMessage("NavMesh not loaded for current map.");