Core/VMaps: Implement loading phased tiles

Closes #15163

21 files changed, 474 insertions, 195 deletions

diff --git a/src/common/Collision/Management/IVMapManager.h b/src/common/Collision/Management/IVMapManager.h
index cec5657f5ed..922549f53da 100644
--- a/src/common/Collision/Management/IVMapManager.h
+++ b/src/common/Collision/Management/IVMapManager.h
@@ -94,6 +94,8 @@ 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 354e3c03b87..9e5955b8794 100644
--- a/src/common/Collision/Management/VMapManager2.cpp
+++ b/src/common/Collision/Management/VMapManager2.cpp
@@ -40,23 +40,35 @@ namespace VMAP
         thread_safe_environment = true;
     }
 
-    VMapManager2::~VMapManager2(void)
+    VMapManager2::~VMapManager2()
     {
-        for (InstanceTreeMap::iterator i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
-        {
+        for (auto i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
             delete i->second;
-        }
-        for (ModelFileMap::iterator i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
-        {
+
+        for (auto i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
             delete i->second.getModel();
-        }
     }
 
-    void VMapManager2::InitializeThreadUnsafe(const std::vector<uint32>& mapIds)
+    InstanceTreeMap::const_iterator VMapManager2::GetMapTree(uint32 mapId) const
+    {
+        // return the iterator if found or end() if not found/NULL
+        auto itr = iInstanceMapTrees.find(mapId);
+        if (itr != iInstanceMapTrees.cend() && !itr->second)
+            itr = iInstanceMapTrees.cend();
+
+        return itr;
+    }
+
+    void VMapManager2::InitializeThreadUnsafe(std::unordered_map<uint32, std::vector<uint32>> const& mapData)
     {
         // the caller must pass the list of all mapIds that will be used in the VMapManager2 lifetime
-        for (uint32 const& mapId : mapIds)
-            iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId, nullptr));
+        iChildMapData = mapData;
+        for (std::pair<uint32 const, std::vector<uint32>> const& mapId : mapData)
+        {
+            iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId.first, nullptr));
+            for (uint32 childMapId : mapId.second)
+                iParentMapData[childMapId] = mapId.first;
+        }
 
         thread_safe_environment = false;
     }
@@ -87,8 +99,15 @@ namespace VMAP
         int result = VMAP_LOAD_RESULT_IGNORED;
         if (isMapLoadingEnabled())
         {
-            if (_loadMap(mapId, basePath, x, y))
+            if (loadSingleMap(mapId, basePath, x, y))
+            {
                 result = VMAP_LOAD_RESULT_OK;
+                auto childMaps = iChildMapData.find(mapId);
+                if (childMaps != iChildMapData.end())
+                    for (uint32 childMapId : childMaps->second)
+                        if (!loadSingleMap(childMapId, basePath, x, y))
+                            result = VMAP_LOAD_RESULT_ERROR;
+            }
             else
                 result = VMAP_LOAD_RESULT_ERROR;
         }
@@ -96,20 +115,10 @@ namespace VMAP
         return result;
     }
 
-    InstanceTreeMap::const_iterator VMapManager2::GetMapTree(uint32 mapId) const
-    {
-        // return the iterator if found or end() if not found/NULL
-        InstanceTreeMap::const_iterator itr = iInstanceMapTrees.find(mapId);
-        if (itr != iInstanceMapTrees.cend() && !itr->second)
-            itr = iInstanceMapTrees.cend();
-
-        return itr;
-    }
-
     // load one tile (internal use only)
-    bool VMapManager2::_loadMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY)
+    bool VMapManager2::loadSingleMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY)
     {
-        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
+        auto instanceTree = iInstanceMapTrees.find(mapId);
         if (instanceTree == iInstanceMapTrees.end())
         {
             if (thread_safe_environment)
@@ -134,12 +143,22 @@ namespace VMAP
         return instanceTree->second->LoadMapTile(tileX, tileY, this);
     }
 
-    void VMapManager2::unloadMap(unsigned int mapId)
+    void VMapManager2::unloadMap(unsigned int mapId, int x, int y)
     {
-        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
+        auto childMaps = iChildMapData.find(mapId);
+        if (childMaps != iChildMapData.end())
+            for (uint32 childMapId : childMaps->second)
+                unloadSingleMap(childMapId, x, y);
+
+        unloadSingleMap(mapId, x, y);
+    }
+
+    void VMapManager2::unloadSingleMap(uint32 mapId, int x, int y)
+    {
+        auto instanceTree = iInstanceMapTrees.find(mapId);
         if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
         {
-            instanceTree->second->UnloadMap(this);
+            instanceTree->second->UnloadMapTile(x, y, this);
             if (instanceTree->second->numLoadedTiles() == 0)
             {
                 delete instanceTree->second;
@@ -148,12 +167,22 @@ namespace VMAP
         }
     }
 
-    void VMapManager2::unloadMap(unsigned int mapId, int x, int y)
+    void VMapManager2::unloadMap(unsigned int mapId)
+    {
+        auto childMaps = iChildMapData.find(mapId);
+        if (childMaps != iChildMapData.end())
+            for (uint32 childMapId : childMaps->second)
+                unloadSingleMap(childMapId);
+
+        unloadSingleMap(mapId);
+    }
+
+    void VMapManager2::unloadSingleMap(uint32 mapId)
     {
-        InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
+        auto instanceTree = iInstanceMapTrees.find(mapId);
         if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
         {
-            instanceTree->second->UnloadMapTile(x, y, this);
+            instanceTree->second->UnloadMap(this);
             if (instanceTree->second->numLoadedTiles() == 0)
             {
                 delete instanceTree->second;
@@ -167,15 +196,13 @@ namespace VMAP
         if (!isLineOfSightCalcEnabled() || IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
             return true;
 
-        InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
+        auto instanceTree = GetMapTree(mapId);
         if (instanceTree != iInstanceMapTrees.end())
         {
             Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
             Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
             if (pos1 != pos2)
-            {
                 return instanceTree->second->isInLineOfSight(pos1, pos2);
-            }
         }
 
         return true;
@@ -189,7 +216,7 @@ namespace VMAP
     {
         if (isLineOfSightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
         {
-            InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
+            auto instanceTree = GetMapTree(mapId);
             if (instanceTree != iInstanceMapTrees.end())
             {
                 Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
@@ -219,7 +246,7 @@ namespace VMAP
     {
         if (isHeightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_HEIGHT))
         {
-            InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
+            auto instanceTree = GetMapTree(mapId);
             if (instanceTree != iInstanceMapTrees.end())
             {
                 Vector3 pos = convertPositionToInternalRep(x, y, z);
@@ -238,7 +265,7 @@ namespace VMAP
     {
         if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_AREAFLAG))
         {
-            InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
+            auto instanceTree = GetMapTree(mapId);
             if (instanceTree != iInstanceMapTrees.end())
             {
                 Vector3 pos = convertPositionToInternalRep(x, y, z);
@@ -256,7 +283,7 @@ namespace VMAP
     {
         if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LIQUIDSTATUS))
         {
-            InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
+            auto instanceTree = GetMapTree(mapId);
             if (instanceTree != iInstanceMapTrees.end())
             {
                 LocationInfo info;
@@ -279,12 +306,21 @@ 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
         std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
 
-        ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
+        auto model = iLoadedModelFiles.find(filename);
         if (model == iLoadedModelFiles.end())
         {
             WorldModel* worldmodel = new WorldModel();
@@ -307,7 +343,7 @@ namespace VMAP
         //! Critical section, thread safe access to iLoadedModelFiles
         std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
 
-        ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
+        auto model = iLoadedModelFiles.find(filename);
         if (model == iLoadedModelFiles.end())
         {
             VMAP_ERROR_LOG("misc", "VMapManager2: trying to unload non-loaded file '%s'", filename.c_str());
@@ -323,7 +359,7 @@ namespace VMAP
 
     bool VMapManager2::existsMap(const char* basePath, unsigned int mapId, int x, int y)
     {
-        return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y);
+        return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y, this);
     }
 
     void VMapManager2::getInstanceMapTree(InstanceTreeMap &instanceMapTree)
@@ -331,4 +367,13 @@ namespace VMAP
         instanceMapTree = iInstanceMapTrees;
     }
 
+    int32 VMapManager2::getParentMapId(uint32 mapId) const
+    {
+        auto itr = iParentMapData.find(mapId);
+        if (itr != iParentMapData.end())
+            return int32(itr->second);
+
+        return -1;
+    }
+
 } // namespace VMAP
diff --git a/src/common/Collision/Management/VMapManager2.h b/src/common/Collision/Management/VMapManager2.h
index ba48c8cae34..fb23f6e239f 100644
--- a/src/common/Collision/Management/VMapManager2.h
+++ b/src/common/Collision/Management/VMapManager2.h
@@ -81,13 +81,12 @@ namespace VMAP
             // Tree to check collision
             ModelFileMap iLoadedModelFiles;
             InstanceTreeMap iInstanceMapTrees;
+            std::unordered_map<uint32, std::vector<uint32>> iChildMapData;
+            std::unordered_map<uint32, uint32> iParentMapData;
             bool thread_safe_environment;
             // Mutex for iLoadedModelFiles
             std::mutex LoadedModelFilesLock;
 
-            bool _loadMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY);
-            /* void _unloadMap(uint32 pMapId, uint32 x, uint32 y); */
-
             static uint32 GetLiquidFlagsDummy(uint32) { return 0; }
             static bool IsVMAPDisabledForDummy(uint32 /*entry*/, uint8 /*flags*/) { return false; }
 
@@ -99,13 +98,18 @@ namespace VMAP
             static std::string getMapFileName(unsigned int mapId);
 
             VMapManager2();
-            ~VMapManager2(void);
+            ~VMapManager2();
+
+            void InitializeThreadUnsafe(std::unordered_map<uint32, std::vector<uint32>> const& mapData);
 
-            void InitializeThreadUnsafe(const std::vector<uint32>& mapIds);
             int loadMap(const char* pBasePath, unsigned int mapId, int x, int y) override;
+            bool loadSingleMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY);
 
             void unloadMap(unsigned int mapId, int x, int y) override;
+            void unloadSingleMap(uint32 mapId, int x, int y);
+
             void unloadMap(unsigned int mapId) override;
+            void unloadSingleMap(uint32 mapId);
 
             bool isInLineOfSight(unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2) override ;
             /**
@@ -119,6 +123,8 @@ 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);
 
@@ -131,6 +137,8 @@ namespace VMAP
 
             void getInstanceMapTree(InstanceTreeMap &instanceMapTree);
 
+            int32 getParentMapId(uint32 mapId) const;
+
             typedef uint32(*GetLiquidFlagsFn)(uint32 liquidType);
             GetLiquidFlagsFn GetLiquidFlagsPtr;
 
diff --git a/src/common/Collision/Maps/MapTree.cpp b/src/common/Collision/Maps/MapTree.cpp
index 894705c56cc..55ff1711a54 100644
--- a/src/common/Collision/Maps/MapTree.cpp
+++ b/src/common/Collision/Maps/MapTree.cpp
@@ -237,9 +237,29 @@ namespace VMAP
         return(height);
     }
 
+    StaticMapTree::TileFileOpenResult StaticMapTree::OpenMapTileFile(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
+    {
+        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);
+            if (parentMapId != -1)
+            {
+                result.Name = basePath + getTileFileName(parentMapId, tileX, tileY);
+                result.File = fopen(result.Name.c_str(), "rb");
+                result.IsPrimary = false;
+            }
+        }
+
+        return result;
+    }
+
     //=========================================================
 
-    bool StaticMapTree::CanLoadMap(const std::string &vmapPath, uint32 mapID, uint32 tileX, uint32 tileY)
+    bool StaticMapTree::CanLoadMap(const std::string &vmapPath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
     {
         std::string basePath = vmapPath;
         if (basePath.length() > 0 && basePath[basePath.length()-1] != '/' && basePath[basePath.length()-1] != '\\')
@@ -259,8 +279,7 @@ namespace VMAP
         }
         if (tiled)
         {
-            std::string tilefile = basePath + getTileFileName(mapID, tileX, tileY);
-            FILE* tf = fopen(tilefile.c_str(), "rb");
+            FILE* tf = OpenMapTileFile(basePath, mapID, tileX, tileY, vm).File;
             if (!tf)
                 success = false;
             else
@@ -321,6 +340,22 @@ namespace VMAP
             }
         }
 
+        if (success)
+        {
+            success = readChunk(rf, chunk, "SIDX", 4);
+            uint32 spawnIndicesSize = 0;
+            uint32 spawnId;
+            uint32 spawnIndex;
+            if (success && fread(&spawnIndicesSize, sizeof(uint32), 1, rf) != 1) success = false;
+            for (uint32 i = 0; i < spawnIndicesSize && success; ++i)
+            {
+                if (fread(&spawnId, sizeof(uint32), 1, rf) == 1 && fread(&spawnIndex, sizeof(uint32), 1, rf) == 1)
+                    iSpawnIndices[spawnId] = spawnIndex;
+                else
+                    success = false;
+            }
+        }
+
         fclose(rf);
         return success;
     }
@@ -337,6 +372,7 @@ namespace VMAP
         }
         iLoadedSpawns.clear();
         iLoadedTiles.clear();
+        iLoadedPrimaryTiles.clear();
     }
 
     //=========================================================
@@ -357,22 +393,21 @@ namespace VMAP
         }
         bool result = true;
 
-        std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
-        FILE* tf = fopen(tilefile.c_str(), "rb");
-        if (tf)
+        TileFileOpenResult fileResult = OpenMapTileFile(iBasePath, iMapID, tileX, tileY, vm);
+        if (fileResult.File)
         {
             char chunk[8];
 
-            if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
+            if (!readChunk(fileResult.File, chunk, VMAP_MAGIC, 8))
                 result = false;
             uint32 numSpawns = 0;
-            if (result && fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
+            if (result && fread(&numSpawns, sizeof(uint32), 1, fileResult.File) != 1)
                 result = false;
             for (uint32 i=0; i<numSpawns && result; ++i)
             {
                 // read model spawns
                 ModelSpawn spawn;
-                result = ModelSpawn::readFromFile(tf, spawn);
+                result = ModelSpawn::readFromFile(fileResult.File, spawn);
                 if (result)
                 {
                     // acquire model instance
@@ -381,15 +416,15 @@ namespace VMAP
                         VMAP_ERROR_LOG("misc", "StaticMapTree::LoadMapTile() : could not acquire WorldModel pointer [%u, %u]", tileX, tileY);
 
                     // update tree
-                    uint32 referencedVal;
-
-                    if (fread(&referencedVal, sizeof(uint32), 1, tf) == 1)
+                    auto spawnIndex = iSpawnIndices.find(spawn.ID);
+                    if (spawnIndex != iSpawnIndices.end())
                     {
+                        uint32 referencedVal = spawnIndex->second;
                         if (!iLoadedSpawns.count(referencedVal))
                         {
-                            if (referencedVal > iNTreeValues)
+                            if (referencedVal >= iNTreeValues)
                             {
-                                VMAP_ERROR_LOG("maps", "StaticMapTree::LoadMapTile() : invalid tree element (%u/%u) referenced in tile %s", referencedVal, iNTreeValues, tilefile.c_str());
+                                VMAP_ERROR_LOG("maps", "StaticMapTree::LoadMapTile() : invalid tree element (%u/%u) referenced in tile %s", referencedVal, iNTreeValues, fileResult.Name.c_str());
                                 continue;
                             }
 
@@ -412,7 +447,9 @@ namespace VMAP
                 }
             }
             iLoadedTiles[packTileID(tileX, tileY)] = true;
-            fclose(tf);
+            if (fileResult.IsPrimary)
+                iLoadedPrimaryTiles.emplace_back(tileX, tileY);
+            fclose(fileResult.File);
         }
         else
             iLoadedTiles[packTileID(tileX, tileY)] = false;
@@ -434,34 +471,33 @@ namespace VMAP
         }
         if (tile->second) // file associated with tile
         {
-            std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
-            FILE* tf = fopen(tilefile.c_str(), "rb");
-            if (tf)
+            TileFileOpenResult fileResult = OpenMapTileFile(iBasePath, iMapID, tileX, tileY, vm);
+            if (fileResult.File)
             {
                 bool result=true;
                 char chunk[8];
-                if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
+                if (!readChunk(fileResult.File, chunk, VMAP_MAGIC, 8))
                     result = false;
                 uint32 numSpawns;
-                if (fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
+                if (fread(&numSpawns, sizeof(uint32), 1, fileResult.File) != 1)
                     result = false;
                 for (uint32 i=0; i<numSpawns && result; ++i)
                 {
                     // read model spawns
                     ModelSpawn spawn;
-                    result = ModelSpawn::readFromFile(tf, spawn);
+                    result = ModelSpawn::readFromFile(fileResult.File, spawn);
                     if (result)
                     {
                         // release model instance
                         vm->releaseModelInstance(spawn.name);
 
                         // update tree
-                        uint32 referencedNode;
-
-                        if (fread(&referencedNode, sizeof(uint32), 1, tf) != 1)
+                        auto spawnIndex = iSpawnIndices.find(spawn.ID);
+                        if (spawnIndex == iSpawnIndices.end())
                             result = false;
                         else
                         {
+                            uint32 referencedNode = spawnIndex->second;
                             if (!iLoadedSpawns.count(referencedNode))
                             VMAP_ERROR_LOG("misc", "StaticMapTree::UnloadMapTile() : trying to unload non-referenced model '%s' (ID:%u)", spawn.name.c_str(), spawn.ID);
                             else if (--iLoadedSpawns[referencedNode] == 0)
@@ -472,10 +508,12 @@ namespace VMAP
                         }
                     }
                 }
-                fclose(tf);
+                fclose(fileResult.File);
             }
         }
         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));
     }
@@ -485,4 +523,13 @@ 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 a15f328fc76..bf991c547c9 100644
--- a/src/common/Collision/Maps/MapTree.h
+++ b/src/common/Collision/Maps/MapTree.h
@@ -47,23 +47,33 @@ namespace VMAP
             BIH iTree;
             ModelInstance* iTreeValues; // the tree entries
             uint32 iNTreeValues;
+            std::unordered_map<uint32, uint32> iSpawnIndices;
 
             // Store all the map tile idents that are loaded for that map
             // some maps are not splitted into tiles and we have to make sure, not removing the map before all tiles are removed
             // empty tiles have no tile file, hence map with bool instead of just a set (consistency check)
             loadedTileMap iLoadedTiles;
+            std::vector<std::pair<int32, int32>> iLoadedPrimaryTiles;
             // stores <tree_index, reference_count> to invalidate tree values, unload map, and to be able to report errors
             loadedSpawnMap iLoadedSpawns;
             std::string iBasePath;
 
+            struct TileFileOpenResult
+            {
+                FILE* File;
+                std::string Name;
+                bool IsPrimary;
+            };
+
         private:
+            static TileFileOpenResult OpenMapTileFile(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
             bool getIntersectionTime(const G3D::Ray& pRay, float &pMaxDist, bool pStopAtFirstHit) const;
             //bool containsLoadedMapTile(unsigned int pTileIdent) const { return(iLoadedMapTiles.containsKey(pTileIdent)); }
         public:
             static std::string getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY);
             static uint32 packTileID(uint32 tileX, uint32 tileY) { return tileX<<16 | tileY; }
-            static void unpackTileID(uint32 ID, uint32 &tileX, uint32 &tileY) { tileX = ID>>16; tileY = ID&0xFF; }
-            static bool CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY);
+            static void unpackTileID(uint32 ID, uint32 &tileX, uint32 &tileY) { tileX = ID >> 16; tileY = ID & 0xFF; }
+            static bool CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
 
             StaticMapTree(uint32 mapID, const std::string &basePath);
             ~StaticMapTree();
@@ -82,6 +92,8 @@ 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/common/Collision/Maps/TileAssembler.cpp b/src/common/Collision/Maps/TileAssembler.cpp
index dd096850d3f..d9133301223 100644
--- a/src/common/Collision/Maps/TileAssembler.cpp
+++ b/src/common/Collision/Maps/TileAssembler.cpp
@@ -84,7 +84,7 @@ namespace VMAP
                 if (entry->second.flags & MOD_M2)
                 {
                     if (!calculateTransformedBound(entry->second))
-                        break;
+                        continue;
                 }
                 else if (entry->second.flags & MOD_WORLDSPAWN) // WMO maps and terrain maps use different origin, so we need to adapt :/
                 {
@@ -92,7 +92,7 @@ namespace VMAP
                     //entry->second.iPos += Vector3(533.33333f*32, 533.33333f*32, 0.f);
                     entry->second.iBound = entry->second.iBound + Vector3(533.33333f*32, 533.33333f*32, 0.f);
                 }
-                mapSpawns.push_back(&(entry->second));
+                mapSpawns.push_back(&entry->second);
                 spawnedModelFiles.insert(entry->second.name);
             }
 
@@ -110,9 +110,6 @@ namespace VMAP
             }
 
             // ===> possibly move this code to StaticMapTree class
-            std::map<uint32, uint32> modelNodeIdx;
-            for (uint32 i=0; i<mapSpawns.size(); ++i)
-                modelNodeIdx.insert(pair<uint32, uint32>(mapSpawns[i]->ID, i));
 
             // write map tree file
             std::stringstream mapfilename;
@@ -139,7 +136,17 @@ namespace VMAP
 
             for (TileMap::iterator glob=globalRange.first; glob != globalRange.second && success; ++glob)
             {
-                success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second]);
+                success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second.Id]);
+            }
+
+            // spawn id to index map
+            if (success && fwrite("SIDX", 4, 1, mapfile) != 1) success = false;
+            uint32 mapSpawnsSize = mapSpawns.size();
+            if (success && fwrite(&mapSpawnsSize, sizeof(uint32), 1, mapfile) != 1) success = false;
+            for (uint32 i = 0; i < mapSpawnsSize; ++i)
+            {
+                if (success && fwrite(&mapSpawns[i]->ID, sizeof(uint32), 1, mapfile) != 1) success = false;
+                if (success && fwrite(&i, sizeof(uint32), 1, mapfile) != 1) success = false;
             }
 
             fclose(mapfile);
@@ -151,8 +158,9 @@ namespace VMAP
             TileMap::iterator tile;
             for (tile = tileEntries.begin(); tile != tileEntries.end(); ++tile)
             {
-                const ModelSpawn &spawn = map_iter->second->UniqueEntries[tile->second];
-                if (spawn.flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
+                if (tile->second.Flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
+                    continue;
+                if (tile->second.Flags & MOD_PARENT_SPAWN) // tile belongs to parent map
                     continue;
                 uint32 nSpawns = tileEntries.count(tile->first);
                 std::stringstream tilefilename;
@@ -172,16 +180,12 @@ namespace VMAP
                     {
                         if (s)
                             ++tile;
-                        const ModelSpawn &spawn2 = map_iter->second->UniqueEntries[tile->second];
+                        const ModelSpawn &spawn2 = map_iter->second->UniqueEntries[tile->second.Id];
                         success = success && ModelSpawn::writeToFile(tilefile, spawn2);
-                        // MapTree nodes to update when loading tile:
-                        std::map<uint32, uint32>::iterator nIdx = modelNodeIdx.find(spawn2.ID);
-                        if (success && fwrite(&nIdx->second, sizeof(uint32), 1, tilefile) != 1) success = false;
                     }
                     fclose(tilefile);
                 }
             }
-            // break; //test, extract only first map; TODO: remvoe this line
         }
 
         // add an object models, listed in temp_gameobject_models file
@@ -239,9 +243,9 @@ namespace VMAP
                 printf("spawning Map %u\n", mapID);
                 mapData[mapID] = current = new MapSpawns();
             }
-            else current = (*map_iter).second;
+            else current = map_iter->second;
             current->UniqueEntries.insert(pair<uint32, ModelSpawn>(spawn.ID, spawn));
-            current->TileEntries.insert(pair<uint32, uint32>(StaticMapTree::packTileID(tileX, tileY), spawn.ID));
+            current->TileEntries.insert(pair<uint32, TileSpawn>(StaticMapTree::packTileID(tileX, tileY), TileSpawn{ spawn.ID, spawn.flags }));
         }
         bool success = (ferror(dirf) == 0);
         fclose(dirf);
diff --git a/src/common/Collision/Maps/TileAssembler.h b/src/common/Collision/Maps/TileAssembler.h
index f370bb638ba..8c3b3f5b88d 100644
--- a/src/common/Collision/Maps/TileAssembler.h
+++ b/src/common/Collision/Maps/TileAssembler.h
@@ -52,8 +52,14 @@ namespace VMAP
             void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; }
     };
 
+    struct TileSpawn
+    {
+        uint32 Id;
+        uint32 Flags;
+    };
+
     typedef std::map<uint32, ModelSpawn> UniqueEntryMap;
-    typedef std::multimap<uint32, uint32> TileMap;
+    typedef std::multimap<uint32, TileSpawn> TileMap;
 
     struct TC_COMMON_API MapSpawns
     {
diff --git a/src/common/Collision/Models/ModelInstance.h b/src/common/Collision/Models/ModelInstance.h
index 4160fd0c879..1edf3b0f442 100644
--- a/src/common/Collision/Models/ModelInstance.h
+++ b/src/common/Collision/Models/ModelInstance.h
@@ -35,8 +35,9 @@ namespace VMAP
     enum ModelFlags
     {
         MOD_M2 = 1,
-        MOD_WORLDSPAWN = 1<<1,
-        MOD_HAS_BOUND = 1<<2
+        MOD_WORLDSPAWN = 1 << 1,
+        MOD_HAS_BOUND = 1 << 2,
+        MOD_PARENT_SPAWN = 1 << 3
     };
 
     class TC_COMMON_API ModelSpawn
diff --git a/src/common/Collision/VMapDefinitions.h b/src/common/Collision/VMapDefinitions.h
index 5410eb2130c..c8f3f2fdbe3 100644
--- a/src/common/Collision/VMapDefinitions.h
+++ b/src/common/Collision/VMapDefinitions.h
@@ -25,8 +25,8 @@
 
 namespace VMAP
 {
-    const char VMAP_MAGIC[] = "VMAP_4.5";
-    const char RAW_VMAP_MAGIC[] = "VMAP045";                // used in extracted vmap files with raw data
+    const char VMAP_MAGIC[] = "VMAP_4.6";
+    const char RAW_VMAP_MAGIC[] = "VMAP046";                // used in extracted vmap files with raw data
     const char GAMEOBJECT_MODELS[] = "GameObjectModels.dtree";
 
     // defined in TileAssembler.cpp currently...
diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp
index 65f5f9bd59c..125e9036e64 100644
--- a/src/server/game/World/World.cpp
+++ b/src/server/game/World/World.cpp
@@ -1576,11 +1576,17 @@ void World::SetInitialWorldSettings()
     sTaxiPathGraph.Initialize();
 
     std::vector<uint32> mapIds;
+    std::unordered_map<uint32, std::vector<uint32>> mapData;
     for (MapEntry const* mapEntry : sMapStore)
+    {
         mapIds.push_back(mapEntry->ID);
+        mapData.emplace(std::piecewise_construct, std::forward_as_tuple(mapEntry->ID), std::forward_as_tuple());
+        if (mapEntry->ParentMapID != -1)
+            mapData[mapEntry->ParentMapID].push_back(mapEntry->ID);
+    }
 
     if (VMAP::VMapManager2* vmmgr2 = dynamic_cast<VMAP::VMapManager2*>(VMAP::VMapFactory::createOrGetVMapManager()))
-        vmmgr2->InitializeThreadUnsafe(mapIds);
+        vmmgr2->InitializeThreadUnsafe(mapData);
 
     MMAP::MMapManager* mmmgr = MMAP::MMapFactory::createOrGetMMapManager();
     mmmgr->InitializeThreadUnsafe(mapIds);
diff --git a/src/tools/mmaps_generator/MapBuilder.cpp b/src/tools/mmaps_generator/MapBuilder.cpp
index a0f99ec6e5d..251df44dfa3 100644
--- a/src/tools/mmaps_generator/MapBuilder.cpp
+++ b/src/tools/mmaps_generator/MapBuilder.cpp
@@ -216,7 +216,7 @@ namespace MMAP
             _workerThreads.push_back(std::thread(&MapBuilder::WorkerThread, this));
         }
 
-        m_tiles.sort([](MapTiles a, MapTiles b)
+        m_tiles.sort([](MapTiles const& a, MapTiles const& b)
         {
             return a.m_tiles->size() > b.m_tiles->size();
         });
diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp
index e70619f8d48..76292c33a1f 100644
--- a/src/tools/vmap4_extractor/adtfile.cpp
+++ b/src/tools/vmap4_extractor/adtfile.cpp
@@ -79,26 +79,33 @@ char* GetExtension(char* FileName)
 
 extern CASC::StorageHandle CascStorage;
 
-ADTFile::ADTFile(char* filename) : ADT(CascStorage, filename, false), nWMO(0), nMDX(0)
+ADTFile::ADTFile(char* filename, bool cache) : ADT(CascStorage, filename, false), nWMO(0), nMDX(0)
 {
     Adtfilename.append(filename);
+    cacheable = cache;
+    dirfileCache = nullptr;
 }
 
-bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
+bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId)
 {
+    if (dirfileCache)
+        return initFromCache(map_num, tileX, tileY, originalMapId);
+
     if (ADT.isEof())
         return false;
 
     uint32 size;
     std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
-    FILE *dirfile;
-    dirfile = fopen(dirname.c_str(), "ab");
+    FILE* dirfile = fopen(dirname.c_str(), "ab");
     if(!dirfile)
     {
         printf("Can't open dirfile!'%s'\n", dirname.c_str());
         return false;
     }
 
+    if (cacheable)
+        dirfileCache = new std::vector<ADTOutputCache>();
+
     while (!ADT.isEof())
     {
         char fourcc[5];
@@ -173,7 +180,7 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
                 {
                     uint32 id;
                     ADT.read(&id, 4);
-                    ModelInstance inst(ADT, ModelInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
+                    ModelInstance inst(ADT, ModelInstanceNames[id].c_str(), map_num, tileX, tileY, originalMapId, dirfile, dirfileCache);
                 }
 
                 ModelInstanceNames.clear();
@@ -188,7 +195,7 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
                 {
                     uint32 id;
                     ADT.read(&id, 4);
-                    WMOInstance inst(ADT, WmoInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
+                    WMOInstance inst(ADT, WmoInstanceNames[id].c_str(), map_num, tileX, tileY, originalMapId, dirfile, dirfileCache);
                 }
 
                 WmoInstanceNames.clear();
@@ -204,7 +211,37 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
     return true;
 }
 
+bool ADTFile::initFromCache(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId)
+{
+    if (dirfileCache->empty())
+        return true;
+
+    std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
+    FILE* dirfile = fopen(dirname.c_str(), "ab");
+    if (!dirfile)
+    {
+        printf("Can't open dirfile!'%s'\n", dirname.c_str());
+        return false;
+    }
+
+    for (ADTOutputCache const& cached : *dirfileCache)
+    {
+        fwrite(&map_num, sizeof(uint32), 1, dirfile);
+        fwrite(&tileX, sizeof(uint32), 1, dirfile);
+        fwrite(&tileY, sizeof(uint32), 1, dirfile);
+        uint32 flags = cached.Flags;
+        if (map_num != originalMapId)
+            flags |= MOD_PARENT_SPAWN;
+        fwrite(&flags, sizeof(uint32), 1, dirfile);
+        fwrite(cached.Data.data(), cached.Data.size(), 1, dirfile);
+    }
+
+    fclose(dirfile);
+    return true;
+}
+
 ADTFile::~ADTFile()
 {
     ADT.close();
+    delete dirfileCache;
 }
diff --git a/src/tools/vmap4_extractor/adtfile.h b/src/tools/vmap4_extractor/adtfile.h
index b388c8a581f..efe35647147 100644
--- a/src/tools/vmap4_extractor/adtfile.h
+++ b/src/tools/vmap4_extractor/adtfile.h
@@ -106,31 +106,28 @@ struct MapChunkHeader
     uint32 effectId;
 };
 
+struct ADTOutputCache
+{
+    uint32 Flags;
+    std::vector<uint8> Data;
+};
 
 class ADTFile
 {
 private:
-    //size_t mcnk_offsets[256], mcnk_sizes[256];
     CASCFile ADT;
-    //mcell Mcell;
     std::string Adtfilename;
+    bool cacheable;
+    std::vector<ADTOutputCache>* dirfileCache;
 public:
-    ADTFile(char* filename);
+    ADTFile(char* filename, bool cache);
     ~ADTFile();
     int nWMO;
     int nMDX;
     std::vector<std::string> WmoInstanceNames;
     std::vector<std::string> ModelInstanceNames;
-    bool init(uint32 map_num, uint32 tileX, uint32 tileY);
-    //void LoadMapChunks();
-
-    //uint32 wmo_count;
-/*
-    const mcell& Getmcell() const
-    {
-        return Mcell;
-    }
-*/
+    bool init(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId);
+    bool initFromCache(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId);
 };
 
 char const* GetPlainName(char const* FileName);
diff --git a/src/tools/vmap4_extractor/model.cpp b/src/tools/vmap4_extractor/model.cpp
index 12d7ee0ab2d..7ba041ef95e 100644
--- a/src/tools/vmap4_extractor/model.cpp
+++ b/src/tools/vmap4_extractor/model.cpp
@@ -19,6 +19,7 @@
 #include "vmapexport.h"
 #include "model.h"
 #include "wmo.h"
+#include "adtfile.h"
 #include "cascfile.h"
 #include <cassert>
 #include <algorithm>
@@ -154,7 +155,7 @@ Vec3D fixCoordSystem2(Vec3D v)
     return Vec3D(v.x, v.z, v.y);
 }
 
-ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE *pDirfile)
+ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache)
     : id(0), scale(0), flags(0)
 {
     float ff[3];
@@ -190,6 +191,8 @@ ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapI
     uint32 tcflags = MOD_M2;
     if (tileX == 65 && tileY == 65)
         tcflags |= MOD_WORLDSPAWN;
+    if (mapID != originalMapId)
+        tcflags |= MOD_PARENT_SPAWN;
 
     //write mapID, tileX, tileY, Flags, ID, Pos, Rot, Scale, name
     fwrite(&mapID, sizeof(uint32), 1, pDirfile);
@@ -205,6 +208,34 @@ ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapI
     fwrite(&nlen, sizeof(uint32), 1, pDirfile);
     fwrite(ModelInstName, sizeof(char), nlen, pDirfile);
 
+    if (dirfileCache)
+    {
+        dirfileCache->emplace_back();
+        ADTOutputCache& cacheModelData = dirfileCache->back();
+        cacheModelData.Flags = tcflags & ~MOD_PARENT_SPAWN;
+        cacheModelData.Data.resize(
+            sizeof(uint16) +    // adtId
+            sizeof(uint32) +    // id
+            sizeof(float) * 3 + // pos
+            sizeof(float) * 3 + // rot
+            sizeof(float) +     // sc
+            sizeof(uint32) +    // nlen
+            nlen);              // ModelInstName
+
+        uint8* cacheData = cacheModelData.Data.data();
+#define CACHE_WRITE(value, size, count, dest) memcpy(dest, value, size * count); dest += size * count;
+
+        CACHE_WRITE(&adtId, sizeof(uint16), 1, cacheData);
+        CACHE_WRITE(&id, sizeof(uint32), 1, cacheData);
+        CACHE_WRITE(&pos, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&rot, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&sc, sizeof(float), 1, cacheData);
+        CACHE_WRITE(&nlen, sizeof(uint32), 1, cacheData);
+        CACHE_WRITE(ModelInstName, sizeof(char), nlen, cacheData);
+
+#undef CACHE_WRITE
+    }
+
     /* int realx1 = (int) ((float) pos.x / 533.333333f);
     int realy1 = (int) ((float) pos.z / 533.333333f);
     int realx2 = (int) ((float) pos.x / 533.333333f);
diff --git a/src/tools/vmap4_extractor/model.h b/src/tools/vmap4_extractor/model.h
index 312c1c8cf12..8e8a8c899d6 100644
--- a/src/tools/vmap4_extractor/model.h
+++ b/src/tools/vmap4_extractor/model.h
@@ -24,6 +24,7 @@
 #include <vector>
 
 class CASCFile;
+struct ADTOutputCache;
 
 Vec3D fixCoordSystem(Vec3D v);
 
@@ -59,7 +60,7 @@ public:
     float sc;
 
     ModelInstance() : id(0), scale(0), flags(0), sc(0.0f) {}
-    ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile);
+    ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache);
 
 };
 
diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp
index 3f68a0c9fe4..80f10fd2af3 100644
--- a/src/tools/vmap4_extractor/vmapexport.cpp
+++ b/src/tools/vmap4_extractor/vmapexport.cpp
@@ -33,6 +33,7 @@
 #include <list>
 #include <map>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 #include <cstdio>
 #include <cerrno>
@@ -54,14 +55,14 @@
 
 CASC::StorageHandle CascStorage;
 
-typedef struct
+struct map_info
 {
     char name[64];
-    unsigned int id;
-}map_id;
+    int32 parent_id;
+};
 
-std::vector<map_id> map_ids;
-uint32 map_count;
+std::map<uint32, map_info> map_ids;
+std::unordered_set<uint32> maps_that_are_parents;
 boost::filesystem::path input_path;
 bool preciseVectorData = false;
 
@@ -108,7 +109,7 @@ struct MapLoadInfo
 
 //static const char * szWorkDirMaps = ".\\Maps";
 const char* szWorkDirWmo = "./Buildings";
-const char* szRawVMAPMagic = "VMAP045";
+const char* szRawVMAPMagic = "VMAP046";
 
 #define CASC_LOCALES_COUNT 17
 char const* CascLocaleNames[CASC_LOCALES_COUNT] =
@@ -274,26 +275,49 @@ bool ExtractSingleWmo(std::string& fname)
 
 void ParsMapFiles()
 {
-    char fn[512];
-    //char id_filename[64];
-    char id[10];
-    for (unsigned int i = 0; i < map_ids.size(); ++i)
+    std::unordered_map<uint32, WDTFile> wdts;
+    auto getWDT = [&wdts](uint32 mapId) -> WDTFile*
+    {
+        auto itr = wdts.find(mapId);
+        if (itr == wdts.end())
+        {
+            char fn[512];
+            char* name = map_ids[mapId].name;
+            sprintf(fn, "World\\Maps\\%s\\%s.wdt", name, name);
+            itr = wdts.emplace(std::piecewise_construct, std::forward_as_tuple(mapId), std::forward_as_tuple(fn, name, maps_that_are_parents.count(mapId) > 0)).first;
+            if (!itr->second.init(mapId))
+            {
+                wdts.erase(itr);
+                return nullptr;
+            }
+        }
+
+        return &itr->second;
+    };
+
+    for (auto itr = map_ids.begin(); itr != map_ids.end(); ++itr)
     {
-        sprintf(id, "%04u", map_ids[i].id);
-        sprintf(fn,"World\\Maps\\%s\\%s.wdt", map_ids[i].name, map_ids[i].name);
-        WDTFile WDT(fn,map_ids[i].name);
-        if(WDT.init(id, map_ids[i].id))
+        if (WDTFile* WDT = getWDT(itr->first))
         {
-            printf("Processing Map %u\n[", map_ids[i].id);
-            for (int x=0; x<64; ++x)
+            WDTFile* parentWDT = itr->second.parent_id >= 0 ? getWDT(itr->second.parent_id) : nullptr;
+            printf("Processing Map %u\n[", itr->first);
+            for (int32 x = 0; x < 64; ++x)
             {
-                for (int y=0; y<64; ++y)
+                for (int32 y = 0; y < 64; ++y)
                 {
-                    if (ADTFile *ADT = WDT.GetMap(x,y))
+                    bool success = false;
+                    if (ADTFile* ADT = WDT->GetMap(x, y))
+                    {
+                        success = ADT->init(itr->first, x, y, itr->first);
+                        WDT->FreeADT(ADT);
+                    }
+                    if (!success && parentWDT)
                     {
-                        //sprintf(id_filename,"%02u %02u %04u",x,y,map_ids[i].id);//!!!!!!!!!
-                        ADT->init(map_ids[i].id, x, y);
-                        delete ADT;
+                        if (ADTFile* ADT = parentWDT->GetMap(x, y))
+                        {
+                            ADT->init(itr->first, x, y, itr->second.parent_id);
+                            parentWDT->FreeADT(ADT);
+                        }
                     }
                 }
                 printf("#");
@@ -398,7 +422,7 @@ int main(int argc, char ** argv)
     Trinity::Banner::Show("VMAP data extractor", [](char const* text) { printf("%s\n", text); }, nullptr);
 
     bool success = true;
-    const char *versionString = "V4.03 2015_05";
+    const char *versionString = "V4.06 2018_02";
 
     // Use command line arguments, when some
     if (!processArgv(argc, argv, versionString))
@@ -480,36 +504,35 @@ int main(int argc, char ** argv)
             exit(1);
         }
 
-        map_ids.resize(db2.GetRecordCount());
-        std::unordered_map<uint32, uint32> idToIndex;
         for (uint32 x = 0; x < db2.GetRecordCount(); ++x)
         {
             DB2Record record = db2.GetRecord(x);
-            map_ids[x].id = record.GetId();
+            map_info& m = map_ids[record.GetId()];
 
             const char* map_name = record.GetString("Directory");
-            size_t max_map_name_length = sizeof(map_ids[x].name);
+            size_t max_map_name_length = sizeof(m.name);
             if (strlen(map_name) >= max_map_name_length)
             {
                 printf("Fatal error: Map name too long!\n");
                 exit(1);
             }
 
-            strncpy(map_ids[x].name, map_name, max_map_name_length);
-            map_ids[x].name[max_map_name_length - 1] = '\0';
-            idToIndex[map_ids[x].id] = x;
+            strncpy(m.name, map_name, max_map_name_length);
+            m.name[max_map_name_length - 1] = '\0';
+            m.parent_id = int16(record.GetUInt16("ParentMapID"));
+            if (m.parent_id >= 0)
+                maps_that_are_parents.insert(m.parent_id);
         }
 
         for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x)
         {
             DB2RecordCopy copy = db2.GetRecordCopy(x);
-            auto itr = idToIndex.find(copy.SourceRowId);
-            if (itr != idToIndex.end())
+            auto itr = map_ids.find(copy.SourceRowId);
+            if (itr != map_ids.end())
             {
-                map_id id;
-                id.id = copy.NewRowId;
-                strcpy(id.name, map_ids[itr->second].name);
-                map_ids.push_back(id);
+                map_info& id = map_ids[copy.NewRowId];
+                strcpy(id.name, itr->second.name);
+                id.parent_id = itr->second.parent_id;
             }
         }
 
diff --git a/src/tools/vmap4_extractor/vmapexport.h b/src/tools/vmap4_extractor/vmapexport.h
index a73d259d52b..c798fb496ba 100644
--- a/src/tools/vmap4_extractor/vmapexport.h
+++ b/src/tools/vmap4_extractor/vmapexport.h
@@ -24,8 +24,9 @@
 enum ModelFlags
 {
     MOD_M2 = 1,
-    MOD_WORLDSPAWN = 1<<1,
-    MOD_HAS_BOUND = 1<<2
+    MOD_WORLDSPAWN = 1 << 1,
+    MOD_HAS_BOUND = 1 << 2,
+    MOD_PARENT_SPAWN = 1 << 3
 };
 
 extern const char * szWorkDirWmo;
diff --git a/src/tools/vmap4_extractor/wdtfile.cpp b/src/tools/vmap4_extractor/wdtfile.cpp
index c94775d7b0f..1f10e7883b0 100644
--- a/src/tools/vmap4_extractor/wdtfile.cpp
+++ b/src/tools/vmap4_extractor/wdtfile.cpp
@@ -19,6 +19,7 @@
 #include "vmapexport.h"
 #include "wdtfile.h"
 #include "adtfile.h"
+#include "Common.h"
 #include <cstdio>
 
 char * wdtGetPlainName(char * FileName)
@@ -32,40 +33,45 @@ char * wdtGetPlainName(char * FileName)
 
 extern CASC::StorageHandle CascStorage;
 
-WDTFile::WDTFile(char* file_name, char* file_name1):WDT(CascStorage, file_name), gnWMO(0)
+WDTFile::WDTFile(char const* storagePath, std::string mapName, bool cache)
+    : _file(CascStorage, storagePath), _mapName(std::move(mapName))
 {
-    filename.append(file_name1,strlen(file_name1));
+    if (cache)
+    {
+        _adtCache = Trinity::make_unique<ADTCache>();
+        memset(_adtCache->file, 0, sizeof(_adtCache->file));
+    }
+    else
+        _adtCache = nullptr;
 }
 
-bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
+WDTFile::~WDTFile() = default;
+
+bool WDTFile::init(uint32 mapId)
 {
-    if (WDT.isEof())
-    {
-        //printf("Can't find WDT file.\n");
+    if (_file.isEof())
         return false;
-    }
 
     char fourcc[5];
     uint32 size;
 
     std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
-    FILE *dirfile;
-    dirfile = fopen(dirname.c_str(), "ab");
-    if(!dirfile)
+    FILE* dirfile = fopen(dirname.c_str(), "ab");
+    if (!dirfile)
     {
         printf("Can't open dirfile!'%s'\n", dirname.c_str());
         return false;
     }
 
-    while (!WDT.isEof())
+    while (!_file.isEof())
     {
-        WDT.read(fourcc,4);
-        WDT.read(&size, 4);
+        _file.read(fourcc,4);
+        _file.read(&size, 4);
 
         flipcc(fourcc);
         fourcc[4] = 0;
 
-        size_t nextpos = WDT.getPos() + size;
+        size_t nextpos = _file.getPos() + size;
 
         if (!strcmp(fourcc,"MAIN"))
         {
@@ -76,7 +82,7 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
             if (size)
             {
                 char *buf = new char[size];
-                WDT.read(buf, size);
+                _file.read(buf, size);
                 char *p = buf;
                 while (p < buf + size)
                 {
@@ -86,7 +92,7 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
                     FixNameCase(s, strlen(s));
                     FixNameSpaces(s, strlen(s));
                     p = p + strlen(p) + 1;
-                    gWmoInstansName.push_back(s);
+                    _wmoNames.push_back(s);
 
                     ExtractSingleWmo(path);
                 }
@@ -98,36 +104,45 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
             // global wmo instance data
             if (size)
             {
-                gnWMO = (int)size / 64;
+                int32 gnWMO = (int)size / 64;
 
                 for (int i = 0; i < gnWMO; ++i)
                 {
                     int id;
-                    WDT.read(&id, 4);
-                    WMOInstance inst(WDT, gWmoInstansName[id].c_str(), mapID, 65, 65, dirfile);
+                    _file.read(&id, 4);
+                    WMOInstance inst(_file, _wmoNames[id].c_str(), mapId, 65, 65, mapId, dirfile, nullptr);
                 }
             }
         }
-        WDT.seek((int)nextpos);
+        _file.seek((int)nextpos);
     }
 
-    WDT.close();
+    _file.close();
     fclose(dirfile);
     return true;
 }
 
-WDTFile::~WDTFile(void)
+ADTFile* WDTFile::GetMap(int32 x, int32 y)
 {
-    WDT.close();
-}
+    if (!(x >= 0 && y >= 0 && x < 64 && y < 64))
+        return nullptr;
 
-ADTFile* WDTFile::GetMap(int x, int z)
-{
-    if(!(x>=0 && z >= 0 && x<64 && z<64))
-        return NULL;
+    if (_adtCache && _adtCache->file[x][y])
+        return _adtCache->file[x][y].get();
 
     char name[512];
 
-    sprintf(name,"World\\Maps\\%s\\%s_%d_%d_obj0.adt", filename.c_str(), filename.c_str(), x, z);
-    return new ADTFile(name);
+    sprintf(name, "World\\Maps\\%s\\%s_%d_%d_obj0.adt", _mapName.c_str(), _mapName.c_str(), x, y);
+    ADTFile* adt =  new ADTFile(name, _adtCache != nullptr);
+    if (_adtCache)
+        _adtCache->file[x][y].reset(adt);
+    return adt;
+}
+
+void WDTFile::FreeADT(ADTFile* adt)
+{
+    if (_adtCache)
+        return;
+
+    delete adt;
 }
diff --git a/src/tools/vmap4_extractor/wdtfile.h b/src/tools/vmap4_extractor/wdtfile.h
index 89b71e9b99d..2fe09b94849 100644
--- a/src/tools/vmap4_extractor/wdtfile.h
+++ b/src/tools/vmap4_extractor/wdtfile.h
@@ -21,6 +21,7 @@
 
 #include "cascfile.h"
 #include "wmo.h"
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -28,18 +29,22 @@ class ADTFile;
 
 class WDTFile
 {
-private:
-    CASCFile WDT;
-    std::string filename;
 public:
-    WDTFile(char* file_name, char* file_name1);
-    ~WDTFile(void);
-    bool init(char* map_id, unsigned int mapID);
-
-    std::vector<std::string> gWmoInstansName;
-    int gnWMO;
+    WDTFile(char const* storagePath, std::string mapName, bool cache);
+    ~WDTFile();
+    bool init(uint32 mapId);
 
-    ADTFile* GetMap(int x, int z);
+    ADTFile* GetMap(int32 x, int32 y);
+    void FreeADT(ADTFile* adt);
+private:
+    CASCFile _file;
+    std::string _mapName;
+    std::vector<std::string> _wmoNames;
+    struct ADTCache
+    {
+        std::unique_ptr<ADTFile> file[64][64];
+    };
+    std::unique_ptr<ADTCache> _adtCache;
 };
 
 #endif
diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp
index 4607856d304..e24c95e6987 100644
--- a/src/tools/vmap4_extractor/wmo.cpp
+++ b/src/tools/vmap4_extractor/wmo.cpp
@@ -18,6 +18,7 @@
 
 #include "vmapexport.h"
 #include "wmo.h"
+#include "adtfile.h"
 #include "vec3d.h"
 #include <cstdio>
 #include <cstdlib>
@@ -514,7 +515,7 @@ WMOGroup::~WMOGroup()
     delete [] LiquBytes;
 }
 
-WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile)
+WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache)
     : currx(0), curry(0), wmo(NULL), doodadset(0), pos(), indx(0), id(0)
 {
     float ff[3];
@@ -578,7 +579,11 @@ WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uin
 
     float scale = 1.0f;
     uint32 flags = MOD_HAS_BOUND;
-    if(tileX == 65 && tileY == 65) flags |= MOD_WORLDSPAWN;
+    if (tileX == 65 && tileY == 65)
+        flags |= MOD_WORLDSPAWN;
+    if (mapID != originalMapId)
+        flags |= MOD_PARENT_SPAWN;
+
     //write mapID, tileX, tileY, Flags, ID, Pos, Rot, Scale, Bound_lo, Bound_hi, name
     fwrite(&mapID, sizeof(uint32), 1, pDirfile);
     fwrite(&tileX, sizeof(uint32), 1, pDirfile);
@@ -591,10 +596,42 @@ WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uin
     fwrite(&scale, sizeof(float), 1, pDirfile);
     fwrite(&pos2, sizeof(float), 3, pDirfile);
     fwrite(&pos3, sizeof(float), 3, pDirfile);
-    uint32 nlen=strlen(WmoInstName);
+    uint32 nlen = strlen(WmoInstName);
     fwrite(&nlen, sizeof(uint32), 1, pDirfile);
     fwrite(WmoInstName, sizeof(char), nlen, pDirfile);
 
+    if (dirfileCache)
+    {
+        dirfileCache->emplace_back();
+        ADTOutputCache& cacheModelData = dirfileCache->back();
+        cacheModelData.Flags = flags & ~MOD_PARENT_SPAWN;
+        cacheModelData.Data.resize(
+            sizeof(uint16) +    // adtId
+            sizeof(uint32) +    // id
+            sizeof(float) * 3 + // pos
+            sizeof(float) * 3 + // rot
+            sizeof(float) +     // scale
+            sizeof(float) * 3 + // pos2
+            sizeof(float) * 3 + // pos3
+            sizeof(uint32) +    // nlen
+            nlen);              // WmoInstName
+
+        uint8* cacheData = cacheModelData.Data.data();
+#define CACHE_WRITE(value, size, count, dest) memcpy(dest, value, size * count); dest += size * count;
+
+        CACHE_WRITE(&adtId, sizeof(uint16), 1, cacheData);
+        CACHE_WRITE(&id, sizeof(uint32), 1, cacheData);
+        CACHE_WRITE(&pos, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&rot, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&scale, sizeof(float), 1, cacheData);
+        CACHE_WRITE(&pos2, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&pos3, sizeof(float), 3, cacheData);
+        CACHE_WRITE(&nlen, sizeof(uint32), 1, cacheData);
+        CACHE_WRITE(WmoInstName, sizeof(char), nlen, cacheData);
+
+#undef CACHE_WRITE
+    }
+
     /* fprintf(pDirfile,"%s/%s %f,%f,%f_%f,%f,%f 1.0 %d %d %d,%d %d\n",
         MapName,
         WmoInstName,
diff --git a/src/tools/vmap4_extractor/wmo.h b/src/tools/vmap4_extractor/wmo.h
index e9482f0d8d1..8bb147e986f 100644
--- a/src/tools/vmap4_extractor/wmo.h
+++ b/src/tools/vmap4_extractor/wmo.h
@@ -43,6 +43,7 @@ enum MopyFlags
 class WMOInstance;
 class WMOManager;
 class CASCFile;
+struct ADTOutputCache;
 
 /* for whatever reason a certain company just can't stick to one coordinate system... */
 static inline Vec3D fixCoords(const Vec3D &v){ return Vec3D(v.z, v.x, v.y); }
@@ -138,7 +139,7 @@ public:
     Vec3D pos2, pos3, rot;
     uint32 indx, id;
 
-    WMOInstance(CASCFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile);
+    WMOInstance(CASCFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache);
 };
 
 #endif