Core/Revert: ...

59 files changed, 1709 insertions, 1492 deletions

diff --git a/src/server/collision/Management/MMapFactory.cpp b/src/server/collision/Management/MMapFactory.cpp
index 43c726d9989..b08cd92d638 100644
--- a/src/server/collision/Management/MMapFactory.cpp
+++ b/src/server/collision/Management/MMapFactory.cpp
@@ -25,14 +25,14 @@ namespace MMAP
 {
     // ######################## MMapFactory ########################
     // our global singleton copy
-    MMapManager* _manager = NULL;
+    MMapManager* g_MMapManager = NULL;
 
-    MMapManager* MMapFactory::CreateOrGetMMapManager()
+    MMapManager* MMapFactory::createOrGetMMapManager()
     {
-        if (_manager == NULL)
-            _manager = new MMapManager();
+        if (g_MMapManager == NULL)
+            g_MMapManager = new MMapManager();
 
-        return _manager;
+        return g_MMapManager;
     }
 
     bool MMapFactory::IsPathfindingEnabled(uint32 mapId)
@@ -41,12 +41,12 @@ namespace MMAP
             && !DisableMgr::IsDisabledFor(DISABLE_TYPE_MMAP, mapId, NULL, MMAP_DISABLE_PATHFINDING);
     }
 
-    void MMapFactory::Clear()
+    void MMapFactory::clear()
     {
-        if (_manager)
+        if (g_MMapManager)
         {
-            delete _manager;
-            _manager = NULL;
+            delete g_MMapManager;
+            g_MMapManager = NULL;
         }
     }
 }
\ No newline at end of file
diff --git a/src/server/collision/Management/MMapFactory.h b/src/server/collision/Management/MMapFactory.h
index 890befdff04..837c893f038 100644
--- a/src/server/collision/Management/MMapFactory.h
+++ b/src/server/collision/Management/MMapFactory.h
@@ -20,6 +20,10 @@
 #define _MMAP_FACTORY_H
 
 #include "MMapManager.h"
+#include "UnorderedMap.h"
+#include "DetourAlloc.h"
+#include "DetourNavMesh.h"
+#include "DetourNavMeshQuery.h"
 
 namespace MMAP
 {
@@ -36,8 +40,8 @@ namespace MMAP
     class MMapFactory
     {
         public:
-            static MMapManager* CreateOrGetMMapManager();
-            static void Clear();
+            static MMapManager* createOrGetMMapManager();
+            static void clear();
             static bool IsPathfindingEnabled(uint32 mapId);
     };
 }
diff --git a/src/server/collision/Management/MMapManager.cpp b/src/server/collision/Management/MMapManager.cpp
index 6c6e39eeda2..cbb10923fe0 100644
--- a/src/server/collision/Management/MMapManager.cpp
+++ b/src/server/collision/Management/MMapManager.cpp
@@ -22,29 +22,32 @@
 
 namespace MMAP
 {
+    // ######################## MMapManager ########################
     MMapManager::~MMapManager()
     {
-        for (MMapDataSet::iterator i = _loadedMaps.begin(); i != _loadedMaps.end(); ++i)
+        for (MMapDataSet::iterator i = loadedMMaps.begin(); i != loadedMMaps.end(); ++i)
             delete i->second;
+
+        // by now we should not have maps loaded
+        // if we had, tiles in MMapData->mmapLoadedTiles, their actual data is lost!
     }
 
-    bool MMapManager::LoadMap(uint32 mapId)
+    bool MMapManager::loadMapData(uint32 mapId)
     {
-        // Do not load a map twice.
-        if (_loadedMaps.find(mapId) != _loadedMaps.end())
+        // we already have this map loaded?
+        if (loadedMMaps.find(mapId) != loadedMMaps.end())
             return true;
 
         // load and init dtNavMesh - read parameters from file
-        std::string basePath = sWorld->GetDataPath();
-        uint32 pathLen = basePath.length() + strlen("mmaps/%03i.mmap") + 1;
-        char* fileName = new char[pathLen];
-        snprintf(fileName, pathLen, (basePath + "mmaps/%03i.mmap").c_str(), mapId);
+        uint32 pathLen = sWorld->GetDataPath().length() + strlen("mmaps/%03i.mmap")+1;
+        char *fileName = new char[pathLen];
+        snprintf(fileName, pathLen, (sWorld->GetDataPath()+"mmaps/%03i.mmap").c_str(), mapId);
 
         FILE* file = fopen(fileName, "rb");
         if (!file)
         {
-            TC_LOG_DEBUG("maps", "MMAP::LoadMap: Error: Could not open mmap file '%s'", fileName);
-            delete[] fileName;
+            TC_LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not open mmap file '%s'", fileName);
+            delete [] fileName;
             return false;
         }
 
@@ -53,75 +56,80 @@ namespace MMAP
         fclose(file);
         if (count != 1)
         {
-            TC_LOG_DEBUG("maps", "MMAP::LoadMap: Error: Could not read params from file '%s'", fileName);
-            delete[] fileName;
+            TC_LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not read params from file '%s'", fileName);
+            delete [] fileName;
             return false;
         }
 
         dtNavMesh* mesh = dtAllocNavMesh();
+        ASSERT(mesh);
         if (dtStatusFailed(mesh->init(&params)))
         {
             dtFreeNavMesh(mesh);
-            TC_LOG_ERROR("maps", "MMAP::LoadMap: Failed to initialize dtNavMesh for mmap %03u from file %s", mapId, fileName);
-            delete[] fileName;
+            TC_LOG_ERROR("maps", "MMAP:loadMapData: Failed to initialize dtNavMesh for mmap %03u from file %s", mapId, fileName);
+            delete [] fileName;
             return false;
         }
 
-        delete[] fileName;
+        delete [] fileName;
 
-        TC_LOG_INFO("maps", "MMAP::LoadMap: Loaded %03i.mmap", mapId);
+        TC_LOG_INFO("maps", "MMAP:loadMapData: Loaded %03i.mmap", mapId);
 
         // store inside our map list
-        MMapData* mmapData = new MMapData(mesh);
-        mmapData->_loadedTiles.clear();
+        MMapData* mmap_data = new MMapData(mesh);
+        mmap_data->mmapLoadedTiles.clear();
 
-        _loadedMaps.insert(std::pair<uint32, MMapData*>(mapId, mmapData));
+        loadedMMaps.insert(std::pair<uint32, MMapData*>(mapId, mmap_data));
         return true;
     }
 
-    bool MMapManager::LoadMapTile(uint32 mapId, int32 x, int32 y)
+    uint32 MMapManager::packTileID(int32 x, int32 y)
+    {
+        return uint32(x << 16 | y);
+    }
+
+    bool MMapManager::loadMap(const std::string& /*basePath*/, uint32 mapId, int32 x, int32 y)
     {
         // make sure the mmap is loaded and ready to load tiles
-        if (!LoadMap(mapId))
+        if (!loadMapData(mapId))
             return false;
 
         // get this mmap data
-        MMapData* mmap = _loadedMaps[mapId];
+        MMapData* mmap = loadedMMaps[mapId];
         ASSERT(mmap->navMesh);
 
-        // Check if we already have this tile loaded
-        uint32 pos = PackTileId(x, y);
-        if (mmap->_loadedTiles.find(pos) != mmap->_loadedTiles.end())
+        // check if we already have this tile loaded
+        uint32 packedGridPos = packTileID(x, y);
+        if (mmap->mmapLoadedTiles.find(packedGridPos) != mmap->mmapLoadedTiles.end())
             return false;
 
-        std::string basePath = sWorld->GetDataPath();
-        uint32 pathLen = basePath.length() + strlen("mmaps/%03i%02i%02i.mmtile") + 1;
-        char* fileName = new char[pathLen];
+        // load this tile :: mmaps/MMMXXYY.mmtile
+        uint32 pathLen = sWorld->GetDataPath().length() + strlen("mmaps/%03i%02i%02i.mmtile")+1;
+        char *fileName = new char[pathLen];
 
-        snprintf(fileName, pathLen, (basePath + "mmaps/%03i%02i%02i.mmtile").c_str(), mapId, x, y);
+        snprintf(fileName, pathLen, (sWorld->GetDataPath()+"mmaps/%03i%02i%02i.mmtile").c_str(), mapId, x, y);
 
         FILE* file = fopen(fileName, "rb");
         if (!file)
         {
-            TC_LOG_DEBUG("maps", "MMAP::LoadMapTile: Could not open mmtile file '%s'", fileName);
-            delete[] fileName;
+            TC_LOG_DEBUG("maps", "MMAP:loadMap: Could not open mmtile file '%s'", fileName);
+            delete [] fileName;
             return false;
         }
-
-        delete[] fileName;
+        delete [] fileName;
 
         // read header
         MmapTileHeader fileHeader;
         if (fread(&fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || fileHeader.mmapMagic != MMAP_MAGIC)
         {
-            TC_LOG_ERROR("maps", "MMAP::LoadMapTile: Bad header in mmap %03u%02i%02i.mmtile", mapId, x, y);
+            TC_LOG_ERROR("maps", "MMAP:loadMap: Bad header in mmap %03u%02i%02i.mmtile", mapId, x, y);
             fclose(file);
             return false;
         }
 
         if (fileHeader.mmapVersion != MMAP_VERSION)
         {
-            TC_LOG_ERROR("maps", "MMAP::LoadMapTile: %03u%02i%02i.mmtile was built with generator v%i, expected v%i",
+            TC_LOG_ERROR("maps", "MMAP:loadMap: %03u%02i%02i.mmtile was built with generator v%i, expected v%i",
                 mapId, x, y, fileHeader.mmapVersion, MMAP_VERSION);
             fclose(file);
             return false;
@@ -131,9 +139,9 @@ namespace MMAP
         ASSERT(data);
 
         size_t result = fread(data, fileHeader.size, 1, file);
-        if (result != 1)
+        if (!result)
         {
-            TC_LOG_ERROR("maps", "MMAP::LoadMapTile: Bad header or data in mmap %03u%02i%02i.mmtile", mapId, x, y);
+            TC_LOG_ERROR("maps", "MMAP:loadMap: Bad header or data in mmap %03u%02i%02i.mmtile", mapId, x, y);
             fclose(file);
             return false;
         }
@@ -146,14 +154,14 @@ namespace MMAP
         // memory allocated for data is now managed by detour, and will be deallocated when the tile is removed
         if (dtStatusSucceed(mmap->navMesh->addTile(data, fileHeader.size, DT_TILE_FREE_DATA, 0, &tileRef)))
         {
-            mmap->_loadedTiles.insert(std::pair<uint32, dtTileRef>(pos, tileRef));
-            ++_loadedTiles;
-            TC_LOG_INFO("maps", "MMAP::LoadMapTile: Loaded mmtile %03i[%02i, %02i] into %03i[%02i, %02i]", mapId, x, y, mapId, header->x, header->y);
+            mmap->mmapLoadedTiles.insert(std::pair<uint32, dtTileRef>(packedGridPos, tileRef));
+            ++loadedTiles;
+            TC_LOG_INFO("maps", "MMAP:loadMap: Loaded mmtile %03i[%02i, %02i] into %03i[%02i, %02i]", mapId, x, y, mapId, header->x, header->y);
             return true;
         }
         else
         {
-            TC_LOG_ERROR("maps", "MMAP::LoadMapTile: Could not load %03u%02i%02i.mmtile into navmesh", mapId, x, y);
+            TC_LOG_ERROR("maps", "MMAP:loadMap: Could not load %03u%02i%02i.mmtile into navmesh", mapId, x, y);
             dtFree(data);
             return false;
         }
@@ -161,26 +169,28 @@ namespace MMAP
         return false;
     }
 
-    bool MMapManager::UnloadMapTile(uint32 mapId, int32 x, int32 y)
+    bool MMapManager::unloadMap(uint32 mapId, int32 x, int32 y)
     {
-        // Do not attempt to remove tiles from a not-loaded map
-        if (_loadedMaps.find(mapId) == _loadedMaps.end())
+        // check if we have this map loaded
+        if (loadedMMaps.find(mapId) == loadedMMaps.end())
         {
-            TC_LOG_DEBUG("maps", "MMAP::UnloadMapTile: Asked to unload not loaded navmesh map. %03u%02i%02i.mmtile", mapId, x, y);
+            // file may not exist, therefore not loaded
+            TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map. %03u%02i%02i.mmtile", mapId, x, y);
             return false;
         }
 
-        MMapData* mmap = _loadedMaps[mapId];
+        MMapData* mmap = loadedMMaps[mapId];
 
         // check if we have this tile loaded
-        uint32 pos = PackTileId(x, y);
-        if (mmap->_loadedTiles.find(pos) == mmap->_loadedTiles.end())
+        uint32 packedGridPos = packTileID(x, y);
+        if (mmap->mmapLoadedTiles.find(packedGridPos) == mmap->mmapLoadedTiles.end())
         {
-            TC_LOG_DEBUG("maps", "MMAP::UnloadMapTile: Asked to unload not loaded navmesh tile. %03u%02i%02i.mmtile", mapId, x, y);
+            // file may not exist, therefore not loaded
+            TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh tile. %03u%02i%02i.mmtile", mapId, x, y);
             return false;
         }
 
-        dtTileRef tileRef = mmap->_loadedTiles[pos];
+        dtTileRef tileRef = mmap->mmapLoadedTiles[packedGridPos];
 
         // unload, and mark as non loaded
         if (dtStatusFailed(mmap->navMesh->removeTile(tileRef, NULL, NULL)))
@@ -188,106 +198,107 @@ namespace MMAP
             // this is technically a memory leak
             // if the grid is later reloaded, dtNavMesh::addTile will return error but no extra memory is used
             // we cannot recover from this error - assert out
-            TC_LOG_ERROR("maps", "MMAP::UnloadMapTile: Could not unload %03u%02i%02i.mmtile from navmesh", mapId, x, y);
+            TC_LOG_ERROR("maps", "MMAP:unloadMap: Could not unload %03u%02i%02i.mmtile from navmesh", mapId, x, y);
             ASSERT(false);
         }
         else
         {
-            mmap->_loadedTiles.erase(pos);
-            --_loadedTiles;
-            TC_LOG_INFO("maps", "MMAP::UnloadMapTile: Unloaded mmtile [%02i, %02i] from %03i", x, y, mapId);
+            mmap->mmapLoadedTiles.erase(packedGridPos);
+            --loadedTiles;
+            TC_LOG_INFO("maps", "MMAP:unloadMap: Unloaded mmtile %03i[%02i, %02i] from %03i", mapId, x, y, mapId);
             return true;
         }
 
         return false;
     }
 
-    bool MMapManager::UnloadMap(uint32 mapId)
+    bool MMapManager::unloadMap(uint32 mapId)
     {
-        if (_loadedMaps.find(mapId) == _loadedMaps.end())
+        if (loadedMMaps.find(mapId) == loadedMMaps.end())
         {
             // file may not exist, therefore not loaded
-            TC_LOG_DEBUG("maps", "MMAP::UnloadMap: Asked to unload not loaded navmesh map %03u", mapId);
+            TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map %03u", mapId);
             return false;
         }
 
         // unload all tiles from given map
-        MMapData* mmap = _loadedMaps[mapId];
-        for (MMapTileSet::iterator i = mmap->_loadedTiles.begin(); i != mmap->_loadedTiles.end(); ++i)
+        MMapData* mmap = loadedMMaps[mapId];
+        for (MMapTileSet::iterator i = mmap->mmapLoadedTiles.begin(); i != mmap->mmapLoadedTiles.end(); ++i)
         {
             uint32 x = (i->first >> 16);
             uint32 y = (i->first & 0x0000FFFF);
             if (dtStatusFailed(mmap->navMesh->removeTile(i->second, NULL, NULL)))
-                TC_LOG_ERROR("maps", "MMAP::UnloadMap: Could not unload %03u%02u%02u.mmtile from navmesh", mapId, x, y);
+                TC_LOG_ERROR("maps", "MMAP:unloadMap: Could not unload %03u%02i%02i.mmtile from navmesh", mapId, x, y);
             else
             {
-                --_loadedTiles;
-                TC_LOG_INFO("maps", "MMAP::UnloadMap: Unloaded mmtile [%02u, %02u] from %03u", x, y, mapId);
+                --loadedTiles;
+                TC_LOG_INFO("maps", "MMAP:unloadMap: Unloaded mmtile %03i[%02i, %02i] from %03i", mapId, x, y, mapId);
             }
         }
 
         delete mmap;
-        _loadedMaps.erase(mapId);
-        TC_LOG_INFO("maps", "MMAP::UnloadMap: Unloaded %03u.mmap", mapId);
+        loadedMMaps.erase(mapId);
+        TC_LOG_INFO("maps", "MMAP:unloadMap: Unloaded %03i.mmap", mapId);
 
         return true;
     }
 
-    bool MMapManager::UnloadMapInstance(uint32 mapId, uint32 instanceId)
+    bool MMapManager::unloadMapInstance(uint32 mapId, uint32 instanceId)
     {
         // check if we have this map loaded
-        if (_loadedMaps.find(mapId) == _loadedMaps.end())
+        if (loadedMMaps.find(mapId) == loadedMMaps.end())
         {
             // file may not exist, therefore not loaded
-            TC_LOG_DEBUG("maps", "MMAP::UnloadMapInstance: Asked to unload not loaded navmesh map %03u", mapId);
+            TC_LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded navmesh map %03u", mapId);
             return false;
         }
 
-        MMapData* mmap = _loadedMaps[mapId];
-        if (mmap->_navMeshQueries.find(instanceId) == mmap->_navMeshQueries.end())
+        MMapData* mmap = loadedMMaps[mapId];
+        if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
         {
-            TC_LOG_DEBUG("maps", "MMAP::UnloadMapInstance: Asked to unload not loaded dtNavMeshQuery mapId %03u instanceId %u", mapId, instanceId);
+            TC_LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded dtNavMeshQuery mapId %03u instanceId %u", mapId, instanceId);
             return false;
         }
 
-        dtNavMeshQuery* query = mmap->_navMeshQueries[instanceId];
+        dtNavMeshQuery* query = mmap->navMeshQueries[instanceId];
 
         dtFreeNavMeshQuery(query);
-        mmap->_navMeshQueries.erase(instanceId);
-        TC_LOG_INFO("maps", "MMAP::UnloadMapInstance: Unloaded mapId %03u instanceId %u", mapId, instanceId);
+        mmap->navMeshQueries.erase(instanceId);
+        TC_LOG_INFO("maps", "MMAP:unloadMapInstance: Unloaded mapId %03u instanceId %u", mapId, instanceId);
 
         return true;
     }
 
     dtNavMesh const* MMapManager::GetNavMesh(uint32 mapId)
     {
-        if (_loadedMaps.find(mapId) == _loadedMaps.end())
+        if (loadedMMaps.find(mapId) == loadedMMaps.end())
             return NULL;
 
-        return _loadedMaps[mapId]->navMesh;
+        return loadedMMaps[mapId]->navMesh;
     }
 
     dtNavMeshQuery const* MMapManager::GetNavMeshQuery(uint32 mapId, uint32 instanceId)
     {
-        if (_loadedMaps.find(mapId) == _loadedMaps.end())
+        if (loadedMMaps.find(mapId) == loadedMMaps.end())
             return NULL;
 
-        MMapData* mmap = _loadedMaps[mapId];
-        if (mmap->_navMeshQueries.find(instanceId) == mmap->_navMeshQueries.end())
+        MMapData* mmap = loadedMMaps[mapId];
+        if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
         {
             // allocate mesh query
             dtNavMeshQuery* query = dtAllocNavMeshQuery();
-            if (dtStatusFailed(query->init(mmap->navMesh, 2048)))
+            ASSERT(query);
+            if (dtStatusFailed(query->init(mmap->navMesh, 1024)))
             {
                 dtFreeNavMeshQuery(query);
-                TC_LOG_ERROR("maps", "MMAP::GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId %03u instanceId %u", mapId, instanceId);
+                TC_LOG_ERROR("maps", "MMAP:GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId %03u instanceId %u", mapId, instanceId);
                 return NULL;
             }
 
             TC_LOG_INFO("maps", "MMAP:GetNavMeshQuery: created dtNavMeshQuery for mapId %03u instanceId %u", mapId, instanceId);
-            mmap->_navMeshQueries.insert(std::pair<uint32, dtNavMeshQuery*>(instanceId, query));
+            mmap->navMeshQueries.insert(std::pair<uint32, dtNavMeshQuery*>(instanceId, query));
         }
 
-        return mmap->_navMeshQueries[instanceId];
+        return mmap->navMeshQueries[instanceId];
     }
 }
diff --git a/src/server/collision/Management/MMapManager.h b/src/server/collision/Management/MMapManager.h
index 87bb4702dd2..8b0d42b83cd 100644
--- a/src/server/collision/Management/MMapManager.h
+++ b/src/server/collision/Management/MMapManager.h
@@ -36,7 +36,7 @@ namespace MMAP
         MMapData(dtNavMesh* mesh) : navMesh(mesh) { }
         ~MMapData()
         {
-            for (NavMeshQuerySet::iterator i = _navMeshQueries.begin(); i != _navMeshQueries.end(); ++i)
+            for (NavMeshQuerySet::iterator i = navMeshQueries.begin(); i != navMeshQueries.end(); ++i)
                 dtFreeNavMeshQuery(i->second);
 
             if (navMesh)
@@ -46,8 +46,8 @@ namespace MMAP
         dtNavMesh* navMesh;
 
         // we have to use single dtNavMeshQuery for every instance, since those are not thread safe
-        NavMeshQuerySet _navMeshQueries;     // instanceId to query
-        MMapTileSet _loadedTiles;        // maps [map grid coords] to [dtTile]
+        NavMeshQuerySet navMeshQueries;     // instanceId to query
+        MMapTileSet mmapLoadedTiles;        // maps [map grid coords] to [dtTile]
     };
 
 
@@ -58,27 +58,26 @@ namespace MMAP
     class MMapManager
     {
         public:
-            MMapManager() : _loadedTiles(0) {}
-
+            MMapManager() : loadedTiles(0) { }
             ~MMapManager();
 
-            bool LoadMapTile(uint32 mapId, int32 x, int32 y);
-            bool UnloadMapTile(uint32 mapId, int32 x, int32 y);
-            bool UnloadMap(uint32 mapId);
-            bool UnloadMapInstance(uint32 mapId, uint32 instanceId);
+            bool loadMap(const std::string& basePath, uint32 mapId, int32 x, int32 y);
+            bool unloadMap(uint32 mapId, int32 x, int32 y);
+            bool unloadMap(uint32 mapId);
+            bool unloadMapInstance(uint32 mapId, uint32 instanceId);
 
             // the returned [dtNavMeshQuery const*] is NOT threadsafe
             dtNavMeshQuery const* GetNavMeshQuery(uint32 mapId, uint32 instanceId);
             dtNavMesh const* GetNavMesh(uint32 mapId);
 
-            uint32 GetLoadedTilesCount() const { return _loadedTiles; }
-            uint32 GetLoadedMapsCount() const { return _loadedMaps.size(); }
+            uint32 getLoadedTilesCount() const { return loadedTiles; }
+            uint32 getLoadedMapsCount() const { return loadedMMaps.size(); }
         private:
-            bool LoadMap(uint32 mapId);
-            uint32 PackTileId(int32 x, int32 y) { return uint32(x << 16 | y); }
+            bool loadMapData(uint32 mapId);
+            uint32 packTileID(int32 x, int32 y);
 
-            MMapDataSet _loadedMaps;
-            uint32 _loadedTiles;
+            MMapDataSet loadedMMaps;
+            uint32 loadedTiles;
     };
 }
 
diff --git a/src/server/game/Instances/InstanceSaveMgr.cpp b/src/server/game/Instances/InstanceSaveMgr.cpp
index c46d9002604..e37e6847bdd 100644
--- a/src/server/game/Instances/InstanceSaveMgr.cpp
+++ b/src/server/game/Instances/InstanceSaveMgr.cpp
@@ -164,11 +164,7 @@ void InstanceSaveManager::RemoveInstanceSave(uint32 InstanceId)
 void InstanceSaveManager::UnloadInstanceSave(uint32 InstanceId)
 {
     if (InstanceSave* save = GetInstanceSave(InstanceId))
-    {
         save->UnloadIfEmpty();
-        if (save->m_toDelete)
-            delete save;
-    }
 }
 
 InstanceSave::InstanceSave(uint16 MapId, uint32 InstanceId, Difficulty difficulty, time_t resetTime, bool canReset)
diff --git a/src/server/game/Instances/InstanceSaveMgr.h b/src/server/game/Instances/InstanceSaveMgr.h
index 1d753ebaa48..7a89e6488f0 100644
--- a/src/server/game/Instances/InstanceSaveMgr.h
+++ b/src/server/game/Instances/InstanceSaveMgr.h
@@ -115,16 +115,16 @@ class InstanceSave
            but that would depend on a lot of things that can easily change in future */
         Difficulty GetDifficulty() const { return m_difficulty; }
 
-        typedef std::list<Player*> PlayerListType;
-        typedef std::list<Group*> GroupListType;
-    private:
-        bool UnloadIfEmpty();
         /* used to flag the InstanceSave as to be deleted, so the caller can delete it */
         void SetToDelete(bool toDelete)
         {
             m_toDelete = toDelete;
         }
 
+        typedef std::list<Player*> PlayerListType;
+        typedef std::list<Group*> GroupListType;
+    private:
+        bool UnloadIfEmpty();
         /* the only reason the instSave-object links are kept is because
            the object-instSave links need to be broken at reset time */
            /// @todo: Check if maybe it's enough to just store the number of players/groups
diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp
index 10ed0e804a7..79e63cf2035 100644
--- a/src/server/game/Maps/Map.cpp
+++ b/src/server/game/Maps/Map.cpp
@@ -66,9 +66,7 @@ Map::~Map()
     if (!m_scriptSchedule.empty())
         sScriptMgr->DecreaseScheduledScriptCount(m_scriptSchedule.size());
 
-    MMAP::MMapManager* manager = MMAP::MMapFactory::CreateOrGetMMapManager();
-    manager->UnloadMapInstance(GetId(), i_InstanceId); // Delete the dtNavMeshQuery
-    manager->UnloadMap(GetId()); // Unload the loaded tiles and delete the dtNavMesh
+    MMAP::MMapFactory::createOrGetMMapManager()->unloadMapInstance(GetId(), i_InstanceId);
 }
 
 bool Map::ExistMap(uint32 mapid, int gx, int gy)
@@ -121,16 +119,12 @@ bool Map::ExistVMap(uint32 mapid, int gx, int gy)
 
 void Map::LoadMMap(int gx, int gy)
 {
-    bool mmapLoadResult = false;
-    if (GetEntry()->Instanceable())
-        mmapLoadResult = MMAP::MMapFactory::CreateOrGetMMapManager()->LoadMapTile(GetId(), 0, 0); // Ignore the tile entry for instances, as they only have 1 tile.
-    else
-        mmapLoadResult = MMAP::MMapFactory::CreateOrGetMMapManager()->LoadMapTile(GetId(), gx, gy);
+    bool mmapLoadResult = MMAP::MMapFactory::createOrGetMMapManager()->loadMap((sWorld->GetDataPath() + "mmaps").c_str(), GetId(), gx, gy);
 
     if (mmapLoadResult)
-        TC_LOG_INFO("maps", "MMAP loaded name: %s, id: %d, x: %d, y: %d", GetMapName(), GetId(), gx, gy);
+        TC_LOG_INFO("maps", "MMAP loaded name:%s, id:%d, x:%d, y:%d (mmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
     else
-        TC_LOG_INFO("maps", "Could not load MMAP name: %s, id: %d, x: %d, y: %d", GetMapName(), GetId(), gx, gy);
+        TC_LOG_INFO("maps", "Could not load MMAP name:%s, id:%d, x:%d, y:%d (mmap rep.: x:%d, y:%d)", GetMapName(), GetId(), gx, gy, gx, gy);
 }
 
 void Map::LoadVMap(int gx, int gy)
@@ -232,9 +226,9 @@ i_gridExpiry(expiry),
 i_scriptLock(false)
 {
     m_parentMap = (_parent ? _parent : this);
-    for (unsigned int idx = 0; idx < MAX_NUMBER_OF_GRIDS; ++idx)
+    for (unsigned int idx=0; idx < MAX_NUMBER_OF_GRIDS; ++idx)
     {
-        for (unsigned int j = 0; j < MAX_NUMBER_OF_GRIDS; ++j)
+        for (unsigned int j=0; j < MAX_NUMBER_OF_GRIDS; ++j)
         {
             //z code
             GridMaps[idx][j] =NULL;
@@ -1342,7 +1336,7 @@ bool Map::UnloadGrid(NGridType& ngrid, bool unloadAll)
                 delete GridMaps[gx][gy];
             }
             VMAP::VMapFactory::createOrGetVMapManager()->unloadMap(GetId(), gx, gy);
-            MMAP::MMapFactory::CreateOrGetMMapManager()->UnloadMapTile(GetId(), gx, gy);
+            MMAP::MMapFactory::createOrGetMMapManager()->unloadMap(GetId(), gx, gy);
         }
         else
             ((MapInstanced*)m_parentMap)->RemoveGridMapReference(GridCoord(gx, gy));
diff --git a/src/server/game/Maps/MapInstanced.cpp b/src/server/game/Maps/MapInstanced.cpp
index d8f93cbe293..e914a5c3eee 100644
--- a/src/server/game/Maps/MapInstanced.cpp
+++ b/src/server/game/Maps/MapInstanced.cpp
@@ -260,7 +260,7 @@ bool MapInstanced::DestroyInstance(InstancedMaps::iterator &itr)
     if (m_InstancedMaps.size() <= 1 && sWorld->getBoolConfig(CONFIG_GRID_UNLOAD))
     {
         VMAP::VMapFactory::createOrGetVMapManager()->unloadMap(itr->second->GetId());
-        MMAP::MMapFactory::CreateOrGetMMapManager()->UnloadMap(itr->second->GetId());
+        MMAP::MMapFactory::createOrGetMMapManager()->unloadMap(itr->second->GetId());
         // in that case, unload grids of the base map, too
         // so in the next map creation, (EnsureGridCreated actually) VMaps will be reloaded
         Map::UnloadAll();
diff --git a/src/server/game/Miscellaneous/SharedDefines.h b/src/server/game/Miscellaneous/SharedDefines.h
index 69d4cf847ac..75e190ed20d 100644
--- a/src/server/game/Miscellaneous/SharedDefines.h
+++ b/src/server/game/Miscellaneous/SharedDefines.h
@@ -4068,7 +4068,7 @@ enum PartyResult
 };
 
 const uint32 MMAP_MAGIC = 0x4d4d4150; // 'MMAP'
-#define MMAP_VERSION 5
+#define MMAP_VERSION 4
 
 struct MmapTileHeader
 {
diff --git a/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp
index e7a3c6de33c..61f3a04bc5d 100755
--- a/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp
+++ b/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp
@@ -86,6 +86,7 @@ bool ConfusedMovementGenerator<T>::DoUpdate(T* unit, uint32 diff)
             unit->MovePositionToFirstCollision(pos, dest, 0.0f);
 
             PathGenerator path(unit);
+            path.SetPathLengthLimit(30.0f);
             bool result = path.CalculatePath(pos.m_positionX, pos.m_positionY, pos.m_positionZ);
             if (!result || (path.GetPathType() & PATHFIND_NOPATH))
             {
diff --git a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
index c351aeecd51..572d65b07c7 100644
--- a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
+++ b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
@@ -59,6 +59,7 @@ void FleeingMovementGenerator<T>::_setTargetLocation(T* owner)
     }
 
     PathGenerator path(owner);
+    path.SetPathLengthLimit(30.0f);
     bool result = path.CalculatePath(x, y, z);
     if (!result || (path.GetPathType() & PATHFIND_NOPATH))
     {
diff --git a/src/server/game/Movement/PathGenerator.cpp b/src/server/game/Movement/PathGenerator.cpp
index 9f16b6b8771..d8a300a2bab 100644
--- a/src/server/game/Movement/PathGenerator.cpp
+++ b/src/server/game/Movement/PathGenerator.cpp
@@ -27,19 +27,21 @@
 #include "DetourCommon.h"
 #include "DetourNavMeshQuery.h"
 
-float PathGenerator::MinWallDistance = 2.5f;
-
 ////////////////// PathGenerator //////////////////
 PathGenerator::PathGenerator(const Unit* owner) :
-    _type(PATHFIND_BLANK), _endPosition(G3D::Vector3::zero()),
-    _sourceUnit(owner), _navMesh(NULL), _navMeshQuery(NULL)
+    _polyLength(0), _type(PATHFIND_BLANK), _useStraightPath(false),
+    _forceDestination(false), _pointPathLimit(MAX_POINT_PATH_LENGTH),
+    _endPosition(G3D::Vector3::zero()), _sourceUnit(owner), _navMesh(NULL),
+    _navMeshQuery(NULL)
 {
-    TC_LOG_DEBUG("maps", "PathGenerator::PathGenerator for %u \n", _sourceUnit->GetGUIDLow());
+    memset(_pathPolyRefs, 0, sizeof(_pathPolyRefs));
+
+    TC_LOG_DEBUG("maps", "++ PathGenerator::PathGenerator for %u \n", _sourceUnit->GetGUIDLow());
 
     uint32 mapId = _sourceUnit->GetMapId();
     if (MMAP::MMapFactory::IsPathfindingEnabled(mapId))
     {
-        MMAP::MMapManager* mmap = MMAP::MMapFactory::CreateOrGetMMapManager();
+        MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();
         _navMesh = mmap->GetNavMesh(mapId);
         _navMeshQuery = mmap->GetNavMeshQuery(mapId, _sourceUnit->GetInstanceId());
     }
@@ -49,23 +51,16 @@ PathGenerator::PathGenerator(const Unit* owner) :
 
 PathGenerator::~PathGenerator()
 {
-    TC_LOG_DEBUG("maps", "PathGenerator::~PathGenerator() for %u \n", _sourceUnit->GetGUIDLow());
+    TC_LOG_DEBUG("maps", "++ PathGenerator::~PathGenerator() for %u \n", _sourceUnit->GetGUIDLow());
 }
 
 bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool forceDest)
 {
-    // Clear the previous path, just in case that the same PathGenerator instance is being used
-    _pathPoints.clear();
-
     float x, y, z;
     _sourceUnit->GetPosition(x, y, z);
 
     if (!Trinity::IsValidMapCoord(destX, destY, destZ) || !Trinity::IsValidMapCoord(x, y, z))
-    {
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() called with invalid map coords, destX: %f destY: %f destZ: %f x: %f y: %f z: %f for creature %u", destX, destY, destZ, x, y, z, _sourceUnit->GetGUIDLow());
-        _type = PATHFIND_NOPATH;
         return false;
-    }
 
     G3D::Vector3 dest(destX, destY, destZ);
     SetEndPosition(dest);
@@ -73,103 +68,463 @@ bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool fo
     G3D::Vector3 start(x, y, z);
     SetStartPosition(start);
 
-    TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() for %u \n", _sourceUnit->GetGUIDLow());
+    _forceDestination = forceDest;
+
+    TC_LOG_DEBUG("maps", "++ PathGenerator::CalculatePath() for %u \n", _sourceUnit->GetGUIDLow());
 
     // make sure navMesh works - we can run on map w/o mmap
     // check if the start and end point have a .mmtile loaded (can we pass via not loaded tile on the way?)
-    if (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING))
+    if (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) ||
+        !HaveTile(start) || !HaveTile(dest))
     {
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() navmesh is not initialized for %u \n", _sourceUnit->GetGUIDLow());
+        BuildShortcut();
         _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
-        _pathPoints.push_back(start);
-        _pathPoints.push_back(dest);
         return true;
     }
 
     UpdateFilter();
 
-    float startPos[3];
-    startPos[0] = -y;
-    startPos[1] = z;
-    startPos[2] = -x;
+    BuildPolyPath(start, dest);
+    return true;
+}
 
-    float endPos[3];
-    endPos[0] = -destY;
-    endPos[1] = destZ;
-    endPos[2] = -destX;
+dtPolyRef PathGenerator::GetPathPolyByPosition(dtPolyRef const* polyPath, uint32 polyPathSize, float const* point, float* distance) const
+{
+    if (!polyPath || !polyPathSize)
+        return INVALID_POLYREF;
 
-    float polyPickExt[3];
-    polyPickExt[0] = 2.5f;
-    polyPickExt[1] = 2.5f;
-    polyPickExt[2] = 2.5f;
+    dtPolyRef nearestPoly = INVALID_POLYREF;
+    float minDist2d = FLT_MAX;
+    float minDist3d = 0.0f;
 
-    //
-    dtPolyRef startRef;
-    dtPolyRef endRef;
+    for (uint32 i = 0; i < polyPathSize; ++i)
+    {
+        float closestPoint[VERTEX_SIZE];
+        if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(polyPath[i], point, closestPoint)))
+            continue;
 
-    float nearestPt[3];
+        float d = dtVdist2DSqr(point, closestPoint);
+        if (d < minDist2d)
+        {
+            minDist2d = d;
+            nearestPoly = polyPath[i];
+            minDist3d = dtVdistSqr(point, closestPoint);
+        }
 
-    _navMeshQuery->findNearestPoly(startPos, polyPickExt, &_filter, &startRef, nearestPt);
-    _navMeshQuery->findNearestPoly(endPos, polyPickExt, &_filter, &endRef, nearestPt);
+        if (minDist2d < 1.0f) // shortcut out - close enough for us
+            break;
+    }
+
+    if (distance)
+        *distance = dtSqrt(minDist3d);
+
+    return (minDist2d < 3.0f) ? nearestPoly : INVALID_POLYREF;
+}
 
-    if (!startRef || !endRef)
+dtPolyRef PathGenerator::GetPolyByLocation(float const* point, float* distance) const
+{
+    // first we check the current path
+    // if the current path doesn't contain the current poly,
+    // we need to use the expensive navMesh.findNearestPoly
+    dtPolyRef polyRef = GetPathPolyByPosition(_pathPolyRefs, _polyLength, point, distance);
+    if (polyRef != INVALID_POLYREF)
+        return polyRef;
+
+    // we don't have it in our old path
+    // try to get it by findNearestPoly()
+    // first try with low search box
+    float extents[VERTEX_SIZE] = {3.0f, 5.0f, 3.0f};    // bounds of poly search area
+    float closestPoint[VERTEX_SIZE] = {0.0f, 0.0f, 0.0f};
+    if (dtStatusSucceed(_navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint)) && polyRef != INVALID_POLYREF)
     {
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() for %u no polygons found for start and end locations\n", _sourceUnit->GetGUIDLow());
-        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
-        _pathPoints.push_back(start);
-        _pathPoints.push_back(dest);
-        return false;
+        *distance = dtVdist(closestPoint, point);
+        return polyRef;
     }
 
-    int hops;
-    dtPolyRef* hopBuffer = new dtPolyRef[8192];
-    dtStatus status = _navMeshQuery->findPath(startRef, endRef, startPos, endPos, &_filter, hopBuffer, &hops, 8192);
+    // still nothing ..
+    // try with bigger search box
+    // Note that the extent should not overlap more than 128 polygons in the navmesh (see dtNavMeshQuery::findNearestPoly)
+    extents[1] = 50.0f;
 
-    if (!dtStatusSucceed(status))
+    if (dtStatusSucceed(_navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint)) && polyRef != INVALID_POLYREF)
     {
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() for %u no path found for start and end locations\n", _sourceUnit->GetGUIDLow());
-        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
-        _pathPoints.push_back(start);
-        _pathPoints.push_back(dest);
-        return false;
+        *distance = dtVdist(closestPoint, point);
+        return polyRef;
     }
 
-    int resultHopCount;
-    float* straightPath = new float[2048 * 3];
-    unsigned char* pathFlags = new unsigned char[2048];
-    dtPolyRef* pathRefs = new dtPolyRef[2048];
+    return INVALID_POLYREF;
+}
+
+void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 const& endPos)
+{
+    // *** getting start/end poly logic ***
+
+    float distToStartPoly, distToEndPoly;
+    float startPoint[VERTEX_SIZE] = {startPos.y, startPos.z, startPos.x};
+    float endPoint[VERTEX_SIZE] = {endPos.y, endPos.z, endPos.x};
+
+    dtPolyRef startPoly = GetPolyByLocation(startPoint, &distToStartPoly);
+    dtPolyRef endPoly = GetPolyByLocation(endPoint, &distToEndPoly);
 
-    status = _navMeshQuery->findStraightPath(startPos, endPos, hopBuffer, hops, straightPath, pathFlags, pathRefs, &resultHopCount, 2048);
-    if (!dtStatusSucceed(status))
+    // we have a hole in our mesh
+    // make shortcut path and mark it as NOPATH ( with flying and swimming exception )
+    // its up to caller how he will use this info
+    if (startPoly == INVALID_POLYREF || endPoly == INVALID_POLYREF)
     {
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() for %u no straight path found for start and end locations\n", _sourceUnit->GetGUIDLow());
-        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
-        _pathPoints.push_back(start);
-        _pathPoints.push_back(dest);
-        return false;
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPoly == 0 || endPoly == 0)\n");
+        BuildShortcut();
+        bool path = _sourceUnit->GetTypeId() == TYPEID_UNIT && _sourceUnit->ToCreature()->CanFly();
+
+        bool waterPath = _sourceUnit->GetTypeId() == TYPEID_UNIT && _sourceUnit->ToCreature()->CanSwim();
+        if (waterPath)
+        {
+            // Check both start and end points, if they're both in water, then we can *safely* let the creature move
+            for (uint32 i = 0; i < _pathPoints.size(); ++i)
+            {
+                ZLiquidStatus status = _sourceUnit->GetBaseMap()->getLiquidStatus(_pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z, MAP_ALL_LIQUIDS, NULL);
+                // One of the points is not in the water, cancel movement.
+                if (status == LIQUID_MAP_NO_WATER)
+                {
+                    waterPath = false;
+                    break;
+                }
+            }
+        }
+
+        _type = (path || waterPath) ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH;
+        return;
     }
 
-    SmoothPath(polyPickExt, resultHopCount, straightPath); // Separate the path from the walls
+    // we may need a better number here
+    bool farFromPoly = (distToStartPoly > 7.0f || distToEndPoly > 7.0f);
+    if (farFromPoly)
+    {
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: farFromPoly distToStartPoly=%.3f distToEndPoly=%.3f\n", distToStartPoly, distToEndPoly);
 
-    for (uint32 i = 0; i < resultHopCount; ++i)
+        bool buildShotrcut = false;
+        if (_sourceUnit->GetTypeId() == TYPEID_UNIT)
+        {
+            Creature* owner = (Creature*)_sourceUnit;
+
+            G3D::Vector3 const& p = (distToStartPoly > 7.0f) ? startPos : endPos;
+            if (_sourceUnit->GetBaseMap()->IsUnderWater(p.x, p.y, p.z))
+            {
+                TC_LOG_DEBUG("maps", "++ BuildPolyPath :: underWater case\n");
+                if (owner->CanSwim())
+                    buildShotrcut = true;
+            }
+            else
+            {
+                TC_LOG_DEBUG("maps", "++ BuildPolyPath :: flying case\n");
+                if (owner->CanFly())
+                    buildShotrcut = true;
+            }
+        }
+
+        if (buildShotrcut)
+        {
+            BuildShortcut();
+            _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
+            return;
+        }
+        else
+        {
+            float closestPoint[VERTEX_SIZE];
+            // we may want to use closestPointOnPolyBoundary instead
+            if (dtStatusSucceed(_navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint)))
+            {
+                dtVcopy(endPoint, closestPoint);
+                SetActualEndPosition(G3D::Vector3(endPoint[2], endPoint[0], endPoint[1]));
+            }
+
+            _type = PATHFIND_INCOMPLETE;
+        }
+    }
+
+    // *** poly path generating logic ***
+
+    // start and end are on same polygon
+    // just need to move in straight line
+    if (startPoly == endPoly)
     {
-        _pathPoints.push_back(G3D::Vector3(-straightPath[i * 3 + 2], -straightPath[i * 3 + 0], straightPath[i * 3 + 1]));
-        TC_LOG_DEBUG("maps", "PathGenerator::CalculatePath() for %u path point %u: (%f, %f, %f)", _sourceUnit->GetGUIDLow(), i, _pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z);
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPoly == endPoly)\n");
+
+        BuildShortcut();
+
+        _pathPolyRefs[0] = startPoly;
+        _polyLength = 1;
+
+        _type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL;
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: path type %d\n", _type);
+        return;
     }
 
-    _type = PATHFIND_NORMAL;
-    return true;
+    // look for startPoly/endPoly in current path
+    /// @todo we can merge it with getPathPolyByPosition() loop
+    bool startPolyFound = false;
+    bool endPolyFound = false;
+    uint32 pathStartIndex = 0;
+    uint32 pathEndIndex = 0;
+
+    if (_polyLength)
+    {
+        for (; pathStartIndex < _polyLength; ++pathStartIndex)
+        {
+            // here to carch few bugs
+            ASSERT(_pathPolyRefs[pathStartIndex] != INVALID_POLYREF);
+
+            if (_pathPolyRefs[pathStartIndex] == startPoly)
+            {
+                startPolyFound = true;
+                break;
+            }
+        }
+
+        for (pathEndIndex = _polyLength-1; pathEndIndex > pathStartIndex; --pathEndIndex)
+            if (_pathPolyRefs[pathEndIndex] == endPoly)
+            {
+                endPolyFound = true;
+                break;
+            }
+    }
+
+    if (startPolyFound && endPolyFound)
+    {
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPolyFound && endPolyFound)\n");
+
+        // we moved along the path and the target did not move out of our old poly-path
+        // our path is a simple subpath case, we have all the data we need
+        // just "cut" it out
+
+        _polyLength = pathEndIndex - pathStartIndex + 1;
+        memmove(_pathPolyRefs, _pathPolyRefs + pathStartIndex, _polyLength * sizeof(dtPolyRef));
+    }
+    else if (startPolyFound && !endPolyFound)
+    {
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPolyFound && !endPolyFound)\n");
+
+        // we are moving on the old path but target moved out
+        // so we have atleast part of poly-path ready
+
+        _polyLength -= pathStartIndex;
+
+        // try to adjust the suffix of the path instead of recalculating entire length
+        // at given interval the target cannot get too far from its last location
+        // thus we have less poly to cover
+        // sub-path of optimal path is optimal
+
+        // take ~80% of the original length
+        /// @todo play with the values here
+        uint32 prefixPolyLength = uint32(_polyLength * 0.8f + 0.5f);
+        memmove(_pathPolyRefs, _pathPolyRefs+pathStartIndex, prefixPolyLength * sizeof(dtPolyRef));
+
+        dtPolyRef suffixStartPoly = _pathPolyRefs[prefixPolyLength-1];
+
+        // we need any point on our suffix start poly to generate poly-path, so we need last poly in prefix data
+        float suffixEndPoint[VERTEX_SIZE];
+        if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)))
+        {
+            // we can hit offmesh connection as last poly - closestPointOnPoly() don't like that
+            // try to recover by using prev polyref
+            --prefixPolyLength;
+            suffixStartPoly = _pathPolyRefs[prefixPolyLength-1];
+            if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)))
+            {
+                // suffixStartPoly is still invalid, error state
+                BuildShortcut();
+                _type = PATHFIND_NOPATH;
+                return;
+            }
+        }
+
+        // generate suffix
+        uint32 suffixPolyLength = 0;
+        dtStatus dtResult = _navMeshQuery->findPath(
+                                suffixStartPoly,    // start polygon
+                                endPoly,            // end polygon
+                                suffixEndPoint,     // start position
+                                endPoint,           // end position
+                                &_filter,            // polygon search filter
+                                _pathPolyRefs + prefixPolyLength - 1,    // [out] path
+                                (int*)&suffixPolyLength,
+                                MAX_PATH_LENGTH-prefixPolyLength);   // max number of polygons in output path
+
+        if (!suffixPolyLength || dtStatusFailed(dtResult))
+        {
+            // this is probably an error state, but we'll leave it
+            // and hopefully recover on the next Update
+            // we still need to copy our preffix
+            TC_LOG_ERROR("maps", "%u's Path Build failed: 0 length path", _sourceUnit->GetGUIDLow());
+        }
+
+        TC_LOG_DEBUG("maps", "++  m_polyLength=%u prefixPolyLength=%u suffixPolyLength=%u \n", _polyLength, prefixPolyLength, suffixPolyLength);
+
+        // new path = prefix + suffix - overlap
+        _polyLength = prefixPolyLength + suffixPolyLength - 1;
+    }
+    else
+    {
+        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (!startPolyFound && !endPolyFound)\n");
+
+        // either we have no path at all -> first run
+        // or something went really wrong -> we aren't moving along the path to the target
+        // just generate new path
+
+        // free and invalidate old path data
+        Clear();
+
+        dtStatus dtResult = _navMeshQuery->findPath(
+                startPoly,          // start polygon
+                endPoly,            // end polygon
+                startPoint,         // start position
+                endPoint,           // end position
+                &_filter,           // polygon search filter
+                _pathPolyRefs,     // [out] path
+                (int*)&_polyLength,
+                MAX_PATH_LENGTH);   // max number of polygons in output path
+
+        if (!_polyLength || dtStatusFailed(dtResult))
+        {
+            // only happens if we passed bad data to findPath(), or navmesh is messed up
+            TC_LOG_ERROR("maps", "%u's Path Build failed: 0 length path", _sourceUnit->GetGUIDLow());
+            BuildShortcut();
+            _type = PATHFIND_NOPATH;
+            return;
+        }
+    }
+
+    // by now we know what type of path we can get
+    if (_pathPolyRefs[_polyLength - 1] == endPoly && !(_type & PATHFIND_INCOMPLETE))
+        _type = PATHFIND_NORMAL;
+    else
+        _type = PATHFIND_INCOMPLETE;
+
+    // generate the point-path out of our up-to-date poly-path
+    BuildPointPath(startPoint, endPoint);
+}
+
+void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoint)
+{
+    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];
+    uint32 pointCount = 0;
+    dtStatus dtResult = DT_FAILURE;
+    if (_useStraightPath)
+    {
+        dtResult = _navMeshQuery->findStraightPath(
+                startPoint,         // start position
+                endPoint,           // end position
+                _pathPolyRefs,     // current path
+                _polyLength,       // lenth of current path
+                pathPoints,         // [out] path corner points
+                NULL,               // [out] flags
+                NULL,               // [out] shortened path
+                (int*)&pointCount,
+                _pointPathLimit);   // maximum number of points/polygons to use
+    }
+    else
+    {
+        dtResult = FindSmoothPath(
+                startPoint,         // start position
+                endPoint,           // end position
+                _pathPolyRefs,     // current path
+                _polyLength,       // length of current path
+                pathPoints,         // [out] path corner points
+                (int*)&pointCount,
+                _pointPathLimit);    // maximum number of points
+    }
+
+    if (pointCount < 2 || dtStatusFailed(dtResult))
+    {
+        // only happens if pass bad data to findStraightPath or navmesh is broken
+        // single point paths can be generated here
+        /// @todo check the exact cases
+        TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath FAILED! path sized %d returned\n", pointCount);
+        BuildShortcut();
+        _type = PATHFIND_NOPATH;
+        return;
+    }
+    else if (pointCount == _pointPathLimit)
+    {
+        TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d\n", pointCount, _pointPathLimit);
+        BuildShortcut();
+        _type = PATHFIND_SHORT;
+        return;
+    }
+
+    _pathPoints.resize(pointCount);
+    for (uint32 i = 0; i < pointCount; ++i)
+        _pathPoints[i] = G3D::Vector3(pathPoints[i*VERTEX_SIZE+2], pathPoints[i*VERTEX_SIZE], pathPoints[i*VERTEX_SIZE+1]);
+
+    NormalizePath();
+
+    // first point is always our current location - we need the next one
+    SetActualEndPosition(_pathPoints[pointCount-1]);
+
+    // force the given destination, if needed
+    if (_forceDestination &&
+        (!(_type & PATHFIND_NORMAL) || !InRange(GetEndPosition(), GetActualEndPosition(), 1.0f, 1.0f)))
+    {
+        // we may want to keep partial subpath
+        if (Dist3DSqr(GetActualEndPosition(), GetEndPosition()) < 0.3f * Dist3DSqr(GetStartPosition(), GetEndPosition()))
+        {
+            SetActualEndPosition(GetEndPosition());
+            _pathPoints[_pathPoints.size()-1] = GetEndPosition();
+        }
+        else
+        {
+            SetActualEndPosition(GetEndPosition());
+            BuildShortcut();
+        }
+
+        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
+    }
+
+    TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath path type %d size %d poly-size %d\n", _type, pointCount, _polyLength);
+}
+
+void PathGenerator::NormalizePath()
+{
+    for (uint32 i = 0; i < _pathPoints.size(); ++i)
+        _sourceUnit->UpdateAllowedPositionZ(_pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z);
+}
+
+void PathGenerator::BuildShortcut()
+{
+    TC_LOG_DEBUG("maps", "++ BuildShortcut :: making shortcut\n");
+
+    Clear();
+
+    // make two point path, our curr pos is the start, and dest is the end
+    _pathPoints.resize(2);
+
+    // set start and a default next position
+    _pathPoints[0] = GetStartPosition();
+    _pathPoints[1] = GetActualEndPosition();
+
+    NormalizePath();
+
+    _type = PATHFIND_SHORTCUT;
 }
 
 void PathGenerator::CreateFilter()
 {
-    uint16 includeFlags = POLY_FLAG_WALK | POLY_FLAG_SWIM;
+    uint16 includeFlags = 0;
     uint16 excludeFlags = 0;
 
-    if (_sourceUnit->GetTypeId() == TYPEID_UNIT && !_sourceUnit->ToCreature()->CanSwim())
+    if (_sourceUnit->GetTypeId() == TYPEID_UNIT)
     {
-        includeFlags = POLY_FLAG_WALK;
-        excludeFlags = POLY_FLAG_SWIM;
+        Creature* creature = (Creature*)_sourceUnit;
+        if (creature->CanWalk())
+            includeFlags |= NAV_GROUND;          // walk
+
+        // creatures don't take environmental damage
+        if (creature->CanSwim())
+            includeFlags |= (NAV_WATER | NAV_MAGMA | NAV_SLIME);           // swim
+    }
+    else // assume Player
+    {
+        // perfect support not possible, just stay 'safe'
+        includeFlags |= (NAV_GROUND | NAV_WATER | NAV_MAGMA | NAV_SLIME);
     }
 
     _filter.setIncludeFlags(includeFlags);
@@ -180,130 +535,275 @@ void PathGenerator::CreateFilter()
 
 void PathGenerator::UpdateFilter()
 {
+    // allow creatures to cheat and use different movement types if they are moved
+    // forcefully into terrain they can't normally move in
+    if (_sourceUnit->IsInWater() || _sourceUnit->IsUnderWater())
+    {
+        uint16 includedFlags = _filter.getIncludeFlags();
+        includedFlags |= GetNavTerrain(_sourceUnit->GetPositionX(),
+                                       _sourceUnit->GetPositionY(),
+                                       _sourceUnit->GetPositionZ());
 
+        _filter.setIncludeFlags(includedFlags);
+    }
 }
 
-float PathGenerator::GetTriangleArea(float* verts, int nv)
+NavTerrain PathGenerator::GetNavTerrain(float x, float y, float z)
 {
-    float area = 0;
-    for (int i = 0; i < nv - 1; i++)
-        area += verts[i * 3] * verts[i * 3 + 5] - verts[i * 3 + 3] * verts[i * 3 + 2];
-    area += verts[(nv - 1) * 3] * verts[2] - verts[0] * verts[(nv - 1) * 3 + 2];
-    return area * 0.5f;
-}
+    LiquidData data;
+    ZLiquidStatus liquidStatus = _sourceUnit->GetBaseMap()->getLiquidStatus(x, y, z, MAP_ALL_LIQUIDS, &data);
+    if (liquidStatus == LIQUID_MAP_NO_WATER)
+        return NAV_GROUND;
 
-bool PathGenerator::PointInPoly(float* pos, float* verts, int nv, float err)
-{
-    // Poly area
-    float area = abs(PathGenerator::GetTriangleArea(verts, nv));
-
-    // Calculate each area of the triangles
-    float testTri[9];
-    memcpy(testTri, pos, sizeof(float) * 3);
-    float area1 = 0;
-    for(int i = 0; i < nv - 1; ++i)
+    switch (data.type_flags)
     {
-        memcpy(&testTri[3], &verts[i * 3], sizeof(float) * 3);
-        memcpy(&testTri[6], &verts[i * 3 + 3], sizeof(float) * 3);
-        area1 += abs(PathGenerator::GetTriangleArea(testTri, 3));
-        if (area1 - err > area)
-            return false;
+        case MAP_LIQUID_TYPE_WATER:
+        case MAP_LIQUID_TYPE_OCEAN:
+            return NAV_WATER;
+        case MAP_LIQUID_TYPE_MAGMA:
+            return NAV_MAGMA;
+        case MAP_LIQUID_TYPE_SLIME:
+            return NAV_SLIME;
+        default:
+            return NAV_GROUND;
     }
-
-    // Last one
-    memcpy(&testTri[3], verts, sizeof(float) * 3);
-    memcpy(&testTri[6], &verts[nv * 3 - 3] , sizeof(float) * 3);
-    area1 += abs(PathGenerator::GetTriangleArea(testTri, 3));
-
-    return abs(area1 - area) < err;
 }
 
-float PathGenerator::DistanceToWall(float* polyPickExt, float* pos, float* hitPos, float* hitNormal)
+bool PathGenerator::HaveTile(const G3D::Vector3& p) const
 {
-    float distanceToWall = 0;
-    dtPolyRef ref;
+    int tx = -1, ty = -1;
+    float point[VERTEX_SIZE] = {p.y, p.z, p.x};
 
-    dtStatus status = _navMeshQuery->findNearestPoly(pos, polyPickExt, &_filter, &ref, 0);
+    _navMesh->calcTileLoc(point, &tx, &ty);
 
-    if (!dtStatusSucceed(status) || ref == 0)
-        return -1;
+    /// Workaround
+    /// For some reason, often the tx and ty variables wont get a valid value
+    /// Use this check to prevent getting negative tile coords and crashing on getTileAt
+    if (tx < 0 || ty < 0)
+        return false;
 
-    const dtMeshTile* tile = 0;
-    const dtPoly* poly = 0;
-    if (dtStatusFailed(_navMesh->getTileAndPolyByRef(ref, &tile, &poly)))
-        return -1;
+    return (_navMesh->getTileAt(tx, ty, 0) != NULL);
+}
 
-    // Collect vertices.
-    float verts[DT_VERTS_PER_POLYGON * 3];
-    int nv = 0;
-    for (unsigned char i = 0; i < poly->vertCount; ++i)
+uint32 PathGenerator::FixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited)
+{
+    int32 furthestPath = -1;
+    int32 furthestVisited = -1;
+
+    // Find furthest common polygon.
+    for (int32 i = npath-1; i >= 0; --i)
     {
-        dtVcopy(&verts[nv * 3], &tile->verts[poly->verts[i] * 3]);
-        nv++;
+        bool found = false;
+        for (int32 j = nvisited-1; j >= 0; --j)
+        {
+            if (path[i] == visited[j])
+            {
+                furthestPath = i;
+                furthestVisited = j;
+                found = true;
+            }
+        }
+        if (found)
+            break;
     }
 
-    bool inside = PathGenerator::PointInPoly(pos, verts, nv, 0.05f);
-    if (!inside)
-        return -1;
+    // If no intersection found just return current path.
+    if (furthestPath == -1 || furthestVisited == -1)
+        return npath;
+
+    // Concatenate paths.
+
+    // Adjust beginning of the buffer to include the visited.
+    uint32 req = nvisited - furthestVisited;
+    uint32 orig = uint32(furthestPath + 1) < npath ? furthestPath + 1 : npath;
+    uint32 size = npath > orig ? npath - orig : 0;
+    if (req + size > maxPath)
+        size = maxPath-req;
 
-    if (!dtStatusSucceed(_navMeshQuery->findDistanceToWall(ref, pos, 100.0f, &_filter, &distanceToWall, hitPos, hitNormal)))
-        return -1;
+    if (size)
+        memmove(path + req, path + orig, size * sizeof(dtPolyRef));
 
-    return distanceToWall;
+    // Store visited
+    for (uint32 i = 0; i < req; ++i)
+        path[i] = visited[(nvisited - 1) - i];
+
+    return req+size;
 }
 
-void PathGenerator::SmoothPath(float* polyPickExt, int pathLength, float*& straightPath)
+bool PathGenerator::GetSteerTarget(float const* startPos, float const* endPos,
+                              float minTargetDist, dtPolyRef const* path, uint32 pathSize,
+                              float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef)
 {
-    float hitPos[3];
-    float hitNormal[3];
-    float testPos[3];
-    float distanceToWall = 0;
-    float up[]= { 0, 1, 0 };
-    float origDis = 0;
-
-    for (int i = 1; i < pathLength - 1; ++i)
+    // Find steer target.
+    static const uint32 MAX_STEER_POINTS = 3;
+    float steerPath[MAX_STEER_POINTS*VERTEX_SIZE];
+    unsigned char steerPathFlags[MAX_STEER_POINTS];
+    dtPolyRef steerPathPolys[MAX_STEER_POINTS];
+    uint32 nsteerPath = 0;
+    dtStatus dtResult = _navMeshQuery->findStraightPath(startPos, endPos, path, pathSize,
+                                                steerPath, steerPathFlags, steerPathPolys, (int*)&nsteerPath, MAX_STEER_POINTS);
+    if (!nsteerPath || dtStatusFailed(dtResult))
+        return false;
+
+    // Find vertex far enough to steer to.
+    uint32 ns = 0;
+    while (ns < nsteerPath)
     {
-        dtPolyRef pt;
-        float* curPoi = &straightPath[i * 3];
-        distanceToWall = DistanceToWall(polyPickExt, curPoi, hitPos, hitNormal);
+        // Stop at Off-Mesh link or when point is further than slop away.
+        if ((steerPathFlags[ns] & DT_STRAIGHTPATH_OFFMESH_CONNECTION) ||
+            !InRangeYZX(&steerPath[ns*VERTEX_SIZE], startPos, minTargetDist, 1000.0f))
+            break;
+        ns++;
+    }
+    // Failed to find good point to steer to.
+    if (ns >= nsteerPath)
+        return false;
+
+    dtVcopy(steerPos, &steerPath[ns*VERTEX_SIZE]);
+    steerPos[1] = startPos[1];  // keep Z value
+    steerPosFlag = steerPathFlags[ns];
+    steerPosRef = steerPathPolys[ns];
 
-        if (distanceToWall < PathGenerator::MinWallDistance && distanceToWall >= 0)
+    return true;
+}
+
+dtStatus PathGenerator::FindSmoothPath(float const* startPos, float const* endPos,
+                                     dtPolyRef const* polyPath, uint32 polyPathSize,
+                                     float* smoothPath, int* smoothPathSize, uint32 maxSmoothPathSize)
+{
+    *smoothPathSize = 0;
+    uint32 nsmoothPath = 0;
+
+    dtPolyRef polys[MAX_PATH_LENGTH];
+    memcpy(polys, polyPath, sizeof(dtPolyRef)*polyPathSize);
+    uint32 npolys = polyPathSize;
+
+    float iterPos[VERTEX_SIZE], targetPos[VERTEX_SIZE];
+    if (dtStatusFailed(_navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos)))
+        return DT_FAILURE;
+
+    if (dtStatusFailed(_navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos)))
+        return DT_FAILURE;
+
+    dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos);
+    nsmoothPath++;
+
+    // Move towards target a small advancement at a time until target reached or
+    // when ran out of memory to store the path.
+    while (npolys && nsmoothPath < maxSmoothPathSize)
+    {
+        // Find location to steer towards.
+        float steerPos[VERTEX_SIZE];
+        unsigned char steerPosFlag;
+        dtPolyRef steerPosRef = INVALID_POLYREF;
+
+        if (!GetSteerTarget(iterPos, targetPos, SMOOTH_PATH_SLOP, polys, npolys, steerPos, steerPosFlag, steerPosRef))
+            break;
+
+        bool endOfPath = (steerPosFlag & DT_STRAIGHTPATH_END);
+        bool offMeshConnection = (steerPosFlag & DT_STRAIGHTPATH_OFFMESH_CONNECTION);
+
+        // Find movement delta.
+        float delta[VERTEX_SIZE];
+        dtVsub(delta, steerPos, iterPos);
+        float len = dtSqrt(dtVdot(delta, delta));
+        // If the steer target is end of path or off-mesh link, do not move past the location.
+        if ((endOfPath || offMeshConnection) && len < SMOOTH_PATH_STEP_SIZE)
+            len = 1.0f;
+        else
+            len = SMOOTH_PATH_STEP_SIZE / len;
+
+        float moveTgt[VERTEX_SIZE];
+        dtVmad(moveTgt, iterPos, delta, len);
+
+        // Move
+        float result[VERTEX_SIZE];
+        const static uint32 MAX_VISIT_POLY = 16;
+        dtPolyRef visited[MAX_VISIT_POLY];
+
+        uint32 nvisited = 0;
+        _navMeshQuery->moveAlongSurface(polys[0], iterPos, moveTgt, &_filter, result, visited, (int*)&nvisited, MAX_VISIT_POLY);
+        npolys = FixupCorridor(polys, npolys, MAX_PATH_LENGTH, visited, nvisited);
+
+        _navMeshQuery->getPolyHeight(polys[0], result, &result[1]);
+        result[1] += 0.5f;
+        dtVcopy(iterPos, result);
+
+        // Handle end of path and off-mesh links when close enough.
+        if (endOfPath && InRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f))
         {
-            float vec[3];
-            dtVsub(vec, &straightPath[i * 3 - 3], &straightPath[i * 3]);
-            // If distanceToWall is 0 means the point is in the edge, so we can't get the hitpos.
-            if (distanceToWall == 0)
+            // Reached end of path.
+            dtVcopy(iterPos, targetPos);
+            if (nsmoothPath < maxSmoothPathSize)
             {
-                // Test the left side
-                dtVcross(testPos, vec, up);
-                dtVadd(testPos, testPos, curPoi);
-                float ft = PathGenerator::MinWallDistance / dtVdist(testPos, curPoi);
-                dtVlerp(testPos, curPoi, testPos, ft);
-                distanceToWall = DistanceToWall(polyPickExt, testPos, hitPos, hitNormal);
-                if (abs(PathGenerator::MinWallDistance - distanceToWall) > 0.1f)
-                {
-                    // Test the right side
-                    dtVcross(testPos, up, vec);
-                    dtVadd(testPos, testPos, curPoi);
-                    ft = PathGenerator::MinWallDistance / dtVdist(testPos, curPoi);
-                    dtVlerp(testPos, curPoi, testPos, ft);
-                    distanceToWall = DistanceToWall(polyPickExt, testPos, hitPos, hitNormal);
-                }
-
-                // If the test point is better than the orig point, replace it.
-                if (abs(distanceToWall - PathGenerator::MinWallDistance) < 0.1f)
-                    dtVcopy(curPoi, testPos);
+                dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos);
+                nsmoothPath++;
             }
-            else
+            break;
+        }
+        else if (offMeshConnection && InRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f))
+        {
+            // Advance the path up to and over the off-mesh connection.
+            dtPolyRef prevRef = INVALID_POLYREF;
+            dtPolyRef polyRef = polys[0];
+            uint32 npos = 0;
+            while (npos < npolys && polyRef != steerPosRef)
             {
-                // We get the hitpos with a ray
-                float ft = PathGenerator::MinWallDistance / distanceToWall;
-                dtVlerp(testPos, hitPos, curPoi, ft);
-                distanceToWall = DistanceToWall(polyPickExt, testPos, hitPos, hitNormal);
+                prevRef = polyRef;
+                polyRef = polys[npos];
+                npos++;
+            }
+
+            for (uint32 i = npos; i < npolys; ++i)
+                polys[i-npos] = polys[i];
 
-                if (abs(distanceToWall - PathGenerator::MinWallDistance) < 0.1f)
-                    dtVcopy(curPoi, testPos);
+            npolys -= npos;
+
+            // Handle the connection.
+            float startPos[VERTEX_SIZE], endPos[VERTEX_SIZE];
+            if (dtStatusSucceed(_navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos)))
+            {
+                if (nsmoothPath < maxSmoothPathSize)
+                {
+                    dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], startPos);
+                    nsmoothPath++;
+                }
+                // Move position at the other side of the off-mesh link.
+                dtVcopy(iterPos, endPos);
+                _navMeshQuery->getPolyHeight(polys[0], iterPos, &iterPos[1]);
+                iterPos[1] += 0.5f;
             }
         }
+
+        // Store results.
+        if (nsmoothPath < maxSmoothPathSize)
+        {
+            dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos);
+            nsmoothPath++;
+        }
     }
+
+    *smoothPathSize = nsmoothPath;
+
+    // this is most likely a loop
+    return nsmoothPath < MAX_POINT_PATH_LENGTH ? DT_SUCCESS : DT_FAILURE;
+}
+
+bool PathGenerator::InRangeYZX(const float* v1, const float* v2, float r, float h) const
+{
+    const float dx = v2[0] - v1[0];
+    const float dy = v2[1] - v1[1]; // elevation
+    const float dz = v2[2] - v1[2];
+    return (dx * dx + dz * dz) < r * r && fabsf(dy) < h;
+}
+
+bool PathGenerator::InRange(G3D::Vector3 const& p1, G3D::Vector3 const& p2, float r, float h) const
+{
+    G3D::Vector3 d = p1 - p2;
+    return (d.x * d.x + d.y * d.y) < r * r && fabsf(d.z) < h;
+}
+
+float PathGenerator::Dist3DSqr(G3D::Vector3 const& p1, G3D::Vector3 const& p2) const
+{
+    return (p1 - p2).squaredLength();
 }
diff --git a/src/server/game/Movement/PathGenerator.h b/src/server/game/Movement/PathGenerator.h
index 075d6dabc9f..ac66b7cec57 100644
--- a/src/server/game/Movement/PathGenerator.h
+++ b/src/server/game/Movement/PathGenerator.h
@@ -26,6 +26,18 @@
 
 class Unit;
 
+// 74*4.0f=296y  number_of_points*interval = max_path_len
+// this is way more than actual evade range
+// I think we can safely cut those down even more
+#define MAX_PATH_LENGTH         74
+#define MAX_POINT_PATH_LENGTH   74
+
+#define SMOOTH_PATH_STEP_SIZE   4.0f
+#define SMOOTH_PATH_SLOP        0.3f
+
+#define VERTEX_SIZE       3
+#define INVALID_POLYREF   0
+
 enum PathType
 {
     PATHFIND_BLANK          = 0x00,   // path not built yet
@@ -37,12 +49,6 @@ enum PathType
     PATHFIND_SHORT          = 0x20,   // path is longer or equal to its limited path length
 };
 
-enum PolyFlag
-{
-    POLY_FLAG_WALK  = 1,
-    POLY_FLAG_SWIM  = 2
-};
-
 class PathGenerator
 {
     public:
@@ -53,6 +59,10 @@ class PathGenerator
         // return: true if new path was calculated, false otherwise (no change needed)
         bool CalculatePath(float destX, float destY, float destZ, bool forceDest = false);
 
+        // option setters - use optional
+        void SetUseStraightPath(bool useStraightPath) { _useStraightPath = useStraightPath; }
+        void SetPathLengthLimit(float distance) { _pointPathLimit = std::min<uint32>(uint32(distance/SMOOTH_PATH_STEP_SIZE), MAX_POINT_PATH_LENGTH); }
+
         // result getters
         G3D::Vector3 const& GetStartPosition() const { return _startPosition; }
         G3D::Vector3 const& GetEndPosition() const { return _endPosition; }
@@ -61,13 +71,19 @@ class PathGenerator
         Movement::PointsArray const& GetPath() const { return _pathPoints; }
 
         PathType GetPathType() const { return _type; }
-        
-        static float MinWallDistance;
 
     private:
+
+        dtPolyRef _pathPolyRefs[MAX_PATH_LENGTH];   // array of detour polygon references
+        uint32 _polyLength;                         // number of polygons in the path
+
         Movement::PointsArray _pathPoints;  // our actual (x,y,z) path to the target
         PathType _type;                     // tells what kind of path this is
 
+        bool _useStraightPath;  // type of path will be generated
+        bool _forceDestination; // when set, we will always arrive at given point
+        uint32 _pointPathLimit; // limit point path size; min(this, MAX_POINT_PATH_LENGTH)
+
         G3D::Vector3 _startPosition;        // {x, y, z} of current location
         G3D::Vector3 _endPosition;          // {x, y, z} of the destination
         G3D::Vector3 _actualEndPosition;    // {x, y, z} of the closest possible point to given destination
@@ -81,16 +97,37 @@ class PathGenerator
         void SetStartPosition(G3D::Vector3 const& point) { _startPosition = point; }
         void SetEndPosition(G3D::Vector3 const& point) { _actualEndPosition = point; _endPosition = point; }
         void SetActualEndPosition(G3D::Vector3 const& point) { _actualEndPosition = point; }
+        void NormalizePath();
+
+        void Clear()
+        {
+            _polyLength = 0;
+            _pathPoints.clear();
+        }
 
-        // Path smoothing
-        void SmoothPath(float* polyPickExt, int pathLength, float*& straightPath);
-        float DistanceToWall(float* polyPickExt, float* pos, float* hitPos, float* hitNormal);
-        // dtPointInPolygon will return false when the point is too close to the edge, so we rewrite the test function.
-        static bool PointInPoly(float* pos, float* verts, int nv, float err);
-        static float GetTriangleArea(float* verts, int nv);
+        bool InRange(G3D::Vector3 const& p1, G3D::Vector3 const& p2, float r, float h) const;
+        float Dist3DSqr(G3D::Vector3 const& p1, G3D::Vector3 const& p2) const;
+        bool InRangeYZX(float const* v1, float const* v2, float r, float h) const;
 
+        dtPolyRef GetPathPolyByPosition(dtPolyRef const* polyPath, uint32 polyPathSize, float const* Point, float* Distance = NULL) const;
+        dtPolyRef GetPolyByLocation(float const* Point, float* Distance) const;
+        bool HaveTile(G3D::Vector3 const& p) const;
+
+        void BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 const& endPos);
+        void BuildPointPath(float const* startPoint, float const* endPoint);
+        void BuildShortcut();
+
+        NavTerrain GetNavTerrain(float x, float y, float z);
         void CreateFilter();
         void UpdateFilter();
+
+        // smooth path aux functions
+        uint32 FixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited);
+        bool GetSteerTarget(float const* startPos, float const* endPos, float minTargetDist, dtPolyRef const* path, uint32 pathSize, float* steerPos,
+                            unsigned char& steerPosFlag, dtPolyRef& steerPosRef);
+        dtStatus FindSmoothPath(float const* startPos, float const* endPos,
+                              dtPolyRef const* polyPath, uint32 polyPathSize,
+                              float* smoothPath, int* smoothPathSize, uint32 smoothPathMaxSize);
 };
 
 #endif
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index 417d7be78ad..0d5ba60df65 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -5234,6 +5234,7 @@ SpellCastResult Spell::CheckCast(bool strict)
                     target->GetContactPoint(m_caster, pos.m_positionX, pos.m_positionY, pos.m_positionZ);
                     target->GetFirstCollisionPosition(pos, CONTACT_DISTANCE, target->GetRelativeAngle(m_caster));
 
+                    m_preGeneratedPath.SetPathLengthLimit(m_spellInfo->GetMaxRange(true) * 1.5f);
                     bool result = m_preGeneratedPath.CalculatePath(pos.m_positionX, pos.m_positionY, pos.m_positionZ + target->GetObjectSize());
                     if (m_preGeneratedPath.GetPathType() & PATHFIND_SHORT)
                         return SPELL_FAILED_OUT_OF_RANGE;
diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp
index e472e975777..ef6f2869ec5 100644
--- a/src/server/game/World/World.cpp
+++ b/src/server/game/World/World.cpp
@@ -152,7 +152,7 @@ World::~World()
         delete command;
 
     VMAP::VMapFactory::clear();
-    MMAP::MMapFactory::Clear();
+    MMAP::MMapFactory::clear();
 
     /// @todo free addSessQueue
 }
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index 81fc9f9b2b2..ba355d08d0c 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -186,7 +186,7 @@ public:
 
         uint32 haveMap = Map::ExistMap(mapId, gridX, gridY) ? 1 : 0;
         uint32 haveVMap = Map::ExistVMap(mapId, gridX, gridY) ? 1 : 0;
-        uint32 haveMMap = (MMAP::MMapFactory::IsPathfindingEnabled(mapId) && MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId())) ? 1 : 0;
+        uint32 haveMMap = (MMAP::MMapFactory::IsPathfindingEnabled(mapId) && MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId())) ? 1 : 0;
 
         if (haveVMap)
         {
diff --git a/src/server/scripts/Commands/cs_mmaps.cpp b/src/server/scripts/Commands/cs_mmaps.cpp
index f38717ba31e..37e7177cbc6 100644
--- a/src/server/scripts/Commands/cs_mmaps.cpp
+++ b/src/server/scripts/Commands/cs_mmaps.cpp
@@ -1,19 +1,19 @@
 /*
- * Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
- *
- * 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/>.
- */
+* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
+*
+* 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/>.
+*/
 
 /**
 * @file cs_mmaps.cpp
@@ -30,13 +30,11 @@
 #include "PointMovementGenerator.h"
 #include "PathGenerator.h"
 #include "MMapFactory.h"
-#include "DetourCommon.h"
 #include "Map.h"
 #include "TargetedMovementGenerator.h"
 #include "GridNotifiers.h"
 #include "GridNotifiersImpl.h"
 #include "CellImpl.h"
-#include "MMapManager.h"
 
 class mmaps_commandscript : public CommandScript
 {
@@ -48,152 +46,24 @@ public:
         static ChatCommand mmapCommandTable[] =
         {
             { "loadedtiles", rbac::RBAC_PERM_COMMAND_MMAP_LOADEDTILES, false, &HandleMmapLoadedTilesCommand, "", NULL },
-            { "loc",         rbac::RBAC_PERM_COMMAND_MMAP_LOC,         false, &HandleMmapLocCommand,         "", NULL },
-            { "path",        rbac::RBAC_PERM_COMMAND_MMAP_PATH,        false, &HandleMmapPathCommand,        "", NULL },
-            { "stats",       rbac::RBAC_PERM_COMMAND_MMAP_STATS,       false, &HandleMmapStatsCommand,       "", NULL },
-            { "testarea",    rbac::RBAC_PERM_COMMAND_MMAP_TESTAREA,    false, &HandleMmapTestArea,           "", NULL },
-            { NULL,          0,                                  false, NULL,                          "", NULL }
+            { "loc", rbac::RBAC_PERM_COMMAND_MMAP_LOC, false, &HandleMmapLocCommand, "", NULL },
+            { "path", rbac::RBAC_PERM_COMMAND_MMAP_PATH, false, &HandleMmapPathCommand, "", NULL },
+            { "stats", rbac::RBAC_PERM_COMMAND_MMAP_STATS, false, &HandleMmapStatsCommand, "", NULL },
+            { "testarea", rbac::RBAC_PERM_COMMAND_MMAP_TESTAREA, false, &HandleMmapTestArea, "", NULL },
+            { NULL, 0, false, NULL, "", NULL }
         };
 
         static ChatCommand commandTable[] =
         {
-            { "mmap", rbac::RBAC_PERM_COMMAND_MMAP, true, NULL, "", mmapCommandTable  },
-            { NULL,   0,                     false, NULL, "", NULL }
+            { "mmap", rbac::RBAC_PERM_COMMAND_MMAP, true, NULL, "", mmapCommandTable },
+            { NULL, 0, false, NULL, "", NULL }
         };
         return commandTable;
     }
 
-    static float Fix_GetXZArea(float* verts, int nv)
-    {
-        float area = 0;
-        for(int i=0; i<nv-1; i++)
-            area+=(verts[i*3]*verts[i*3+5]-verts[i*3+3]*verts[i*3+2]);
-        area += (verts[(nv-1)*3]*verts[2] - verts[0]*verts[(nv-1)*3+2]);
-        return area*0.5f;
-    }
-
-
-    //dtPointInPolygon will return false when the point is too close to the edge,so we rewite the test function.
-    static bool Fix_PointIsInPoly(float* pos,float* verts,int nv,float err)
-    {
-        //poly area
-        float area = abs(Fix_GetXZArea(verts,nv));
-
-        //calculate each area of triangles
-        float TestTri[9];
-        memcpy(TestTri,pos,sizeof(float)*3);
-        float area1 = 0;
-        for(int i=0;i<nv-1;++i)
-        {
-            memcpy(&TestTri[3],&verts[i*3],sizeof(float)*3);
-            memcpy(&TestTri[6],&verts[i*3+3],sizeof(float)*3);
-            area1+= abs(Fix_GetXZArea(TestTri,3));
-            if(area1-err>area)
-                return false;
-        }
-
-        //last one
-        memcpy(&TestTri[3],verts,sizeof(float)*3);
-        memcpy(&TestTri[6],&verts[nv*3-3],sizeof(float)*3);
-        area1+= abs(Fix_GetXZArea(TestTri,3));
-
-        return abs(area1-area)<err;
-    }
-
-
-    static float DistanceToWall(dtNavMeshQuery* navQuery, dtNavMesh* navMesh, float* polyPickExt, dtQueryFilter& filter, float* pos,float* hitPos,float* hitNormal)
-    {
-        float distanceToWall=0;
-        dtPolyRef ref;
-        if(dtStatusSucceed(navQuery->findNearestPoly(pos, polyPickExt, &filter, &ref, 0))==false || ref ==0)
-            return -1;
-
-        const dtMeshTile* tile = 0;
-        const dtPoly* poly = 0;
-        if (dtStatusFailed(navMesh->getTileAndPolyByRef(ref, &tile, &poly)))
-            return -1;
-
-        // Collect vertices.
-        float verts[DT_VERTS_PER_POLYGON*3];
-        int nv = 0;
-        for (int i = 0; i < (int)poly->vertCount; ++i)
-        {
-            dtVcopy(&verts[nv*3], &tile->verts[poly->verts[i]*3]);
-            nv++;
-        }
-
-        bool inside = Fix_PointIsInPoly(pos, verts, nv,0.05f);
-        if(inside == false)
-            return -1;
-
-        if(dtStatusSucceed(navQuery->findDistanceToWall(ref, pos, 100.0f, &filter, &distanceToWall, hitPos, hitNormal))==false)
-            return -1;
-
-        return distanceToWall;
-    }
-
-    #define MIN_WALL_DISTANCE 1.5f    //set this value bigger to make the path point far way from wall
-
-    //Try to fix the path,
-    static void FixPath(dtNavMesh* navMesh, dtNavMeshQuery* navQuery, float* polyPickExt, dtQueryFilter& filter, int pathLength, float*& straightPath)
-    {
-        float hitPos[3];
-        float hitNormal[3];
-        float TestPos[3];
-        float distanceToWall=0;
-        float up[3]={0,1,0};
-        float origDis = 0;
-
-        for(int i=1;i<pathLength-1;++i)
-        {
-            dtPolyRef pt;
-            float* pCurPoi=&straightPath[i*3];
-            distanceToWall = DistanceToWall(navQuery, navMesh, polyPickExt, filter, pCurPoi,hitPos,hitNormal);
-
-            if(distanceToWall<MIN_WALL_DISTANCE && distanceToWall>=0)
-            {
-                float vec[3];
-                dtVsub(vec,&straightPath[i*3-3],&straightPath[i*3]);
-                //distanceToWall is 0 means the point is in the edge.so we can't get the hitpos.
-                if(distanceToWall == 0)
-                {
-                    //test left side
-                    dtVcross(TestPos,vec,up);
-                    dtVadd(TestPos,TestPos,pCurPoi);
-                    float ft = MIN_WALL_DISTANCE/dtVdist(TestPos,pCurPoi);
-                    dtVlerp(TestPos,pCurPoi,TestPos,ft);
-                    distanceToWall = DistanceToWall(navQuery, navMesh, polyPickExt, filter,TestPos,hitPos,hitNormal);
-                    if(abs(MIN_WALL_DISTANCE - distanceToWall)>0.1f)
-                    {
-                        //test right side
-                        dtVcross(TestPos,up,vec);
-                        dtVadd(TestPos,TestPos,pCurPoi);
-                        ft = MIN_WALL_DISTANCE/dtVdist(TestPos,pCurPoi);
-                        dtVlerp(TestPos,pCurPoi,TestPos,ft);
-                        distanceToWall = DistanceToWall(navQuery, navMesh, polyPickExt, filter,TestPos,hitPos,hitNormal);
-                    }
-
-                    //if test point is better than the orig point,replace it.
-                    if(abs(distanceToWall-MIN_WALL_DISTANCE)<0.1f)
-                        dtVcopy(pCurPoi,TestPos);
-                }
-                else
-                {
-                    //ok,we get the hitpos,just make a ray
-                    float ft = MIN_WALL_DISTANCE/distanceToWall;
-                    dtVlerp(TestPos,hitPos,pCurPoi,ft);
-                    distanceToWall = DistanceToWall(navQuery, navMesh, polyPickExt, filter, TestPos,hitPos,hitNormal);
-
-                    if(abs(distanceToWall-MIN_WALL_DISTANCE)<0.1f)
-                        dtVcopy(pCurPoi,TestPos);
-                }
-            }
-        }
-    }
-
     static bool HandleMmapPathCommand(ChatHandler* handler, char const* args)
     {
-        if (!MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
+        if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
         {
             handler->PSendSysMessage("NavMesh not loaded for current map.");
             return true;
@@ -221,10 +91,10 @@ public:
         player->GetPosition(x, y, z);
 
         // path
-        /*PathGenerator path(target);
+        PathGenerator path(target);
         path.SetUseStraightPath(useStraightPath);
         bool result = path.CalculatePath(x, y, z);
-        
+
         Movement::PointsArray const& pointPath = path.GetPath();
         handler->PSendSysMessage("%s's path to %s:", target->GetName().c_str(), player->GetName().c_str());
         handler->PSendSysMessage("Building: %s", useStraightPath ? "StraightPath" : "SmoothPath");
@@ -237,64 +107,13 @@ public:
         handler->PSendSysMessage("StartPosition     (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
         handler->PSendSysMessage("EndPosition       (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
         handler->PSendSysMessage("ActualEndPosition (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
-        */
-        float m_spos[3];
-        m_spos[0] = -y;
-        m_spos[1] = z;
-        m_spos[2] = -x;
-
-        //
-        float m_epos[3];
-        m_epos[0] = -target->GetPositionY();
-        m_epos[1] = target->GetPositionZ();
-        m_epos[2] = -target->GetPositionX();
-
-        //
-        dtQueryFilter m_filter;
-        m_filter.setIncludeFlags(3);
-        m_filter.setExcludeFlags(2);
-
-        //
-        float m_polyPickExt[3];
-        m_polyPickExt[0] = 2.5f;
-        m_polyPickExt[1] = 2.5f;
-        m_polyPickExt[2] = 2.5f;
-
-        //
-        dtPolyRef m_startRef;
-        dtPolyRef m_endRef;
-
-        const dtNavMesh* navMesh = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMesh(player->GetMapId());
-        const dtNavMeshQuery* navMeshQuery = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMeshQuery(player->GetMapId(), handler->GetSession()->GetPlayer()->GetInstanceId());
-
-        float nearestPt[3];
-
-        navMeshQuery->findNearestPoly(m_spos, m_polyPickExt, &m_filter, &m_startRef, nearestPt);
-        navMeshQuery->findNearestPoly(m_epos, m_polyPickExt, &m_filter, &m_endRef, nearestPt);
-
-        if ( !m_startRef || !m_endRef )
-        {
-            std::cerr << "Could not find any nearby poly's (" << m_startRef << "," << m_endRef << ")" << std::endl;
-            return 0;
-        }
-
-        int hops;
-        dtPolyRef* hopBuffer = new dtPolyRef[8192];
-        dtStatus status = navMeshQuery->findPath(m_startRef, m_endRef, m_spos, m_epos, &m_filter, hopBuffer, &hops, 8192);
-
-        int resultHopCount;
-        float* straightPath = new float[2048*3];
-        unsigned char* pathFlags = new unsigned char[2048];
-        dtPolyRef* pathRefs = new dtPolyRef[2048];
-
-        status = navMeshQuery->findStraightPath(m_spos, m_epos, hopBuffer, hops, straightPath, pathFlags, pathRefs, &resultHopCount, 2048);
-        FixPath(const_cast<dtNavMesh*>(navMesh), const_cast<dtNavMeshQuery*>(navMeshQuery), m_polyPickExt, m_filter, resultHopCount, straightPath);
-        for (uint32 i = 0; i < resultHopCount; ++i)
-            player->SummonCreature(VISUAL_WAYPOINT, -straightPath[i * 3 + 2], -straightPath[i * 3 + 0], straightPath[i * 3 + 1], 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
 
         if (!player->IsGameMaster())
             handler->PSendSysMessage("Enable GM mode to see the path points.");
 
+        for (uint32 i = 0; i < pointPath.size(); ++i)
+            player->SummonCreature(VISUAL_WAYPOINT, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
+
         return true;
     }
 
@@ -312,8 +131,8 @@ public:
         handler->PSendSysMessage("gridloc [%i, %i]", gx, gy);
 
         // calculate navmesh tile location
-        dtNavMesh const* navmesh = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
-        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMeshQuery(handler->GetSession()->GetPlayer()->GetMapId(), player->GetInstanceId());
+        dtNavMesh const* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
+        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(handler->GetSession()->GetPlayer()->GetMapId(), player->GetInstanceId());
         if (!navmesh || !navmeshquery)
         {
             handler->PSendSysMessage("NavMesh not loaded for current map.");
@@ -323,8 +142,8 @@ public:
         float const* min = navmesh->getParams()->orig;
         float x, y, z;
         player->GetPosition(x, y, z);
-        float location[] = {y, z, x};
-        float extents[] = {3.0f, 5.0f, 3.0f};
+        float location[VERTEX_SIZE] = { y, z, x };
+        float extents[VERTEX_SIZE] = { 3.0f, 5.0f, 3.0f };
 
         int32 tilex = int32((y - min[0]) / SIZE_OF_GRIDS);
         int32 tiley = int32((x - min[2]) / SIZE_OF_GRIDS);
@@ -333,14 +152,14 @@ public:
 
         // navmesh poly -> navmesh tile location
         dtQueryFilter filter = dtQueryFilter();
-        dtPolyRef polyRef = 0;
+        dtPolyRef polyRef = INVALID_POLYREF;
         if (dtStatusFailed(navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL)))
         {
             handler->PSendSysMessage("Dt     [??,??] (invalid poly, probably no tile loaded)");
             return true;
         }
 
-        if (polyRef == 0)
+        if (polyRef == INVALID_POLYREF)
             handler->PSendSysMessage("Dt     [??, ??] (invalid poly, probably no tile loaded)");
         else
         {
@@ -364,8 +183,8 @@ public:
     static bool HandleMmapLoadedTilesCommand(ChatHandler* handler, char const* /*args*/)
     {
         uint32 mapid = handler->GetSession()->GetPlayer()->GetMapId();
-        dtNavMesh const* navmesh = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMesh(mapid);
-        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::CreateOrGetMMapManager()->GetNavMeshQuery(mapid, handler->GetSession()->GetPlayer()->GetInstanceId());
+        dtNavMesh const* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(mapid);
+        dtNavMeshQuery const* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(mapid, handler->GetSession()->GetPlayer()->GetInstanceId());
         if (!navmesh || !navmeshquery)
         {
             handler->PSendSysMessage("NavMesh not loaded for current map.");
@@ -392,8 +211,8 @@ public:
         handler->PSendSysMessage("mmap stats:");
         handler->PSendSysMessage("  global mmap pathfinding is %sabled", MMAP::MMapFactory::IsPathfindingEnabled(mapId) ? "en" : "dis");
 
-        MMAP::MMapManager* manager = MMAP::MMapFactory::CreateOrGetMMapManager();
-        handler->PSendSysMessage(" %u maps loaded with %u tiles overall", manager->GetLoadedMapsCount(), manager->GetLoadedTilesCount());
+        MMAP::MMapManager* manager = MMAP::MMapFactory::createOrGetMMapManager();
+        handler->PSendSysMessage(" %u maps loaded with %u tiles overall", manager->getLoadedMapsCount(), manager->getLoadedTilesCount());
 
         dtNavMesh const* navmesh = manager->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
         if (!navmesh)
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 7c181e95104..0267f17fd6c 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -11,6 +11,7 @@
 add_subdirectory(map_extractor)
 add_subdirectory(vmap4_assembler)
 add_subdirectory(vmap4_extractor)
+
 #if (WITH_MESHEXTRACTOR)
 #  add_subdirectory(mesh_extractor)
 #else()
diff --git a/src/tools/mesh_extractor/ADT.cpp b/src/tools/mesh_extractor/ADT.cpp
index f1b06fb1c0b..a55bdd5e4bb 100644
--- a/src/tools/mesh_extractor/ADT.cpp
+++ b/src/tools/mesh_extractor/ADT.cpp
@@ -25,7 +25,7 @@ ADT::ADT( std::string file, int x, int y ) : ObjectData(NULL), Data(NULL), HasOb
 {
     Data = new ChunkedData(file);
     ObjectData = new ChunkedData(file);
-    if (ObjectData->_Stream)
+    if (ObjectData->Stream)
         HasObjectData = true;
     else
         ObjectData = NULL;
@@ -33,11 +33,6 @@ ADT::ADT( std::string file, int x, int y ) : ObjectData(NULL), Data(NULL), HasOb
 
 ADT::~ADT()
 {
-    // Temporarily delete the underlying streams, they are guaranteed to be different
-    // @TODO: Remove this code once the ChunkedData destructor properly releases _Stream
-    delete ObjectData->_Stream;
-    delete Data->_Stream;
-
     delete ObjectData;
     delete Data;
 
diff --git a/src/tools/mesh_extractor/Cache.h b/src/tools/mesh_extractor/Cache.h
index 37aeb9caf48..5d8c02252c9 100644
--- a/src/tools/mesh_extractor/Cache.h
+++ b/src/tools/mesh_extractor/Cache.h
@@ -31,18 +31,24 @@ class GenericCache
 public:
     GenericCache() {}
 
-    T const* Get(K key)
+    static const uint32 FlushLimit = 300; // We can't get too close to filling up all the memory, and we have to be wary of the maximum number of open streams.
+
+    void Insert(K key, T* val)
+    {
+        ACE_GUARD(ACE_Thread_Mutex, g, mutex);
+
+        if (_items.size() > FlushLimit)
+            Clear();
+        _items[key] = val;
+    }
+
+    T* Get(K key)
     {
         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex, NULL);
         typename std::map<K, T*>::iterator itr = _items.find(key);
         if (itr != _items.end())
             return itr->second;
-        else
-        {
-            T* t = new T(key); // Create the object
-            _items[key] = t;
-            return t;
-        }
+        return NULL;
     }
 
     void Clear()
diff --git a/src/tools/mesh_extractor/Chunk.cpp b/src/tools/mesh_extractor/Chunk.cpp
index b1b28494a66..e4b2f60ff99 100644
--- a/src/tools/mesh_extractor/Chunk.cpp
+++ b/src/tools/mesh_extractor/Chunk.cpp
@@ -25,24 +25,24 @@ int32 Chunk::FindSubChunkOffset(std::string name)
     if (name.size() != 4)
         return -1;
 
-    Stream* stream = GetStream();
+    FILE* stream = GetStream();
     uint32 matched = 0;
-    while (stream->GetPos() < stream->GetSize())
+    while (uint32(ftell(stream)) < Utils::Size(stream))
     {
-        char b = stream->Read<char>();
-        if (b != name[matched])
+        char b = 0;
+        if (fread(&b, sizeof(char), 1, stream) != 1 || b != name[matched])
             matched = 0;
         else
             ++matched;
 
         if (matched == 4)
-            return stream->GetPos() - 4;
+            return ftell(stream) - 4;
     }
     return -1;
 }
 
-Stream* Chunk::GetStream()
+FILE* Chunk::GetStream()
 {
-    _Stream->Seek(Offset, SEEK_SET);
-    return _Stream;
+    fseek(Stream, Offset, SEEK_SET);
+    return Stream;
 }
diff --git a/src/tools/mesh_extractor/Chunk.h b/src/tools/mesh_extractor/Chunk.h
index 6cb6a10c8c2..87201928435 100644
--- a/src/tools/mesh_extractor/Chunk.h
+++ b/src/tools/mesh_extractor/Chunk.h
@@ -19,21 +19,19 @@
 #define CHUNK_H
 #include "Define.h"
 #include <string>
-#include "Stream.h"
-
 class ChunkedData;
 
 class Chunk
 {
 public:
-    Chunk(const char* name, uint32 length, uint32 offset, Stream* stream) : Name(name), Length(length), Offset(offset), _Stream(stream) {}
+    Chunk(const char* name, uint32 length, uint32 offset, FILE* stream) : Name(name), Length(length), Offset(offset), Stream(stream) {}
 
     int32 FindSubChunkOffset(std::string name);
-    Stream* GetStream();
+    FILE* GetStream();
     std::string Name;
     uint32 Length;
     uint32 Offset;
-    Stream* _Stream;
+    FILE* Stream;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/ChunkedData.cpp b/src/tools/mesh_extractor/ChunkedData.cpp
index 96af6f56a52..ae7827d98ea 100644
--- a/src/tools/mesh_extractor/ChunkedData.cpp
+++ b/src/tools/mesh_extractor/ChunkedData.cpp
@@ -21,18 +21,18 @@
 
 #include <string>
 
-ChunkedData::ChunkedData(Stream* stream, uint32 maxLength, uint32 chunksHint /*= 300*/ ) :
-_Stream(stream)
+ChunkedData::ChunkedData( FILE* stream, uint32 maxLength, uint32 chunksHint /*= 300*/ ) :
+Stream(stream)
 {
-    if (!_Stream)
+    if (!Stream)
         return;
     Load(maxLength, chunksHint);
 }
 
 ChunkedData::ChunkedData( const std::string& file, uint32 chunksHint /*= 300*/ )
 {
-    _Stream = MPQHandler->GetFile(file);
-    if (!_Stream)
+    Stream = MPQHandler->GetFile(file);
+    if (!Stream)
         return;
     Load(0, chunksHint);
 }
@@ -40,30 +40,31 @@ ChunkedData::ChunkedData( const std::string& file, uint32 chunksHint /*= 300*/ )
 void ChunkedData::Load( uint32 maxLength, uint32 chunksHint )
 {
     if (!maxLength)
-        maxLength = _Stream->GetSize();
+        maxLength = Utils::Size(Stream);
     Chunks.reserve(chunksHint);
-    uint32 baseOffset = _Stream->GetPos();
+    uint32 baseOffset = ftell(Stream);
     uint32 calcOffset = 0;
-    while ((calcOffset + baseOffset) < _Stream->GetSize() && (calcOffset < maxLength))
+    while ((calcOffset + baseOffset) < Utils::Size(Stream) && (calcOffset < maxLength))
     {
         char nameBytes[5];
-        _Stream->Read(nameBytes, sizeof(char) * 4);
-        nameBytes[4] = '\0';
+        uint32 read = fread(&nameBytes, sizeof(char), 4, Stream);
+        nameBytes[read] = '\0';
         std::string name = std::string(nameBytes);
+        // Utils::Reverse(nameBytes);
         name = std::string(name.rbegin(), name.rend());
-
-        uint32 length = _Stream->Read<uint32>();
+        uint32 length;
+        if (fread(&length, sizeof(uint32), 1, Stream) != 1)
+            continue;
         calcOffset += 8;
-
-        Chunks.push_back(new Chunk(name.c_str(), length, calcOffset + baseOffset, _Stream));
+        Chunks.push_back(new Chunk(name.c_str(), length, calcOffset + baseOffset, Stream));
         calcOffset += length;
         // save an extra seek at the end
-        if ((calcOffset + baseOffset) < _Stream->GetSize() && calcOffset < maxLength)
-            _Stream->Seek(length, SEEK_CUR);
+        if ((calcOffset + baseOffset) < Utils::Size(Stream) && calcOffset < maxLength)
+            fseek(Stream, length, SEEK_CUR);
     }
 }
 
-int ChunkedData::GetFirstIndex( const std::string& name ) const
+int ChunkedData::GetFirstIndex( const std::string& name )
 {
     for (uint32 i = 0; i < Chunks.size(); ++i)
         if (Chunks[i]->Name == name)
@@ -85,7 +86,6 @@ ChunkedData::~ChunkedData()
         delete *itr;
 
     Chunks.clear();
-    /* WorldModelGroup Data and SubData share the same _Stream so it's deleted twice and it crashes
-    if (_Stream)
-        delete _Stream;*/
+    if (Stream)
+        fclose(Stream);
 }
diff --git a/src/tools/mesh_extractor/ChunkedData.h b/src/tools/mesh_extractor/ChunkedData.h
index cef6c111542..48bb61f6959 100644
--- a/src/tools/mesh_extractor/ChunkedData.h
+++ b/src/tools/mesh_extractor/ChunkedData.h
@@ -20,20 +20,19 @@
 
 #include <vector>
 #include "Chunk.h"
-#include "Stream.h"
 
 class ChunkedData
 {
 public:
-    ChunkedData(Stream* stream, uint32 maxLength, uint32 chunksHint = 300);
+    ChunkedData(FILE* stream, uint32 maxLength, uint32 chunksHint = 300);
     ChunkedData(const std::string &file, uint32 chunksHint = 300);
     ~ChunkedData();
 
-    int GetFirstIndex(const std::string& name) const;
+    int GetFirstIndex(const std::string& name);
     Chunk* GetChunkByName(const std::string& name);
 
     void Load(uint32 maxLength, uint32 chunksHint);
     std::vector<Chunk*> Chunks;
-    Stream* _Stream;
+    FILE* Stream;
 };
 #endif
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/Constants.h b/src/tools/mesh_extractor/Constants.h
index 1961c2f386f..75e08bcf6fd 100644
--- a/src/tools/mesh_extractor/Constants.h
+++ b/src/tools/mesh_extractor/Constants.h
@@ -26,8 +26,6 @@ public:
         TRIANGLE_TYPE_UNKNOWN,
         TRIANGLE_TYPE_TERRAIN,
         TRIANGLE_TYPE_WATER,
-        TRIANGLE_TYPE_MAGMA,
-        TRIANGLE_TYPE_SLIME,
         TRIANGLE_TYPE_DOODAD,
         TRIANGLE_TYPE_WMO
     };
diff --git a/src/tools/mesh_extractor/ContinentBuilder.cpp b/src/tools/mesh_extractor/ContinentBuilder.cpp
index aa1666fd0e3..8f6a918ef8d 100644
--- a/src/tools/mesh_extractor/ContinentBuilder.cpp
+++ b/src/tools/mesh_extractor/ContinentBuilder.cpp
@@ -16,21 +16,80 @@
  */
 
 #include "ContinentBuilder.h"
+#include "TileBuilder.h"
 #include "WDT.h"
 #include "Utils.h"
 #include "DetourNavMesh.h"
 #include "Cache.h"
+#include "ace/Task.h"
 #include "Recast.h"
 #include "DetourCommon.h"
 
-void ContinentBuilder::getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax) const
+class BuilderThread : public ACE_Task_Base
+{
+private:
+    int X, Y, MapId;
+    std::string Continent;
+    dtNavMeshParams Params;
+    ContinentBuilder* cBuilder;
+public:
+    BuilderThread(ContinentBuilder* _cBuilder, dtNavMeshParams& params) : Params(params), cBuilder(_cBuilder), Free(true) {}
+    
+    void SetData(int x, int y, int map, const std::string& cont) 
+    { 
+        X = x; 
+        Y = y; 
+        MapId = map; 
+        Continent = cont; 
+    }
+
+    int svc()
+    {
+        Free = false;
+        printf("[%02i,%02i] Building tile\n", X, Y);
+        TileBuilder builder(cBuilder, Continent, X, Y, MapId);
+        char buff[100];
+        sprintf(buff, "mmaps/%03u%02i%02i.mmtile", MapId, Y, X);
+        FILE* f = fopen(buff, "r");
+        if (f) // Check if file already exists.
+        {
+            printf("[%02i,%02i] Tile skipped, file already exists\n", X, Y);
+            fclose(f);
+            Free = true;
+            return 0;
+        }
+        uint8* nav = builder.BuildTiled(Params);
+        if (nav)
+        {
+            f = fopen(buff, "wb");
+            if (!f)
+            {
+                printf("Could not create file %s. Check that you have write permissions to the destination folder and try again\n", buff);
+                return 0;
+            }
+            MmapTileHeader header;
+            header.size = builder.DataSize;
+            fwrite(&header, sizeof(MmapTileHeader), 1, f);
+            fwrite(nav, sizeof(unsigned char), builder.DataSize, f);
+            fclose(f);
+        }
+        dtFree(nav);
+        printf("[%02i,%02i] Tile Built!\n", X, Y);
+        Free = true;
+        return 0;
+    }
+
+    bool Free;
+};
+
+void ContinentBuilder::getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax)
 {
     // this is for elevation
     if (verts && vertCount)
         rcCalcBounds(verts, vertCount, bmin, bmax);
     else
     {
-        bmin[1] = -FLT_MAX;
+        bmin[1] = FLT_MIN;
         bmax[1] = FLT_MAX;
     }
 
@@ -69,6 +128,8 @@ void ContinentBuilder::Build()
 
     dtNavMeshParams params;
     
+    std::vector<BuilderThread*> Threads;
+
     if (TileMap->IsGlobalModel)
     {
         printf("Map %s ( %u ) is a WMO. Building with 1 thread.\n", Continent.c_str(), MapId);
@@ -98,7 +159,6 @@ void ContinentBuilder::Build()
             }
 
             MmapTileHeader mheader;
-            Utils::InitializeMmapTileHeader(mheader);
             mheader.size = builder->DataSize;
             fwrite(&mheader, sizeof(MmapTileHeader), 1, f);
             fwrite(nav, sizeof(unsigned char), builder->DataSize, f);
@@ -110,70 +170,44 @@ void ContinentBuilder::Build()
     }
     else
     {
-        params.maxPolys = 1024;
-        params.maxTiles = TileMap->TileTable.size();
+        params.maxPolys = 32768;
+        params.maxTiles = 4096;
         rcVcopy(params.orig, Constants::Origin);
         params.tileHeight = Constants::TileSize;
         params.tileWidth = Constants::TileSize;
         fwrite(&params, sizeof(dtNavMeshParams), 1, mmap);
         fclose(mmap);
 
-        std::vector<BuilderThread*> _threads;
-        BuilderThreadPool* pool = NumberOfThreads > 0 ? new BuilderThreadPool() : NULL;
-
+        for (uint32 i = 0; i < NumberOfThreads; ++i)
+            Threads.push_back(new BuilderThread(this, params));
         printf("Map %s ( %u ) has %u tiles. Building them with %u threads\n", Continent.c_str(), MapId, uint32(TileMap->TileTable.size()), NumberOfThreads);
-
         for (std::vector<TilePos>::iterator itr = TileMap->TileTable.begin(); itr != TileMap->TileTable.end(); ++itr)
-            pool->Enqueue(new TileBuildRequest(this, Continent, itr->X, itr->Y, MapId, params));
-
-        for (uint32 i = 0; i < NumberOfThreads; ++i)
-            _threads.push_back(new BuilderThread(this, pool->Queue()));
-
-        // Free memory
-        for (std::vector<BuilderThread*>::iterator _th = _threads.begin(); _th != _threads.end(); ++_th)
         {
-            (*_th)->wait();
-            delete *_th;
+            bool next = false;
+            while (!next)
+            {
+                for (std::vector<BuilderThread*>::iterator _th = Threads.begin(); _th != Threads.end(); ++_th)
+                {
+                    if ((*_th)->Free)
+                    {
+                        (*_th)->SetData(itr->X, itr->Y, MapId, Continent);
+                        (*_th)->activate();
+                        next = true;
+                        break;
+                    }
+                }
+                // Wait for 20 seconds
+                ACE_OS::sleep(ACE_Time_Value (0, 20000));
+            }
         }
-
-        delete pool;
     }
 
     Cache->Clear();
-}
 
-int TileBuildRequest::call()
-{
-    printf("[%02i,%02i] Building tile\n", X, Y);
-    // Build the tile and return negative on error
-    TileBuilder tile(_builder, _continent, X, Y, _mapId);
-    char buff[100];
-    sprintf(buff, "mmaps/%03u%02i%02i.mmtile", _mapId, Y, X);
-    FILE* f = fopen(buff, "r");
-    if (f) // Check if file already exists.
+    // Free memory
+    for (std::vector<BuilderThread*>::iterator _th = Threads.begin(); _th != Threads.end(); ++_th)
     {
-        printf("[%02i,%02i] Tile skipped, file already exists\n", X, Y);
-        fclose(f);
-        return 0;
-    }
-    uint8* nav = tile.BuildTiled(_params);
-    if (nav)
-    {
-        f = fopen(buff, "wb");
-        if (!f)
-        {
-            printf("Could not create file %s. Check that you have write permissions to the destination folder and try again\n", buff);
-            dtFree(nav);
-            return -1;
-        }
-        MmapTileHeader header;
-        Utils::InitializeMmapTileHeader(header);
-        header.size = tile.DataSize;
-        fwrite(&header, sizeof(MmapTileHeader), 1, f);
-        fwrite(nav, sizeof(unsigned char), tile.DataSize, f);
-        fclose(f);
+        (*_th)->wait();
+        delete *_th;
     }
-    dtFree(nav);
-    printf("[%02i,%02i] Tile Built!\n", X, Y);
-    return 0;
 }
diff --git a/src/tools/mesh_extractor/ContinentBuilder.h b/src/tools/mesh_extractor/ContinentBuilder.h
index 3dccced09c3..075265f2627 100644
--- a/src/tools/mesh_extractor/ContinentBuilder.h
+++ b/src/tools/mesh_extractor/ContinentBuilder.h
@@ -17,15 +17,9 @@
 
 #ifndef CONT_BUILDER_H
 #define CONT_BUILDER_H
-
 #include <string>
 #include "WDT.h"
 #include "Define.h"
-#include "TileBuilder.h"
-
-#include <ace/Task.h>
-#include <ace/Activation_Queue.h>
-#include <ace/Method_Request.h>
 
 class ContinentBuilder
 {
@@ -36,7 +30,7 @@ public:
         {}
 
     void Build();
-    void getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax) const;
+    void getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax);
     void CalculateTileBounds();
     float bmin[3];
     float bmax[3];
@@ -51,60 +45,4 @@ private:
     int tileYMax;
 };
 
-class TileBuildRequest : public ACE_Method_Request
-{
-public:
-    TileBuildRequest(ContinentBuilder* builder, std::string& continent, uint32 x, uint32 y, uint32 mapId, dtNavMeshParams& params) : _mapId(mapId), _builder(builder), _continent(continent), X(x), Y(y), _params(params) { }
-
-    virtual int call();
-
-private:
-    uint32 _mapId;
-    ContinentBuilder* _builder;
-    std::string& _continent;
-    uint32 X;
-    uint32 Y;
-    dtNavMeshParams& _params;
-};
-
-class BuilderThreadPool
-{
-public:
-    BuilderThreadPool() : _queue(new ACE_Activation_Queue()) {}
-    ~BuilderThreadPool() { _queue->queue()->close(); delete _queue; }
-
-    void Enqueue(TileBuildRequest* request)
-    {
-        _queue->enqueue(request);
-    }
-
-    ACE_Activation_Queue* Queue() { return _queue; }
-
-private:
-    ACE_Activation_Queue* _queue;
-};
-
-class BuilderThread : public ACE_Task_Base
-{
-private:
-    ContinentBuilder* _builder;
-    ACE_Activation_Queue* _queue;
-public:
-    BuilderThread(ContinentBuilder* builder, ACE_Activation_Queue* queue) : _builder(builder), _queue(queue) { activate(); }
-
-    int svc()
-    {
-        /// @ Set a timeout for dequeue attempts (only used when the queue is empty) as it will never get populated after thread starts
-        ACE_Time_Value timeout(5);
-        ACE_Method_Request* request = NULL;
-        while ((request = _queue->dequeue(&timeout)) != NULL)
-        {
-            request->call();
-            delete request;
-            request = NULL;
-        }
-        return 0;
-    }
-};
-
 #endif
diff --git a/src/tools/mesh_extractor/DBC.cpp b/src/tools/mesh_extractor/DBC.cpp
index 49c136efc80..e38b9560533 100644
--- a/src/tools/mesh_extractor/DBC.cpp
+++ b/src/tools/mesh_extractor/DBC.cpp
@@ -19,15 +19,19 @@
 #include "DBC.h"
 #include "Define.h"
 
-DBC::DBC(Stream* stream) : StringBlock(NULL), StringBlockSize(0), IsFaulty(true)
+DBC::DBC( FILE* stream ) : StringBlock(NULL), StringBlockSize(0), IsFaulty(true)
 {
-    delete[] stream->Read(4); // Read the magic "WDBC"
-
-    RecordCount = stream->Read<int>();
+    char magic[5];
+    uint32 count = 0;
+    count += fread(&magic, sizeof(char), 4, stream);
+    magic[4] = '\0';
+    count += fread(&RecordCount, sizeof(uint32), 1, stream);
     Records.reserve(RecordCount);
-    Fields = stream->Read<int>();
-    RecordSize = stream->Read<int>();
-    StringBlockSize = stream->Read<uint32>();
+    count += fread(&Fields, sizeof(uint32), 1, stream);
+    count += fread(&RecordSize, sizeof(uint32), 1, stream);
+    count += fread(&StringBlockSize, sizeof(uint32), 1, stream);
+    if (count != 8)
+        printf("DBC::DBC: Failed to read some data expected 8, read %u\n", count);
 
     for (int i = 0; i < RecordCount; i++)
     {
@@ -41,21 +45,21 @@ DBC::DBC(Stream* stream) : StringBlock(NULL), StringBlockSize(0), IsFaulty(true)
                 IsFaulty = true;
                 break;
             }
-            rec->Values.push_back(stream->Read<uint32>());
+            uint32 tmp;
+            if (fread(&tmp, sizeof(uint32), 1, stream) != 1)
+                printf("DBC::DBC: Failed to read some data expected 1, read 0\n");
+            rec->Values.push_back(tmp);
             size += 4;
         }
     }
-    StringBlock = (uint8*)stream->Read(StringBlockSize);
-}
 
-DBC::~DBC()
-{
-    delete[] StringBlock;
-    for (std::vector<Record*>::iterator itr = Records.begin(); itr != Records.end(); ++itr)
-        delete *itr;
+    StringBlock = new uint8[StringBlockSize];
+    count = fread(StringBlock, sizeof(uint8), StringBlockSize, stream);
+    if (count != StringBlockSize)
+        printf("DBC::DBC: Failed to read some data expected %u, read %u\n", StringBlockSize, count);
 }
 
-std::string DBC::GetStringByOffset( int offset ) const
+std::string DBC::GetStringByOffset( int offset )
 {
     int len = 0;
     for (uint32 i = offset; i < StringBlockSize; i++)
@@ -70,14 +74,14 @@ std::string DBC::GetStringByOffset( int offset ) const
     strcpy(d, (const char*)(StringBlock + offset));
     d[len] = '\0';
     std::string val = std::string(d);
-    delete[] d;
+    delete [] d;
     return val;
 }
 
-Record const* DBC::GetRecordById( int id ) const
+Record* DBC::GetRecordById( int id )
 {
     // we assume Id is index 0
-    for (std::vector<Record*>::const_iterator itr = Records.begin(); itr != Records.end(); ++itr)
+    for (std::vector<Record*>::iterator itr = Records.begin(); itr != Records.end(); ++itr)
         if ((*itr)->Values[0] == id)
             return *itr;
     return NULL;
diff --git a/src/tools/mesh_extractor/DBC.h b/src/tools/mesh_extractor/DBC.h
index 179c63ffcf2..d0951e36737 100644
--- a/src/tools/mesh_extractor/DBC.h
+++ b/src/tools/mesh_extractor/DBC.h
@@ -20,19 +20,17 @@
 #include <vector>
 #include <string>
 #include "Define.h"
-#include "Stream.h"
 
 class Record;
 
 class DBC
 {
 public:
-    DBC(Stream* stream);
-    ~DBC();
+    DBC(FILE* stream);
 
-    std::string GetStringByOffset(int offset) const;
+    std::string GetStringByOffset(int offset);
 
-    Record const* GetRecordById(int id) const;
+    Record* GetRecordById(int id);
 
     std::string Name;
     std::vector<Record*> Records;
@@ -52,18 +50,18 @@ public:
     DBC* Source;
     std::vector<int> Values;
 
-    int operator[](int index) const
+    int operator[](int index)
     {
         return Values[index];
     }
 
     template <typename T>
-    T GetValue(int index) const
+    T GetValue(int index)
     {
         return *(T*)(&Values[index]);
     }
 
-    const std::string GetString(int index) const
+    std::string GetString(int index)
     {
         return Source->GetStringByOffset(Values[index]);
     }
diff --git a/src/tools/mesh_extractor/DoodadHandler.cpp b/src/tools/mesh_extractor/DoodadHandler.cpp
index 7e84eaa6044..d56ba4c3bdf 100644
--- a/src/tools/mesh_extractor/DoodadHandler.cpp
+++ b/src/tools/mesh_extractor/DoodadHandler.cpp
@@ -34,18 +34,20 @@ DoodadHandler::DoodadHandler( ADT* adt ) :
         ReadDoodadPaths(mmid, mmdx);
 }
 
-void DoodadHandler::ProcessInternal(MapChunk* mcnk)
+void DoodadHandler::ProcessInternal( MapChunk* mcnk )
 {
     if (!IsSane())
         return;
     
     uint32 refCount = mcnk->Header.DoodadRefs;
-    Stream* stream = mcnk->Source->GetStream();
-    stream->Seek(mcnk->Source->Offset + mcnk->Header.OffsetMCRF, SEEK_SET);
-
+    FILE* stream = mcnk->Source->GetStream();
+    fseek(stream, mcnk->Source->Offset + mcnk->Header.OffsetMCRF, SEEK_SET);
     for (uint32 i = 0; i < refCount; i++)
     {
-        int32 index = stream->Read<int32>();
+        int32 index;
+        int32 count;
+        if ((count = fread(&index, sizeof(int32), 1, stream)) != 1)
+            printf("DoodadHandler::ProcessInternal: Failed to read some data expected 1, read %d\n", count);
         if (index < 0 || uint32(index) >= _definitions->size())
             continue;
         DoodadDefinition doodad = (*_definitions)[index];
@@ -56,7 +58,12 @@ void DoodadHandler::ProcessInternal(MapChunk* mcnk)
             continue;
 
         std::string path = (*_paths)[doodad.MmidIndex];
-        Model const* model = Cache->ModelCache.Get(path);
+        Model* model = Cache->ModelCache.Get(path);
+        if (!model)
+        {
+            model = new Model(path);
+            Cache->ModelCache.Insert(path, model);
+        }
         if (!model->IsCollidable)
             continue;
 
@@ -66,7 +73,7 @@ void DoodadHandler::ProcessInternal(MapChunk* mcnk)
         InsertModelGeometry(doodad, model);
     }
     // Restore the stream position
-    stream->Seek(mcnk->Source->Offset, SEEK_SET);
+    fseek(stream, mcnk->Source->Offset, SEEK_SET);
 }
 
 void DoodadHandler::ReadDoodadDefinitions( Chunk* chunk )
@@ -74,7 +81,7 @@ void DoodadHandler::ReadDoodadDefinitions( Chunk* chunk )
     int32 count = chunk->Length / 36;
     _definitions = new std::vector<DoodadDefinition>;
     _definitions->reserve(count);
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     for (int i = 0; i < count; i++)
     {
         DoodadDefinition def;
@@ -90,24 +97,25 @@ void DoodadHandler::ReadDoodadPaths( Chunk* id, Chunk* data )
     _paths->reserve(paths);
     for (int i = 0; i < paths; i++)
     {
-        Stream* idStream = id->GetStream();
-        idStream->Seek(i * 4, SEEK_CUR);
-        uint32 offset = idStream->Read<uint32>();
-
-        Stream* dataStream = data->GetStream();
-        dataStream->Seek(offset + data->Offset, SEEK_SET);
-        _paths->push_back(dataStream->ReadString());
+        FILE* idStream = id->GetStream();
+        fseek(idStream, i * 4, SEEK_CUR);
+        uint32 offset;
+        if (fread(&offset, sizeof(uint32), 1, idStream) != 1)
+            printf("DoodadHandler::ReadDoodadPaths: Failed to read some data expected 1, read 0\n");
+        FILE* dataStream = data->GetStream();
+        fseek(dataStream, offset + data->Offset, SEEK_SET);
+        _paths->push_back(Utils::ReadString(dataStream));
     }
 }
 
-void DoodadHandler::InsertModelGeometry(const DoodadDefinition& def, Model const* model)
+void DoodadHandler::InsertModelGeometry(const DoodadDefinition& def, Model* model)
 {
     uint32 vertOffset = Vertices.size();
     
-    for (std::vector<Vector3>::const_iterator itr = model->Vertices.begin(); itr != model->Vertices.end(); ++itr)
+    for (std::vector<Vector3>::iterator itr = model->Vertices.begin(); itr != model->Vertices.end(); ++itr)
         Vertices.push_back(Utils::TransformDoodadVertex(def, *itr)); // Vertices have to be converted based on the information from the DoodadDefinition struct
 
-    for (std::vector<Triangle<uint16> >::const_iterator itr = model->Triangles.begin(); itr != model->Triangles.end(); ++itr)
+    for (std::vector<Triangle<uint16> >::iterator itr = model->Triangles.begin(); itr != model->Triangles.end(); ++itr)
         Triangles.push_back(Triangle<uint32>(Constants::TRIANGLE_TYPE_DOODAD, itr->V0 + vertOffset, itr->V1 + vertOffset, itr->V2 + vertOffset));
 }
 
diff --git a/src/tools/mesh_extractor/DoodadHandler.h b/src/tools/mesh_extractor/DoodadHandler.h
index 00bb3edb7b0..3e179f63539 100644
--- a/src/tools/mesh_extractor/DoodadHandler.h
+++ b/src/tools/mesh_extractor/DoodadHandler.h
@@ -21,7 +21,6 @@
 #include "Utils.h"
 #include "Chunk.h"
 #include "Model.h"
-#include "Stream.h"
 #include <set>
 #include <vector>
 
@@ -40,14 +39,18 @@ public:
         return Vector3(vec.z, vec.x, vec.y);
     }
 
-    void Read(Stream* stream)
+    void Read(FILE* stream)
     {
-        MmidIndex = stream->Read<uint32>();
-        UniqueId = stream->Read<uint32>();
-        Position = Vector3::Read(stream);
+        int count = 0;
+
+        count += fread(&MmidIndex, sizeof(uint32), 1, stream);
+        count += fread(&UniqueId, sizeof(uint32), 1, stream);
+        Position = (Vector3::Read(stream));
         Rotation = Vector3::Read(stream);
-        DecimalScale = stream->Read<uint16>();
-        Flags = stream->Read<uint16>();
+        count += fread(&DecimalScale, sizeof(uint16), 1, stream);
+        count += fread(&Flags, sizeof(uint16), 1, stream);
+        if (count != 4)
+            printf("DoodadDefinition::Read: Failed to read some data expected 4, read %d\n", count);
     }
 };
 
@@ -59,7 +62,7 @@ public:
 
     std::vector<Vector3> Vertices;
     std::vector<Triangle<uint32> > Triangles;
-    bool IsSane() const { return _definitions && _paths; }
+    bool IsSane() { return _definitions && _paths; }
 
 
 protected:
@@ -68,7 +71,7 @@ protected:
 private:
     void ReadDoodadDefinitions(Chunk* chunk);
     void ReadDoodadPaths(Chunk* id, Chunk* data);
-    void InsertModelGeometry(const DoodadDefinition& def, Model const* model);
+    void InsertModelGeometry(const DoodadDefinition& def, Model* model);
     std::set<uint32> _drawn;
     std::vector<DoodadDefinition>* _definitions;
     std::vector<std::string>* _paths;
diff --git a/src/tools/mesh_extractor/Geometry.cpp b/src/tools/mesh_extractor/Geometry.cpp
index d95c07bc89b..e81dd8a7660 100644
--- a/src/tools/mesh_extractor/Geometry.cpp
+++ b/src/tools/mesh_extractor/Geometry.cpp
@@ -20,7 +20,6 @@
 #include "ADT.h"
 #include "WorldModelHandler.h"
 #include "DoodadHandler.h"
-#include "LiquidHandler.h"
 #include <limits.h>
 
 Geometry::Geometry() : Transform(false)
@@ -35,7 +34,7 @@ void Geometry::CalculateBoundingBox( float*& min, float*& max )
     max = new float[3];
     for (int i = 0; i < 3; ++i)
     {
-        max[i] = -FLT_MAX;
+        max[i] = std::numeric_limits<float>::lowest();
         min[i] = std::numeric_limits<float>::max();
     }
 
@@ -61,7 +60,7 @@ void Geometry::CalculateBoundingBox( float*& min, float*& max )
 void Geometry::CalculateMinMaxHeight( float& min, float& max )
 {
     min = std::numeric_limits<float>::max();
-    max = -FLT_MAX;
+    max = std::numeric_limits<float>::lowest();
 
     for (std::vector<Vector3>::iterator itr = Vertices.begin(); itr != Vertices.end(); ++itr)
     {
@@ -92,12 +91,12 @@ void Geometry::AddData( std::vector<Vector3>& verts, std::vector<Triangle<uint32
         Triangles.push_back(Triangle<uint32>(itr->Type, itr->V0 + vertOffset, itr->V1 + vertOffset, itr->V2 + vertOffset));
 }
 
-void Geometry::GetRawData( float*& verts, int*& tris, uint8*& areas ) const
+void Geometry::GetRawData( float*& verts, int*& tris, uint8*& areas )
 {
     verts = new float[Vertices.size() * 3];
     for (uint32 i = 0; i < Vertices.size(); ++i)
     {
-        const Vector3& vert = Vertices[i];
+        Vector3& vert = Vertices[i];
         verts[(i * 3) + 0] = vert.x;
         verts[(i * 3) + 1] = vert.y;
         verts[(i * 3) + 2] = vert.z;
@@ -106,7 +105,7 @@ void Geometry::GetRawData( float*& verts, int*& tris, uint8*& areas ) const
     tris = new int[Triangles.size() * 3];
     for (uint32 i = 0; i < Triangles.size(); ++i)
     {
-        const Triangle<uint32>& tri = Triangles[i];
+        Triangle<uint32>& tri = Triangles[i];
         tris[(i * 3) + 0] = (int)tri.V0;
         tris[(i * 3) + 1] = (int)tri.V1;
         tris[(i * 3) + 2] = (int)tri.V2;
@@ -143,8 +142,5 @@ void Geometry::AddAdt( ADT* adt )
 
     if (!adt->_WorldModelHandler->Triangles.empty())
         AddData(adt->_WorldModelHandler->Vertices, adt->_WorldModelHandler->Triangles);
-
-    if (!adt->_LiquidHandler->Triangles.empty())
-        AddData(adt->_LiquidHandler->Vertices, adt->_LiquidHandler->Triangles);
 }
 
diff --git a/src/tools/mesh_extractor/Geometry.h b/src/tools/mesh_extractor/Geometry.h
index d7a664068c6..d54cdbde5dd 100644
--- a/src/tools/mesh_extractor/Geometry.h
+++ b/src/tools/mesh_extractor/Geometry.h
@@ -31,7 +31,7 @@ public:
     void CalculateMinMaxHeight(float& min, float& max);
     void AddData(std::vector<Vector3>& verts, std::vector<Triangle<uint32> >& tris);
     void AddAdt(ADT* adt);
-    void GetRawData(float*& verts, int*& tris, uint8*& areas) const;
+    void GetRawData(float*& verts, int*& tris, uint8*& areas);
 
     std::vector<Vector3> Vertices;
     std::vector<Triangle<uint32> > Triangles;
diff --git a/src/tools/mesh_extractor/LiquidHandler.cpp b/src/tools/mesh_extractor/LiquidHandler.cpp
index 177b94924d0..0a76dbfb54c 100644
--- a/src/tools/mesh_extractor/LiquidHandler.cpp
+++ b/src/tools/mesh_extractor/LiquidHandler.cpp
@@ -17,20 +17,10 @@
 
 #include "LiquidHandler.h"
 #include "Utils.h"
-#include "DBC.h"
-#include "MPQManager.h"
 
 LiquidHandler::LiquidHandler( ADT* adt ) : Source(adt)
 {
     HandleNewLiquid();
-    HandleOldLiquid();
-}
-
-LiquidHandler::~LiquidHandler()
-{
-    for (std::vector<MCNKLiquidData*>::iterator itr = MCNKData.begin(); itr != MCNKData.end(); ++itr)
-        delete *itr;
-    MCNKData.clear();
 }
 
 void LiquidHandler::HandleNewLiquid()
@@ -42,7 +32,7 @@ void LiquidHandler::HandleNewLiquid()
     Vertices.reserve(1000);
     Triangles.reserve(1000);
 
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     H2OHeader header[256];
     MCNKData.reserve(256);
     for (int i = 0; i < 256; i++)
@@ -54,44 +44,40 @@ void LiquidHandler::HandleNewLiquid()
         if (h.LayerCount == 0)
         {
             // Need to fill in missing data with dummies.
-            MCNKData.push_back(new MCNKLiquidData(NULL, H2ORenderMask()));
+            MCNKData.push_back(MCNKLiquidData(NULL, H2ORenderMask()));
             continue;
         }
-        stream->Seek(chunk->Offset + h.OffsetInformation, SEEK_SET);
+        fseek(stream, chunk->Offset + h.OffsetInformation, SEEK_SET);
         H2OInformation information = H2OInformation::Read(stream);
 
-        // Load the LiquidTypes DBC
-        DBC const* liquidTypes = MPQHandler->GetDBC("LiquidTypes");
-        Record const* liquid = liquidTypes->GetRecordById(information.LiquidType);
-        ASSERT(liquid);
-
-        // This pointer will be passed to the MCNKLiquidData constructor, from that point on, it is the job of MCNKLiquidData's destructor to release it.
         float** heights = new float*[9];
         for (int j = 0; j < 9; ++j)
         {
             heights[j] = new float[9];
             memset(heights[j], 0, sizeof(float) * 9);
         }
-        
+
         H2ORenderMask renderMask;
-        if (liquid->GetValue<uint32>(3) != 1) // Read the liquid type and skip Ocean, Slow Ocean and Fast Ocean
+        if (information.LiquidType != 2)
         {
-            stream->Seek(chunk->Offset + h.OffsetRender, SEEK_SET);
+            fseek(stream, chunk->Offset + h.OffsetRender, SEEK_SET);
             renderMask = H2ORenderMask::Read(stream);
             if ((Utils::IsAllZero(renderMask.Mask, 8) || (information.Width == 8 && information.Height == 8)) && information.OffsetMask2)
             {
-                stream->Seek(chunk->Offset + information.OffsetMask2, SEEK_SET);
+                fseek(stream, chunk->Offset + information.OffsetMask2, SEEK_SET);
                 uint32 size = ceil(information.Width * information.Height / 8.0f);
-                uint8* altMask = (uint8*)stream->Read(size);
-                for (uint32 mi = 0; mi < size; mi++)
-                    renderMask.Mask[mi + information.OffsetY] |= altMask[mi];
+                uint8* altMask = new uint8[size];
+                if (fread(altMask, sizeof(uint8), size, stream) == size)
+                    for (uint32 mi = 0; mi < size; mi++)
+                        renderMask.Mask[mi + information.OffsetY] |= altMask[mi];
                 delete[] altMask;
             }
-            stream->Seek(chunk->Offset + information.OffsetHeightmap, SEEK_SET);
+            fseek(stream, chunk->Offset + information.OffsetHeightmap, SEEK_SET);
 
             for (int y = information.OffsetY; y < (information.OffsetY + information.Height); y++)
                 for (int x = information.OffsetX; x < (information.OffsetX + information.Width); x++)
-                    heights[x][y] = stream->Read<float>();
+                    if (fread(&heights[x][y], sizeof(float), 1, stream) != 1)
+                        return;
         }
         else
         {
@@ -104,7 +90,7 @@ void LiquidHandler::HandleNewLiquid()
                     heights[x][y] = information.HeightLevel1;
         }
 
-        MCNKData.push_back(new MCNKLiquidData(heights, renderMask));
+        MCNKData.push_back(MCNKLiquidData(heights, renderMask));
 
         for (int y = information.OffsetY; y < (information.OffsetY + information.Height); y++)
         {
@@ -124,37 +110,10 @@ void LiquidHandler::HandleNewLiquid()
                 Vertices.push_back(Vector3(location.x - Constants::UnitSize, location.y, location.z));
                 Vertices.push_back(Vector3(location.x, location.y - Constants::UnitSize, location.z));
                 Vertices.push_back(Vector3(location.x - Constants::UnitSize, location.y - Constants::UnitSize, location.z));
-                
-                // Define the liquid type
-                Constants::TriangleType type = Constants::TRIANGLE_TYPE_UNKNOWN;
-                switch (liquid->GetValue<uint32>(3))
-                {
-                    case 0: // Water
-                    case 1: // Ocean
-                        type = Constants::TRIANGLE_TYPE_WATER;
-                        break;
-                    case 2: // Magma
-                        type = Constants::TRIANGLE_TYPE_MAGMA;
-                        break;
-                    case 3: // Slime
-                        type = Constants::TRIANGLE_TYPE_SLIME;
-                        break;
-                }
 
-                Triangles.push_back(Triangle<uint32>(type, vertOffset, vertOffset+2, vertOffset + 1));
-                Triangles.push_back(Triangle<uint32>(type, vertOffset + 2, vertOffset + 3, vertOffset + 1));
+                Triangles.push_back(Triangle<uint32>(Constants::TRIANGLE_TYPE_WATER, vertOffset, vertOffset+2, vertOffset + 1));
+                Triangles.push_back(Triangle<uint32>(Constants::TRIANGLE_TYPE_WATER, vertOffset + 2, vertOffset + 3, vertOffset + 1));
             }
         }
     }
 }
-
-void LiquidHandler::HandleOldLiquid()
-{
-    for (uint32 i = 0; i < 256; ++i)
-    {
-        MapChunk* mapChunk = Source->MapChunks[i];
-        if (!mapChunk->Header.OffsetMCLQ || mapChunk->Header.SizeMCLQ <= 8)
-            continue;
-        printf("Found old liquid");
-    }
-}
diff --git a/src/tools/mesh_extractor/LiquidHandler.h b/src/tools/mesh_extractor/LiquidHandler.h
index 7001e849097..424dbde7e63 100644
--- a/src/tools/mesh_extractor/LiquidHandler.h
+++ b/src/tools/mesh_extractor/LiquidHandler.h
@@ -27,14 +27,12 @@ class LiquidHandler
 {
 public:
     LiquidHandler(ADT* adt);
-    ~LiquidHandler();
 
     ADT* Source;
     std::vector<Vector3> Vertices;
     std::vector<Triangle<uint32> > Triangles;
-    std::vector<MCNKLiquidData*> MCNKData;
+    std::vector<MCNKLiquidData> MCNKData;
 private:
     void HandleNewLiquid();
-    void HandleOldLiquid();
 };
 #endif
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/MPQ.cpp b/src/tools/mesh_extractor/MPQ.cpp
index 5551b0a9d47..b75a5bbdd85 100644
--- a/src/tools/mesh_extractor/MPQ.cpp
+++ b/src/tools/mesh_extractor/MPQ.cpp
@@ -17,7 +17,6 @@
 
 #include "MPQ.h"
 #include "MPQManager.h"
-#include "Stream.h"
 #include <deque>
 #include <cstdio>
 
@@ -126,8 +125,15 @@ void MPQFile::close()
     eof = true;
 }
 
-Stream* MPQFile::GetFileStream()
+FILE* MPQFile::GetFileStream()
 {
-    Stream* stream = new Stream(buffer, size);
-    return stream;
+    FILE* file = tmpfile();
+    if (!file)
+    {
+        printf("Could not create temporary file. Please run as Administrator or root\n");
+        exit(1);
+    }
+    fwrite(buffer, sizeof(char), size, file);
+    fseek(file, 0, SEEK_SET);
+    return file;
 }
diff --git a/src/tools/mesh_extractor/MPQ.h b/src/tools/mesh_extractor/MPQ.h
index 68c678df616..7eb048480b9 100644
--- a/src/tools/mesh_extractor/MPQ.h
+++ b/src/tools/mesh_extractor/MPQ.h
@@ -20,7 +20,6 @@
 
 #include "libmpq/mpq.h"
 #include "Define.h"
-#include "Stream.h"
 #include <string>
 #include <ctype.h>
 #include <vector>
@@ -31,7 +30,7 @@ class MPQArchive
 {
 
 public:
-    mpq_archive_s* mpq_a;
+    mpq_archive_s *mpq_a;
 
     std::vector<std::string> Files;
 
@@ -71,8 +70,8 @@ class MPQFile
 {
     //MPQHANDLE handle;
     bool eof;
-    char* buffer;
-    libmpq__off_t pointer, size;
+    char *buffer;
+    libmpq__off_t pointer,size;
 
     // disable copying
     MPQFile(const MPQFile& /*f*/) {}
@@ -82,18 +81,18 @@ public:
     MPQFile(const char* filename);    // filenames are not case sensitive
     ~MPQFile() { close(); }
     size_t Read(void* dest, size_t bytes);
-    Stream* GetFileStream();
-    size_t getSize() const { return size; }
-    size_t getPos() const { return pointer; }
+    FILE* GetFileStream();
+    size_t getSize() { return size; }
+    size_t getPos() { return pointer; }
     char* getBuffer() { return buffer; }
     char* getPointer() { return buffer + pointer; }
-    bool isEof() const { return eof; }
+    bool isEof() { return eof; }
     void seek(int offset);
     void seekRelative(int offset);
     void close();
 };
 
-inline void flipcc(char* fcc)
+inline void flipcc(char *fcc)
 {
     char t;
     t=fcc[0];
diff --git a/src/tools/mesh_extractor/MPQManager.cpp b/src/tools/mesh_extractor/MPQManager.cpp
index 563b31d724e..5f6e4a331ac 100644
--- a/src/tools/mesh_extractor/MPQManager.cpp
+++ b/src/tools/mesh_extractor/MPQManager.cpp
@@ -19,7 +19,6 @@
 #include "MPQ.h"
 #include "DBC.h"
 #include "Utils.h"
-#include "Stream.h"
 #include <ace/Guard_T.h>
 
 char const* MPQManager::Files[] = {
@@ -32,12 +31,6 @@ char const* MPQManager::Files[] = {
     "patch-3.MPQ"
 };
 
-char const* MPQManager::LocalePatchFiles[] = {
-    "Data/%s/patch-%s.MPQ",
-    "Data/%s/patch-%s-2.MPQ",
-    "Data/%s/patch-%s-3.MPQ"
-};
-
 char const* MPQManager::Languages[] = { "enGB", "enUS", "deDE", "esES", "frFR", "koKR", "zhCN", "zhTW", "enCN", "enTW", "esMX", "ruRU" };
 
 void MPQManager::Initialize()
@@ -55,7 +48,9 @@ void MPQManager::Initialize()
 void MPQManager::InitializeDBC()
 {
     BaseLocale = -1;
+    std::string fileName;
     uint32 size = sizeof(Languages) / sizeof(char*);
+    MPQArchive* _baseLocale = NULL;
     for (uint32 i = 0; i < size; ++i)
     {
         std::string _fileName = "Data/" + std::string(Languages[i]) + "/locale-" + std::string(Languages[i]) + ".MPQ";
@@ -63,34 +58,20 @@ void MPQManager::InitializeDBC()
         if (file)
         {
             if (BaseLocale == -1)
-                BaseLocale = i;
-
-            // Load the base locale file
-            MPQArchive* arch = new MPQArchive(_fileName.c_str());
-            LocaleFiles[i].push_front(arch);
-            
-            Archives.push_front(arch); // For lookup in GetFile
-
-            // Load the locale patches
-            for (uint32 j = 0; j < sizeof(LocalePatchFiles) / sizeof(char*); ++j)
             {
-                char patchName[100];
-                sprintf(patchName, LocalePatchFiles[j], Languages[i], Languages[i]);
-                FILE* patch = fopen(patchName, "rb");
-                if (file)
-                {
-                    MPQArchive* archP = new MPQArchive(patchName);
-                    LocaleFiles[i].push_front(archP);
-                    Archives.push_front(archP); // For lookup in GetFile
-                    fclose(patch);
-                }
+                BaseLocale = i;
+                _baseLocale = new MPQArchive(_fileName.c_str());
+                fileName = _fileName;
+                LocaleFiles[i] = _baseLocale;
             }
+            else
+                LocaleFiles[i] = new MPQArchive(_fileName.c_str());
 
             AvailableLocales.insert(i);
             printf("Detected locale: %s\n", Languages[i]);
         }
     }
-
+    Archives.push_front(_baseLocale);
     if (BaseLocale == -1)
     {
         printf("No locale data detected. Please make sure that the executable is in the same folder as your WoW installation.\n");
@@ -100,7 +81,7 @@ void MPQManager::InitializeDBC()
         printf("Using default locale: %s\n", Languages[BaseLocale]);
 }
 
-Stream* MPQManager::GetFile(const std::string& path )
+FILE* MPQManager::GetFile(const std::string& path )
 {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex, NULL);
     MPQFile file(path.c_str());
@@ -109,54 +90,13 @@ Stream* MPQManager::GetFile(const std::string& path )
     return file.GetFileStream();
 }
 
-DBC const* MPQManager::GetDBC(const std::string& name )
+DBC* MPQManager::GetDBC(const std::string& name )
 {
-    std::map<std::string, DBC*>::const_iterator itr = LoadedDBCs.find(name);
-    if (itr != LoadedDBCs.end())
-        return itr->second;
-
     std::string path = "DBFilesClient\\" + name + ".dbc";
-    DBC* dbc = new DBC(GetFile(path));
-    
-    LoadedDBCs[name] = dbc;
-
-    return dbc;
+    return new DBC(GetFile(path));
 }
 
-Stream* MPQManager::GetFileFromLocale( const std::string& path, uint32 locale )
-{
-    ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex, NULL);
-    std::deque<MPQArchive*> files = LocaleFiles[locale];
-    Stream* ret = NULL;
-    for (std::deque<MPQArchive*>::iterator itr = files.begin(); itr != files.end(); ++itr)
-    {
-        mpq_archive* mpq_a = (*itr)->mpq_a;
-
-        uint32_t filenum;
-        if(libmpq__file_number(mpq_a, path.c_str(), &filenum))
-            continue;
-        libmpq__off_t transferred;
-        libmpq__off_t size = 0;
-        libmpq__file_unpacked_size(mpq_a, filenum, &size);
-
-        // HACK: in patch.mpq some files don't want to open and give 1 for filesize
-        if (size <= 1)
-            continue;
-
-        char* buffer = new char[size];
-
-        //libmpq_file_getdata
-        libmpq__file_read(mpq_a, filenum, (unsigned char*)buffer, size, &transferred);
-        
-        ret = new Stream(buffer, size);
-
-        delete[] buffer;
-        break;
-    }
-    return ret;
-}
-
-Stream* MPQManager::GetFileFrom(const std::string& path, MPQArchive* file )
+FILE* MPQManager::GetFileFrom(const std::string& path, MPQArchive* file )
 {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex, NULL);
     mpq_archive* mpq_a = file->mpq_a;
@@ -179,7 +119,14 @@ Stream* MPQManager::GetFileFrom(const std::string& path, MPQArchive* file )
     libmpq__file_read(mpq_a, filenum, (unsigned char*)buffer, size, &transferred);
 
     // Pack the return into a FILE stream
-    Stream* ret = new Stream((char*)buffer, size);
+    FILE* ret = tmpfile();
+    if (!ret)
+    {
+        printf("Could not create temporary file. Please run as Administrator or root\n");
+        exit(1);
+    }
+    fwrite(buffer, sizeof(uint8), size, ret);
+    fseek(ret, 0, SEEK_SET);
     delete[] buffer;
     return ret;
 }
diff --git a/src/tools/mesh_extractor/MPQManager.h b/src/tools/mesh_extractor/MPQManager.h
index 43aba352dd3..588052bb844 100644
--- a/src/tools/mesh_extractor/MPQManager.h
+++ b/src/tools/mesh_extractor/MPQManager.h
@@ -19,7 +19,6 @@
 #define MPQ_MANAGER_H
 
 #include "MPQ.h"
-#include "Stream.h"
 #include <ace/Synch.h>
 #include <set>
 #include <map>
@@ -32,26 +31,22 @@ public:
     ~MPQManager() {}
 
     void Initialize();
-    Stream* GetFile(const std::string& path);
-    Stream* GetFileFrom(const std::string& path, MPQArchive* file);
-    Stream* GetFileFromLocale(const std::string& path, uint32 locale);
-
-    DBC const* GetDBC(const std::string& name);
+    FILE* GetFile(const std::string& path);
+    FILE* GetFileFrom(const std::string& path, MPQArchive* file);
+    DBC* GetDBC(const std::string& name);
     std::vector<std::string> GetAllFiles(std::string extension);
 
     std::deque<MPQArchive*> Archives;
     int32 BaseLocale;
     std::set<uint32> AvailableLocales;
-    std::map<uint32, std::deque<MPQArchive*> > LocaleFiles;
+    std::map<uint32, MPQArchive*> LocaleFiles;
 
     static char const* Files[];
-    static char const* LocalePatchFiles[];
     static char const* Languages[];
 protected:
     void InitializeDBC();
 private:
     ACE_Thread_Mutex mutex;
-    std::map<std::string, DBC*> LoadedDBCs;
 };
 
 extern MPQManager* MPQHandler;
diff --git a/src/tools/mesh_extractor/MapChunk.cpp b/src/tools/mesh_extractor/MapChunk.cpp
index 3a9738c92b1..76280dcc973 100644
--- a/src/tools/mesh_extractor/MapChunk.cpp
+++ b/src/tools/mesh_extractor/MapChunk.cpp
@@ -21,9 +21,9 @@
 
 MapChunk::MapChunk( ADT* _adt, Chunk* chunk ) : Adt(_adt), Source(chunk)
 {
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     Header.Read(stream);
-    stream->Seek(chunk->Offset, SEEK_SET);
+    fseek(stream, chunk->Offset, SEEK_SET);
     Index = Header.IndexX + Header.IndexY * 16;
     GenerateVertices(stream);
 }
@@ -47,12 +47,12 @@ void MapChunk::GenerateTriangles()
             Constants::TriangleType triangleType = Constants::TRIANGLE_TYPE_TERRAIN;
             if (Adt->_LiquidHandler && !Adt->_LiquidHandler->MCNKData.empty())
             {
-                MCNKLiquidData* data = Adt->_LiquidHandler->MCNKData[Index];
+                MCNKLiquidData& data = Adt->_LiquidHandler->MCNKData[Index];
                 float maxHeight = std::max(
                     std::max(
                     std::max(std::max(Vertices[topLeft].z, Vertices[topRight].z), Vertices[bottomLeft].z),
                     Vertices[bottomRight].z), Vertices[center].z);
-                if (data->IsWater(x, y, maxHeight))
+                if (data.IsWater(x, y, maxHeight))
                     triangleType = Constants::TRIANGLE_TYPE_WATER;
             }
 
@@ -64,9 +64,9 @@ void MapChunk::GenerateTriangles()
     }
 }
 
-void MapChunk::GenerateVertices(Stream* stream)
+void MapChunk::GenerateVertices( FILE* stream )
 {
-    stream->Seek(Header.OffsetMCVT, SEEK_CUR);
+    fseek(stream, Header.OffsetMCVT, SEEK_CUR);
     Vertices.reserve(125);
 
     for (int j = 0; j < 17; j++)
@@ -74,7 +74,9 @@ void MapChunk::GenerateVertices(Stream* stream)
         int values = j % 2 ? 8 : 9;
         for (int i = 0; i < values; i++)
         {
-            float tmp = stream->Read<float>();
+            float tmp;
+            if (fread(&tmp, sizeof(float), 1, stream) != 1)
+                printf("MapChunk::GenerateVertices: Failed to read some data expected 1, read 0\n");
             Vector3 vert(Header.Position.x - (j * (Constants::UnitSize * 0.5f)), Header.Position.y - (i * Constants::UnitSize), Header.Position.z + tmp);
             if (values == 8)
                 vert.y -= Constants::UnitSize * 0.5f;
@@ -82,7 +84,7 @@ void MapChunk::GenerateVertices(Stream* stream)
         }
     }
     // Restore stream position.
-    stream->Seek(Source->Offset, SEEK_SET);
+    fseek(stream, Source->Offset, SEEK_SET);
 }
 
 bool MapChunk::HasHole( uint32 map, int x, int y )
diff --git a/src/tools/mesh_extractor/MapChunk.h b/src/tools/mesh_extractor/MapChunk.h
index a32a6ce20a7..97adc790e94 100644
--- a/src/tools/mesh_extractor/MapChunk.h
+++ b/src/tools/mesh_extractor/MapChunk.h
@@ -29,7 +29,7 @@ public:
     MapChunk(ADT* _adt, Chunk* chunk);
 
     void GenerateTriangles();
-    void GenerateVertices(Stream* stream);
+    void GenerateVertices(FILE* stream);
     static bool HasHole(uint32 map, int x, int y);
     ADT* Adt;
     Chunk* Source;
diff --git a/src/tools/mesh_extractor/MeshExtractor.cpp b/src/tools/mesh_extractor/MeshExtractor.cpp
index 00121509a8a..df1393f7e6b 100644
--- a/src/tools/mesh_extractor/MeshExtractor.cpp
+++ b/src/tools/mesh_extractor/MeshExtractor.cpp
@@ -34,41 +34,16 @@
 MPQManager* MPQHandler;
 CacheClass* Cache;
 
-bool IgnoreMap(uint32 id)
-{
-    switch (id)
-    {
-        case 13:    // test.wdt
-        case 25:    // ScottTest.wdt
-        case 29:    // Test.wdt
-        case 42:    // Colin.wdt
-        case 169:   // EmeraldDream.wdt (unused, and very large)
-        case 451:   // development.wdt
-        case 573:   // ExteriorTest.wdt
-        case 597:   // CraigTest.wdt
-        case 605:   // development_nonweighted.wdt
-        case 606:   // QA_DVD.wdt
-            return true;
-        default:
-            break;
-    }
-
-    return false;
-}
-
 void ExtractMMaps(std::set<uint32>& mapIds, uint32 threads)
 {
-    std::string basePath = "mmaps/";
-    Utils::CreateDir(basePath);
-
-    DBC const* dbc = MPQHandler->GetDBC("Map");
-    printf("Map.dbc contains " SIZEFMTD " rows.\n", dbc->Records.size());
-    for (std::vector<Record*>::const_iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr)
+    DBC* dbc = MPQHandler->GetDBC("Map");
+    printf("Map.dbc contains %u rows.\n", dbc->Records.size());
+    for (std::vector<Record*>::iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr)
     {
         uint32 mapId = (*itr)->Values[0];
 
-        // Skip this map if a list of specific maps was provided and this one is not contained in it, or if the map is in the ignore list.
-        if ((!mapIds.empty() && mapIds.find(mapId) == mapIds.end()) || IgnoreMap(mapId))
+        // Skip this map if a list of specific maps was provided and this one is not contained in it.
+        if (!mapIds.empty() && mapIds.find(mapId) == mapIds.end())
         {
             if (Constants::Debug)
                 printf("Map %u will not be built.\n", mapId);
@@ -100,12 +75,9 @@ void ExtractDBCs()
     // Populate list of DBC files
     // We get the DBC names by going over the (guaranteed to exist) default locale files
     // Then we look in other locale files in case that they are available.
-    for (std::map<uint32, std::deque<MPQArchive*> >::iterator itr = MPQHandler->LocaleFiles.begin(); itr != MPQHandler->LocaleFiles.end(); ++itr)
-        for (std::deque<MPQArchive*>::iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
-            for (std::vector<std::string>::iterator itr3 = (*itr2)->Files.begin(); itr3 != (*itr2)->Files.end(); ++itr3)
-                if (itr3->rfind(".dbc") == itr3->length() - extLen) // Check if the extension is ".dbc"
-                    if (DBCFiles.find(*itr3) == DBCFiles.end())
-                        DBCFiles.insert(*itr3);
+    for (std::vector<std::string>::iterator itr = MPQHandler->LocaleFiles[MPQHandler->BaseLocale]->Files.begin(); itr != MPQHandler->LocaleFiles[MPQHandler->BaseLocale]->Files.end(); ++itr)
+        if (itr->rfind(".dbc") == itr->length() - extLen) // Check if the extension is ".dbc"
+            DBCFiles.insert(*itr);
 
     const size_t folderLen = strlen("DBFilesClient\\");
     // Iterate over all available locales
@@ -121,10 +93,10 @@ void ExtractDBCs()
 
         std::string component = "component.wow-" + std::string(MPQManager::Languages[*itr]) + ".txt";
         // Extract the component file
-        Utils::SaveToDisk(MPQHandler->GetFileFromLocale(component, *itr), path + component);
+        Utils::SaveToDisk(MPQHandler->GetFileFrom(component, MPQHandler->LocaleFiles[*itr]), path + component);
         // Extract the DBC files for the given locale
         for (std::set<std::string>::iterator itr2 = DBCFiles.begin(); itr2 != DBCFiles.end(); ++itr2)
-            Utils::SaveToDisk(MPQHandler->GetFileFromLocale(*itr2, *itr), path + (itr2->c_str() + folderLen));
+            Utils::SaveToDisk(MPQHandler->GetFileFrom(*itr2, MPQHandler->LocaleFiles[*itr]), path + (itr2->c_str() + folderLen));
     }
     printf("DBC extraction finished!\n");
 }
@@ -146,8 +118,8 @@ void ExtractGameobjectModels()
         return;
     }
 
-    DBC const* dbc = MPQHandler->GetDBC("GameObjectDisplayInfo");
-    for (std::vector<Record*>::const_iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr)
+    DBC* dbc = MPQHandler->GetDBC("GameObjectDisplayInfo");
+    for (std::vector<Record*>::iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr)
     {
         std::string path = (*itr)->GetString(1);
         std::string fileName = Utils::GetPlainName(path.c_str());
@@ -253,9 +225,8 @@ void ExtractGameobjectModels()
             fwrite(&model.Header.WmoId, sizeof(uint32), 1, output);
 
             const char grp[] = { 'G' , 'R' , 'P', ' ' };
-            for (std::vector<WorldModelGroup*>::iterator groupItr = model.Groups.begin(); groupItr != model.Groups.end(); ++groupItr)
+            for (std::vector<WorldModelGroup>::iterator itr2 = model.Groups.begin(); itr2 != model.Groups.end(); ++itr2)
             {
-                WorldModelGroup* itr2 = *groupItr;
                 const WMOGroupHeader& header = itr2->Header;
                 fwrite(&header.Flags, sizeof(uint32), 1, output);
                 fwrite(&header.WmoId, sizeof(uint32), 1, output);
@@ -392,6 +363,7 @@ void LoadTile(dtNavMesh*& navMesh, const char* tile)
 
 int main(int argc, char* argv[])
 {
+    _setmaxstdio(2048);
     uint32 threads = 4, extractFlags = 0;
     std::set<uint32> mapIds;
 
@@ -423,8 +395,13 @@ int main(int argc, char* argv[])
 
     if (extractFlags & Constants::EXTRACT_FLAG_TEST)
     {
+<<<<<<< .mine
         float start[] = { -45.4745407f, -29.5000954f, -21.4456501f };
         float end[] = { -107.686218f, -32.3544769f, -30.3459435f };
+=======
+        float start[] = { 16226.200195f, 16257.000000f, 13.202200f };
+        float end[] = { 16245.725586f, 16382.465820f, 47.384956f };
+>>>>>>> .theirs
 
         //
         float m_spos[3];
@@ -453,7 +430,7 @@ int main(int argc, char* argv[])
         dtPolyRef m_startRef;
         dtPolyRef m_endRef;
 
-        FILE* mmap = fopen("mmaps/631.mmap", "rb");
+        FILE* mmap = fopen("mmaps/001.mmap", "rb");
         dtNavMeshParams params;
         int count = fread(&params, sizeof(dtNavMeshParams), 1, mmap);
         fclose(mmap);
@@ -472,7 +449,7 @@ int main(int argc, char* argv[])
             for (int j = 0; j <= 32; ++j)
             {
                 char buff[100];
-                sprintf(buff, "mmaps/631%02i%02i.mmtile", i, j);
+                sprintf(buff, "mmaps/001%02i%02i.mmtile", i, j);
                 LoadTile(navMesh, buff);
             }
         }
@@ -490,6 +467,7 @@ int main(int argc, char* argv[])
             return 0;
         }
 
+<<<<<<< .mine
         dtStatus status;
         status = navMeshQuery->initSlicedFindPath(m_startRef, m_endRef, m_spos, m_epos, &m_filter);
         while (status != DT_SUCCESS)
@@ -500,12 +478,46 @@ int main(int argc, char* argv[])
         int resultHopCount = 0;
         float* straightPath = new float[2048 * 3];
         unsigned char* pathFlags = new unsigned char[2048];
+=======
+        int hops;
+
+
+
+
+
+
+
+
+
+>>>>>>> .theirs
         dtPolyRef* hopBuffer = new dtPolyRef[8192];
+<<<<<<< .mine
 
         navMeshQuery->finalizeSlicedFindPath(pathRefs, &pcount, 200);
+
+
+
+
+
+
+=======
+        dtStatus status = navMeshQuery->findPath(m_startRef, m_endRef, m_spos, m_epos, &m_filter, hopBuffer, &hops, 8192);
+        
+        int resultHopCount;
+        float* straightPath = new float[2048*3];
+        unsigned char* pathFlags = new unsigned char[2048];
+        dtPolyRef* pathRefs = new dtPolyRef[2048];
+
+        status = navMeshQuery->findStraightPath(m_spos, m_epos, hopBuffer, hops, straightPath, pathFlags, pathRefs, &resultHopCount, 2048);
+>>>>>>> .theirs
         std::vector<Vector3> FinalPath;
+<<<<<<< .mine
 
         for (int i = 0; i < pcount; ++i)
+=======
+        FinalPath.reserve(resultHopCount);
+        for (uint32 i = 0; i < resultHopCount; ++i)
+>>>>>>> .theirs
         {
             navMeshQuery->findStraightPath(m_spos, m_epos, &pathRefs[i], 1,
                 straightPath, pathFlags,
@@ -514,14 +526,6 @@ int main(int argc, char* argv[])
             FinalPath.push_back(finalV);
             printf("Point %f %f %f\n", finalV.x, finalV.y, finalV.z);
         }
-        /*
-        FinalPath.reserve(resultHopCount);
-        for (int i = 0; i < resultHopCount; ++i)
-        {
-            Vector3 finalV = Utils::ToWoWCoords(Vector3(straightPath[i * 3 + 0], straightPath[i * 3 + 1], straightPath[i * 3 + 2]));
-            FinalPath.push_back(finalV);
-            printf("Point %f %f %f\n", finalV.x, finalV.y, finalV.z);
-        }*/
     }
 
     return 0;
diff --git a/src/tools/mesh_extractor/Model.cpp b/src/tools/mesh_extractor/Model.cpp
index 6e735ec7440..48c60d9d644 100644
--- a/src/tools/mesh_extractor/Model.cpp
+++ b/src/tools/mesh_extractor/Model.cpp
@@ -19,15 +19,15 @@
 #include "MPQManager.h"
 #include "Utils.h"
 
-Model::Model(std::string path) : IsCollidable(false), IsBad(false)
+Model::Model( std::string path ) : IsCollidable(false), IsBad(false)
 {
-    _Stream = MPQHandler->GetFile(Utils::FixModelPath(path));
-    if (!_Stream)
+    Stream = MPQHandler->GetFile(Utils::FixModelPath(path));
+    if (!Stream)
     {
         IsBad = true;
         return;
     }
-    Header.Read(_Stream);
+    Header.Read(Stream);
     if (Header.OffsetBoundingNormals > 0 && Header.OffsetBoundingVertices > 0 &&
         Header.OffsetBoundingTriangles > 0 && Header.BoundingRadius > 0.0f)
     {
@@ -40,17 +40,17 @@ Model::Model(std::string path) : IsCollidable(false), IsBad(false)
 
 Model::~Model()
 {
-    if (_Stream)
-        delete _Stream;
+    if (Stream)
+        fclose(Stream);
 }
 
 void Model::ReadVertices()
 {
-    _Stream->Seek(Header.OffsetBoundingVertices, SEEK_SET);
+    fseek(Stream, Header.OffsetBoundingVertices, SEEK_SET);
     Vertices.reserve(Header.CountBoundingVertices);
     for (uint32 i = 0; i < Header.CountBoundingVertices; ++i)
     {
-        Vertices.push_back(Vector3::Read(_Stream));
+        Vertices.push_back(Vector3::Read(Stream));
         if (Constants::ToWoWCoords)
             Vertices[i] = Utils::ToWoWCoords(Vertices[i]);
     }
@@ -58,24 +58,27 @@ void Model::ReadVertices()
 
 void Model::ReadBoundingTriangles()
 {
-    _Stream->Seek(Header.OffsetBoundingTriangles, SEEK_SET);
+    fseek(Stream, Header.OffsetBoundingTriangles, SEEK_SET);
     Triangles.reserve(Header.CountBoundingTriangles / 3);
     for (uint32 i = 0; i < Header.CountBoundingTriangles / 3; i++)
     {
         Triangle<uint16> tri;
         tri.Type = Constants::TRIANGLE_TYPE_DOODAD;
-        tri.V0 = _Stream->Read<uint16>();
-        tri.V1 = _Stream->Read<uint16>();
-        tri.V2 = _Stream->Read<uint16>();
+        int count = 0;
+        count += fread(&tri.V0, sizeof(uint16), 1, Stream);
+        count += fread(&tri.V1, sizeof(uint16), 1, Stream);
+        count += fread(&tri.V2, sizeof(uint16), 1, Stream);
+        if (count != 3)
+            printf("Model::ReadBoundingTriangles: Error reading data, expected 3, read %d\n", count);
         Triangles.push_back(tri);
     }
 }
 
 void Model::ReadBoundingNormals()
 {
-    _Stream->Seek(Header.OffsetBoundingNormals, SEEK_SET);
+    fseek(Stream, Header.OffsetBoundingNormals, SEEK_SET);
     Normals.reserve(Header.CountBoundingNormals);
     for (uint32 i = 0; i < Header.CountBoundingNormals; i++)
-        Normals.push_back(Vector3::Read(_Stream));
+        Normals.push_back(Vector3::Read(Stream));
 }
 
diff --git a/src/tools/mesh_extractor/Model.h b/src/tools/mesh_extractor/Model.h
index 1169421cdf1..8f43b2963ea 100644
--- a/src/tools/mesh_extractor/Model.h
+++ b/src/tools/mesh_extractor/Model.h
@@ -19,7 +19,6 @@
 #define MODEL_H
 #include <vector>
 #include "Utils.h"
-#include "Stream.h"
 
 class Model
 {
@@ -35,7 +34,7 @@ public:
     std::vector<Vector3> Normals;
     std::vector<Triangle<uint16> > Triangles;
     bool IsCollidable;
-    Stream* _Stream;
+    FILE* Stream;
     bool IsBad;
 };
 #endif
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/ObjectDataHandler.h b/src/tools/mesh_extractor/ObjectDataHandler.h
index 423d8704a00..dc57301563a 100644
--- a/src/tools/mesh_extractor/ObjectDataHandler.h
+++ b/src/tools/mesh_extractor/ObjectDataHandler.h
@@ -24,7 +24,6 @@ class ObjectDataHandler
 {
 public:
     ObjectDataHandler(ADT* _adt) : Source(_adt) {}
-    virtual ~ObjectDataHandler() {}
 
     void ProcessMapChunk(MapChunk* chunk);
     virtual void ProcessInternal(MapChunk* data) = 0;
diff --git a/src/tools/mesh_extractor/Stream.cpp b/src/tools/mesh_extractor/Stream.cpp
deleted file mode 100644
index f775d97d114..00000000000
--- a/src/tools/mesh_extractor/Stream.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "Stream.h"
-#include <iostream>
-
-Stream::Stream(char* buffer, uint32 size) : _size(size), _position(0)
-{
-    _buffer = new char[size];
-    memcpy(_buffer, buffer, size); // Initialize the buffer
-}
-
-Stream::~Stream()
-{
-    delete[] _buffer;
-}
-
-char* Stream::Read(uint32 size)
-{
-    char* buff = new char[size];
-    memcpy(buff, &_buffer[_position], size);
-    _position += size;
-    return buff;
-}
-
-void Stream::Seek(uint32 position, uint32 type)
-{
-    switch (type)
-    {
-        case SEEK_SET:
-            _position = position;
-            break;
-        case SEEK_CUR:
-            _position += position;
-            break;
-    }
-}
-
-std::string Stream::ReadString()
-{
-    std::string str;
-    while (true)
-    {
-        char b = Read<char>();
-        if (b == 0)
-            break;
-        str.push_back(b);
-    }
-    return str;
-}
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/Stream.h b/src/tools/mesh_extractor/Stream.h
deleted file mode 100644
index 647ff9d5357..00000000000
--- a/src/tools/mesh_extractor/Stream.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include "Define.h"
-#include <iostream>
-
-class Stream
-{
-public:
-    Stream(char* buffer, uint32 size);
-    ~Stream();
-
-    template<typename T>
-    T Read()
-    {
-        T ret = *((T*)(&_buffer[_position]));
-        _position += sizeof(T);
-        return ret;
-    }
-
-    template<typename T>
-    void Read(T* dest, uint32 size)
-    {
-        memcpy(dest, &_buffer[_position], size);
-        _position += size;
-    }
-
-    template<typename T>
-    void Skip()
-    {
-        _position += sizeof(T);
-    }
-
-    char* Read(uint32 size);
-    std::string ReadString();
-
-    void Reset()
-    {
-        _position = 0;
-    }
-
-    void Seek(uint32 position, uint32 type);
-
-    uint32 GetSize() const
-    {
-        return _size;
-    }
-
-    uint32 GetPos() const
-    {
-        return _position;
-    }
-
-private:
-    char* _buffer;
-    uint32 _size;
-    uint32 _position;
-};
-#endif
\ No newline at end of file
diff --git a/src/tools/mesh_extractor/TileBuilder.cpp b/src/tools/mesh_extractor/TileBuilder.cpp
index 0ec35c5a04f..a9774abe6ce 100644
--- a/src/tools/mesh_extractor/TileBuilder.cpp
+++ b/src/tools/mesh_extractor/TileBuilder.cpp
@@ -43,8 +43,8 @@ TileBuilder::TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x,
     Config.detailSampleDist = 3.0f;
     Config.detailSampleMaxError = 1.25f;
     Config.walkableClimb = 1.0f / Config.ch;
-    Config.walkableHeight = 2.1;
-    Config.walkableRadius = 0.6f;
+    Config.walkableHeight = 2.1 / Config.ch;
+    Config.walkableRadius = 0.6f / Config.cs;
     Config.maxEdgeLen = Config.walkableRadius * 8;
     Config.borderSize = Config.walkableRadius + 8;
     Config.tileSize = 1800;
@@ -59,19 +59,19 @@ TileBuilder::TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x,
     InstanceConfig.mergeRegionArea = 100;
     InstanceConfig.walkableSlopeAngle = 50.0f;
     InstanceConfig.detailSampleDist = 3.0f;
-    InstanceConfig.detailSampleMaxError = 1.25f;
+    InstanceConfig.detailSampleMaxError = 1.5f;
     InstanceConfig.walkableClimb = 1.0f / InstanceConfig.ch;
-    InstanceConfig.walkableHeight = 2.1f;
-    InstanceConfig.walkableRadius = 0.6f;
+    InstanceConfig.walkableHeight = 2.1f / InstanceConfig.ch;
+    InstanceConfig.walkableRadius = 0.6f / InstanceConfig.cs;
     InstanceConfig.maxEdgeLen = 8 * InstanceConfig.walkableRadius;
     InstanceConfig.maxVertsPerPoly = 6;
-    InstanceConfig.maxSimplificationError = 1.3f;
+    InstanceConfig.maxSimplificationError = 1.25f;
     InstanceConfig.borderSize = 0;
 
     Context = new rcContext;
 }
 
-void TileBuilder::CalculateTileBounds( float*& bmin, float*& bmax, dtNavMeshParams& /*navMeshParams*/ ) const
+void TileBuilder::CalculateTileBounds( float*& bmin, float*& bmax, dtNavMeshParams& /*navMeshParams*/ )
 {
     bmin = new float[3];
     bmax = new float[3];
@@ -81,7 +81,7 @@ void TileBuilder::CalculateTileBounds( float*& bmin, float*& bmax, dtNavMeshPara
     bmax[2] = Constants::Origin[2] /*navMeshParams.orig[2]*/ + (Constants::TileSize * (Y + 1));
 }
 
-void TileBuilder::AddGeometry(WorldModelRoot const* root, const WorldModelDefinition& def)
+void TileBuilder::AddGeometry(WorldModelRoot* root, const WorldModelDefinition& def)
 {
     _Geometry = new Geometry();
     _Geometry->Transform = true;
@@ -91,7 +91,7 @@ void TileBuilder::AddGeometry(WorldModelRoot const* root, const WorldModelDefini
     OutputDebugVertices();
 }
 
-uint8* TileBuilder::BuildInstance( dtNavMeshParams& /*navMeshParams*/ )
+uint8* TileBuilder::BuildInstance( dtNavMeshParams& navMeshParams )
 {
     float* bmin = NULL, *bmax = NULL;
 
@@ -183,11 +183,11 @@ uint8* TileBuilder::BuildInstance( dtNavMeshParams& /*navMeshParams*/ )
     rcFreeHeightField(hf);
     rcFreeCompactHeightfield(chf);
     rcFreeContourSet(contours);
-    delete[] vertices;
-    delete[] triangles;
-    delete[] areas;
-    delete[] bmin;
-    delete[] bmax;
+    delete vertices;
+    delete triangles;
+    delete areas;
+    delete bmin;
+    delete bmax;
 
     if (!params.polyCount || !params.polys || Constants::TilesPerMap * Constants::TilesPerMap == params.polyCount)
     {
@@ -226,7 +226,7 @@ uint8* TileBuilder::BuildTiled(dtNavMeshParams& navMeshParams)
     adt->Read();
     _Geometry->AddAdt(adt);
     delete adt;
-    
+
     if (_Geometry->Vertices.empty() && _Geometry->Triangles.empty())
         return NULL;
 
@@ -246,7 +246,7 @@ uint8* TileBuilder::BuildTiled(dtNavMeshParams& navMeshParams)
 
             ADT* _adt = new ADT(Utils::GetAdtPath(World, tx, ty), tx, ty);
             // If this condition is met, it means that this WDT does not contain the ADT
-            if (!_adt->Data->_Stream)
+            if (!_adt->Data->Stream)
             {
                 delete _adt;
                 continue;
@@ -352,11 +352,12 @@ uint8* TileBuilder::BuildTiled(dtNavMeshParams& navMeshParams)
     rcFreeHeightField(hf);
     rcFreeCompactHeightfield(chf);
     rcFreeContourSet(contours);
-    delete[] vertices;
-    delete[] triangles;
-    delete[] areas;
-    delete[] bmin;
-    delete[] bmax;
+
+    delete vertices;
+    delete triangles;
+    delete areas;
+    delete bmin;
+    delete bmax;
 
     if (!params.polyCount || !params.polys || Constants::TilesPerMap * Constants::TilesPerMap == params.polyCount)
     {
@@ -387,7 +388,7 @@ uint8* TileBuilder::BuildTiled(dtNavMeshParams& navMeshParams)
     return NULL;
 }
 
-void TileBuilder::OutputDebugVertices() const
+void TileBuilder::OutputDebugVertices()
 {
     if (Constants::Debug)
     {
diff --git a/src/tools/mesh_extractor/TileBuilder.h b/src/tools/mesh_extractor/TileBuilder.h
index ba8b9539649..b88966190b0 100644
--- a/src/tools/mesh_extractor/TileBuilder.h
+++ b/src/tools/mesh_extractor/TileBuilder.h
@@ -32,11 +32,11 @@ public:
     TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x, int y, uint32 mapId);
     ~TileBuilder();
 
-    void CalculateTileBounds(float*& bmin, float*& bmax, dtNavMeshParams& navMeshParams) const;
+    void CalculateTileBounds(float*& bmin, float*& bmax, dtNavMeshParams& navMeshParams);
     uint8* BuildTiled(dtNavMeshParams& navMeshParams);
     uint8* BuildInstance(dtNavMeshParams& navMeshParams);
-    void AddGeometry(WorldModelRoot const* root, const WorldModelDefinition& def);
-    void OutputDebugVertices() const;
+    void AddGeometry(WorldModelRoot* root, const WorldModelDefinition& def);
+    void OutputDebugVertices();
     std::string World;
     int X;
     int Y;
diff --git a/src/tools/mesh_extractor/Utils.cpp b/src/tools/mesh_extractor/Utils.cpp
index 42df1107bc0..704acf967ee 100644
--- a/src/tools/mesh_extractor/Utils.cpp
+++ b/src/tools/mesh_extractor/Utils.cpp
@@ -18,7 +18,6 @@
 #include "Utils.h"
 #include "WorldModelHandler.h"
 #include "Constants.h"
-#include "Stream.h"
 #include <cstring>
 #include "G3D/Matrix4.h"
 #include "G3D/Quat.h"
@@ -54,9 +53,40 @@ void Utils::CreateDir( const std::string& Path )
 #endif
 }
 
-void Utils::Reverse(std::string& str)
+void Utils::Reverse(char word[])
 {
-    std::reverse(str.begin(), str.end());
+    int len = strlen(word);
+    for (int i = 0;i < len / 2; i++)
+    {
+        word[i] ^= word[len-i-1];
+        word[len-i-1] ^= word[i];
+        word[i] ^= word[len-i-1];
+    }
+}
+
+std::string Utils::ReadString( FILE* file )
+{
+    std::string ret;
+    while (true)
+    {
+        char b;
+        if (fread(&b, sizeof(char), 1, file) != 1 || b == 0)
+            break;
+        ret.push_back(b);
+    }
+    return ret;
+}
+
+uint32 Utils::Size( FILE* file )
+{
+    // store the old position
+    uint32 offset = ftell(file);
+    // Get file size
+    fseek(file, 0, SEEK_END);
+    uint32 size = ftell(file);
+    // reset back to the old position
+    fseek(file, offset, SEEK_SET);
+    return size;
 }
 
 Vector3 Utils::ToRecast(const Vector3& val )
@@ -74,7 +104,7 @@ std::string Utils::FixModelPath(const std::string& path )
     return Utils::GetPathBase(path) + ".M2";
 }
 
-Vector3 Utils::TransformDoodadVertex(const IDefinition& def, Vector3 vec, bool translate)
+Vector3 Utils::TransformDoodadVertex(const IDefinition& def, Vector3& vec, bool translate)
 {
     // Sources of information:
     /// http://www.pxr.dk/wowdev/wiki/index.php?title=ADT/v18&oldid=3715
@@ -92,7 +122,7 @@ Vector3 Utils::TransformDoodadVertex(const IDefinition& def, Vector3 vec, bool t
     return ret;
 }
 
-Vector3 Utils::TransformWmoDoodad(const DoodadInstance& inst, const WorldModelDefinition& /*root*/, const Vector3& vec, bool translate)
+Vector3 Utils::TransformWmoDoodad(const DoodadInstance& inst, const WorldModelDefinition& root, Vector3& vec, bool translate )
 {
     G3D::Quat quat = G3D::Quat(-inst.QuatY, inst.QuatZ, -inst.QuatX, inst.QuatW);
 
@@ -123,9 +153,12 @@ std::string Utils::GetPathBase(const std::string& path )
     return path;
 }
 
-Vector3 Vector3::Read(Stream* file)
+Vector3 Vector3::Read( FILE* file )
 {
-    return file->Read<Vector3>();
+    Vector3 ret;
+    if (fread(&ret, sizeof(Vector3), 1, file) != 1)
+        printf("Vector3::Read: Failed to read some data expected 1, read 0\n");
+    return ret;
 }
 
 Vector3 Utils::GetLiquidVert(const IDefinition& def, Vector3 basePosition, float height, int x, int y, bool translate)
@@ -151,36 +184,41 @@ std::string Utils::Replace( std::string str, const std::string& oldStr, const st
     return str;
 }
 
-void Utils::SaveToDisk(Stream* stream, const std::string& path)
+void Utils::SaveToDisk( FILE* stream, const std::string& path )
 {
     FILE* disk = fopen(path.c_str(), "wb");
     if (!disk)
     {
         printf("SaveToDisk: Could not save file %s to disk, please verify that you have write permissions on that directory\n", path.c_str());
-        delete stream;
+        fclose(stream);
         return;
     }
 
-    uint32 size = stream->GetSize();
-    stream->Reset(); // Reset the stream just in case
-    
+    uint32 size = Utils::Size(stream);
+    uint8* data = new uint8[size];
     // Read the data to an array
-    char* data = stream->Read(size);
-   
+    size_t read = fread(data, size, 1, stream);
+    if (read != 1)
+    {
+        printf("SaveToDisk: Error reading from Stream while trying to save file %s to disk.\n", path.c_str());
+        fclose(disk);
+        fclose(stream);
+        return;
+    }
+    
     // And write it in the file
     size_t wrote = fwrite(data, size, 1, disk);
     if (wrote != 1)
     {
         printf("SaveToDisk: Error writing to the file while trying to save %s to disk.\n", path.c_str());
-        delete[] data;
-        delete stream;
+        fclose(stream);
         fclose(disk);
         return;
     }
 
     // Close the filestream
     fclose(disk);
-    delete stream;
+    fclose(stream);
 
     // Free the used memory
     delete[] data;
@@ -201,193 +239,249 @@ std::string Utils::GetExtension( std::string path )
     return extension;
 }
 
-void MapChunkHeader::Read(Stream* stream)
-{
-    Flags = stream->Read<uint32>();
-    IndexX = stream->Read<uint32>();
-    IndexY = stream->Read<uint32>();
-    Layers = stream->Read<uint32>();
-    DoodadRefs = stream->Read<uint32>();
-    OffsetMCVT = stream->Read<uint32>();
-    OffsetMCNR = stream->Read<uint32>();
-    OffsetMCLY = stream->Read<uint32>();
-    OffsetMCRF = stream->Read<uint32>();
-    OffsetMCAL = stream->Read<uint32>();
-    SizeMCAL = stream->Read<uint32>();
-    OffsetMCSH = stream->Read<uint32>();
-    SizeMCSH = stream->Read<uint32>();
-    AreaId = stream->Read<uint32>();
-    MapObjectRefs = stream->Read<uint32>();
-    Holes = stream->Read<uint32>();
-    stream->Read(LowQualityTextureMap, sizeof(uint32) * 4);
-    PredTex = stream->Read<uint32>();
-    NumberEffectDoodad = stream->Read<uint32>();
-    OffsetMCSE = stream->Read<uint32>();
-    SoundEmitters = stream->Read<uint32>();
-    OffsetMCLQ = stream->Read<uint32>();
-    SizeMCLQ = stream->Read<uint32>();
+void MapChunkHeader::Read(FILE* stream)
+{
+    int count = 0;
+
+    count += fread(&Flags, sizeof(uint32), 1, stream);
+    count += fread(&IndexX, sizeof(uint32), 1, stream);
+    count += fread(&IndexY, sizeof(uint32), 1, stream);
+    count += fread(&Layers, sizeof(uint32), 1, stream);
+    count += fread(&DoodadRefs, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCVT, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCNR, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCLY, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCRF, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCAL, sizeof(uint32), 1, stream);
+    count += fread(&SizeMCAL, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCSH, sizeof(uint32), 1, stream);
+    count += fread(&SizeMCSH, sizeof(uint32), 1, stream);
+    count += fread(&AreaId, sizeof(uint32), 1, stream);
+    count += fread(&MapObjectRefs, sizeof(uint32), 1, stream);
+    count += fread(&Holes, sizeof(uint32), 1, stream);
+    LowQualityTextureMap = new uint32[4];
+    count += fread(LowQualityTextureMap, sizeof(uint32), 4, stream);
+    count += fread(&PredTex, sizeof(uint32), 1, stream);
+    count += fread(&NumberEffectDoodad, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCSE, sizeof(uint32), 1, stream);
+    count += fread(&SoundEmitters, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCLQ, sizeof(uint32), 1, stream);
+    count += fread(&SizeMCLQ, sizeof(uint32), 1, stream);
     Position = Vector3::Read(stream);
-    OffsetMCCV = stream->Read<uint32>();
+    count += fread(&OffsetMCCV, sizeof(uint32), 1, stream);
+
+    if (count != 27)
+         printf("MapChunkHeader::Read: Failed to read some data expected 27, read %d\n", count);
 }
 
-void MHDR::Read(Stream* stream)
+void MHDR::Read(FILE* stream)
 {
-    Flags = stream->Read<uint32>();
-    OffsetMCIN = stream->Read<uint32>();
-    OffsetMTEX = stream->Read<uint32>();
-    OffsetMMDX = stream->Read<uint32>();
-    OffsetMMID = stream->Read<uint32>();
-    OffsetMWMO = stream->Read<uint32>();
-    OffsetMWID = stream->Read<uint32>();
-    OffsetMDDF = stream->Read<uint32>();
-    OffsetMODF = stream->Read<uint32>();
-    OffsetMFBO = stream->Read<uint32>();
-    OffsetMH2O = stream->Read<uint32>();
-    OffsetMTFX = stream->Read<uint32>();
+    int count = 0;
+
+    count += fread(&Flags, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMCIN, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMTEX, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMMDX, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMMID, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMWMO, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMWID, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMDDF, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMODF, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMFBO, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMH2O, sizeof(uint32), 1, stream);
+    count += fread(&OffsetMTFX, sizeof(uint32), 1, stream);
+
+    if (count != 12)
+         printf("MHDR::Read: Failed to read some data expected 12, read %d\n", count);
 }
 
-void ModelHeader::Read(Stream* stream)
+void ModelHeader::Read(FILE* stream)
 {
-    stream->Read(Magic, 4);
+    int count = 0;
+
+    count += fread(&Magic, sizeof(char), 4, stream);
     Magic[4] = '\0'; // null-terminate it.
-    Version = stream->Read<uint32>();
-    LengthModelName = stream->Read<uint32>();
-    OffsetName = stream->Read<uint32>();
-    ModelFlags = stream->Read<uint32>();
-    CountGlobalSequences = stream->Read<uint32>();
-    OffsetGlobalSequences = stream->Read<uint32>();
-    CountAnimations = stream->Read<uint32>();
-    OffsetAnimations = stream->Read<uint32>();
-    CountAnimationLookup = stream->Read<uint32>();
-    OffsetAnimationLookup = stream->Read<uint32>();
-    CountBones = stream->Read<uint32>();
-    OffsetBones = stream->Read<uint32>();
-    CountKeyBoneLookup = stream->Read<uint32>();
-    OffsetKeyBoneLookup = stream->Read<uint32>();
-    CountVertices = stream->Read<uint32>();
-    OffsetVertices = stream->Read<uint32>();
-    CountViews = stream->Read<uint32>();
-    CountColors = stream->Read<uint32>();
-    OffsetColors = stream->Read<uint32>();
-    CountTextures = stream->Read<uint32>();
-    OffsetTextures = stream->Read<uint32>();
-    CountTransparency = stream->Read<uint32>();
-    OffsetTransparency = stream->Read<uint32>();
-    CountUvAnimation = stream->Read<uint32>();
-    OffsetUvAnimation = stream->Read<uint32>();
-    CountTexReplace = stream->Read<uint32>();
-    OffsetTexReplace = stream->Read<uint32>();
-    CountRenderFlags = stream->Read<uint32>();
-    OffsetRenderFlags = stream->Read<uint32>();
-    CountBoneLookup = stream->Read<uint32>();
-    OffsetBoneLookup = stream->Read<uint32>();
-    CountTexLookup = stream->Read<uint32>();
-    OffsetTexLookup = stream->Read<uint32>();
-    CountTexUnits = stream->Read<uint32>();
-    OffsetTexUnits = stream->Read<uint32>();
-    CountTransLookup = stream->Read<uint32>();
-    OffsetTransLookup = stream->Read<uint32>();
-    CountUvAnimLookup = stream->Read<uint32>();
-    OffsetUvAnimLookup = stream->Read<uint32>();
+    count += fread(&Version, sizeof(uint32), 1, stream);
+    count += fread(&LengthModelName, sizeof(uint32), 1, stream);
+    count += fread(&OffsetName, sizeof(uint32), 1, stream);
+    count += fread(&ModelFlags, sizeof(uint32), 1, stream);
+    count += fread(&CountGlobalSequences, sizeof(uint32), 1, stream);
+    count += fread(&OffsetGlobalSequences, sizeof(uint32), 1, stream);
+    count += fread(&CountAnimations, sizeof(uint32), 1, stream);
+    count += fread(&OffsetAnimations, sizeof(uint32), 1, stream);
+    count += fread(&CountAnimationLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetAnimationLookup, sizeof(uint32), 1, stream);
+    count += fread(&CountBones, sizeof(uint32), 1, stream);
+    count += fread(&OffsetBones, sizeof(uint32), 1, stream);
+    count += fread(&CountKeyBoneLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetKeyBoneLookup, sizeof(uint32), 1, stream);
+    count += fread(&CountVertices, sizeof(uint32), 1, stream);
+    count += fread(&OffsetVertices, sizeof(uint32), 1, stream);
+    count += fread(&CountViews, sizeof(uint32), 1, stream);
+    count += fread(&CountColors, sizeof(uint32), 1, stream);
+    count += fread(&OffsetColors, sizeof(uint32), 1, stream);
+    count += fread(&CountTextures, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTextures, sizeof(uint32), 1, stream);
+    count += fread(&CountTransparency, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTransparency, sizeof(uint32), 1, stream);
+    count += fread(&CountUvAnimation, sizeof(uint32), 1, stream);
+    count += fread(&OffsetUvAnimation, sizeof(uint32), 1, stream);
+    count += fread(&CountTexReplace, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTexReplace, sizeof(uint32), 1, stream);
+    count += fread(&CountRenderFlags, sizeof(uint32), 1, stream);
+    count += fread(&OffsetRenderFlags, sizeof(uint32), 1, stream);
+    count += fread(&CountBoneLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetBoneLookup, sizeof(uint32), 1, stream);
+    count += fread(&CountTexLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTexLookup, sizeof(uint32), 1, stream);
+    count += fread(&CountTexUnits, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTexUnits, sizeof(uint32), 1, stream);
+    count += fread(&CountTransLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetTransLookup, sizeof(uint32), 1, stream);
+    count += fread(&CountUvAnimLookup, sizeof(uint32), 1, stream);
+    count += fread(&OffsetUvAnimLookup, sizeof(uint32), 1, stream);
     VertexBox[0] = Vector3::Read(stream);
     VertexBox[1] = Vector3::Read(stream);
-    VertexRadius = stream->Read<float>();
+    count += fread(&VertexRadius, sizeof(float), 1, stream);
     BoundingBox[0] = Vector3::Read(stream);
     BoundingBox[1] = Vector3::Read(stream);
-    BoundingRadius = stream->Read<float>();
-    CountBoundingTriangles = stream->Read<uint32>();
-    OffsetBoundingTriangles = stream->Read<uint32>();
-    CountBoundingVertices = stream->Read<uint32>();
-    OffsetBoundingVertices = stream->Read<uint32>();
-    CountBoundingNormals = stream->Read<uint32>();
-    OffsetBoundingNormals = stream->Read<uint32>();
-}
-
-void WorldModelHeader::Read(Stream* stream)
-{
-    CountMaterials = stream->Read<uint32>();
-    CountGroups = stream->Read<uint32>();
-    CountPortals = stream->Read<uint32>();
-    CountLights = stream->Read<uint32>();
-    CountModels = stream->Read<uint32>();
-    CountDoodads = stream->Read<uint32>();
-    CountSets = stream->Read<uint32>();
-    AmbientColorUnk = stream->Read<uint32>();
-    WmoId = stream->Read<uint32>();
-    BoundingBox[0] = Vector3::Read(stream);
-    BoundingBox[1] = Vector3::Read(stream);
-    LiquidTypeRelated = stream->Read<uint32>();
+    count += fread(&BoundingRadius, sizeof(float), 1, stream);
+    count += fread(&CountBoundingTriangles, sizeof(uint32), 1, stream);
+    count += fread(&OffsetBoundingTriangles, sizeof(uint32), 1, stream);
+    count += fread(&CountBoundingVertices, sizeof(uint32), 1, stream);
+    count += fread(&OffsetBoundingVertices, sizeof(uint32), 1, stream);
+    count += fread(&CountBoundingNormals, sizeof(uint32), 1, stream);
+    count += fread(&OffsetBoundingNormals, sizeof(uint32), 1, stream);
+
+    if (count != 51)
+         printf("ModelHeader::Read: Failed to read some data expected 51, read %d\n", count);
+
 }
 
-DoodadInstance DoodadInstance::Read(Stream* stream)
+WorldModelHeader WorldModelHeader::Read(FILE* stream)
+{
+    WorldModelHeader ret;
+    int count = 0;
+
+    count += fread(&ret.CountMaterials, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountGroups, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountPortals, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountLights, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountModels, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountDoodads, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountSets, sizeof(uint32), 1, stream);
+    count += fread(&ret.AmbientColorUnk, sizeof(uint32), 1, stream);
+    count += fread(&ret.WmoId, sizeof(uint32), 1, stream);
+    ret.BoundingBox[0] = Vector3::Read(stream);
+    ret.BoundingBox[1] = Vector3::Read(stream);
+    count += fread(&ret.LiquidTypeRelated, sizeof(uint32), 1, stream);
+
+    if (count != 10)
+         printf("WorldModelHeader::Read: Failed to read some data expected 10, read %d\n", count);
+
+    return ret;
+}
+
+DoodadInstance DoodadInstance::Read(FILE* stream)
 {
     DoodadInstance ret;
+    int count = 0;
 
-    ret.FileOffset = stream->Read<uint32>();
+    count += fread(&ret.FileOffset, sizeof(uint32), 1, stream);
     ret.Position = Vector3::Read(stream);
-    ret.QuatW = stream->Read<float>();
-    ret.QuatX = stream->Read<float>();
-    ret.QuatY = stream->Read<float>();
-    ret.QuatZ = stream->Read<float>();
-    ret.Scale = stream->Read<float>();
-    ret.LightColor = stream->Read<uint32>();
+    count += fread(&ret.QuatW, sizeof(float), 1, stream);
+    count += fread(&ret.QuatX, sizeof(float), 1, stream);
+    count += fread(&ret.QuatY, sizeof(float), 1, stream);
+    count += fread(&ret.QuatZ, sizeof(float), 1, stream);
+    count += fread(&ret.Scale, sizeof(float), 1, stream);
+    count += fread(&ret.LightColor, sizeof(uint32), 1, stream);
+
+    if (count != 7)
+         printf("DoodadInstance::Read: Failed to read some data expected 7, read %d\n", count);
+
     return ret;
 }
 
-DoodadSet DoodadSet::Read(Stream* stream)
+DoodadSet DoodadSet::Read(FILE* stream)
 {
     DoodadSet ret;
-    char* name = stream->Read(20);
-    ret.Name = std::string(name, 20);
-    delete[] name;
-    ret.FirstInstanceIndex = stream->Read<uint32>();
-    ret.CountInstances = stream->Read<uint32>();
-    ret.UnknownZero = stream->Read<uint32>();
-    
+    char name[21];
+    int count = 0;
+
+    count += fread(&name, sizeof(char), 20, stream);
+    name[20] = '\0';
+    ret.Name = name;
+    count += fread(&ret.FirstInstanceIndex, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountInstances, sizeof(uint32), 1, stream);
+    count += fread(&ret.UnknownZero, sizeof(uint32), 1, stream);
+
+    if (count != 23)
+         printf("DoodadSet::Read: Failed to read some data expected 23, read %d\n", count);
+
     return ret;
 }
 
-void LiquidHeader::Read(Stream* stream)
+LiquidHeader LiquidHeader::Read(FILE* stream)
 {
-    CountXVertices = stream->Read<uint32>();
-    CountYVertices = stream->Read<uint32>();
-    Width = stream->Read<uint32>();
-    Height = stream->Read<uint32>();
-    BaseLocation = Vector3::Read(stream);
-    MaterialId = stream->Read<uint16>();
+    LiquidHeader ret;
+    int count = 0;
+    count += fread(&ret.CountXVertices, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountYVertices, sizeof(uint32), 1, stream);
+    count += fread(&ret.Width, sizeof(uint32), 1, stream);
+    count += fread(&ret.Height, sizeof(uint32), 1, stream);
+    ret.BaseLocation = Vector3::Read(stream);
+    count += fread(&ret.MaterialId, sizeof(uint16), 1, stream);
+
+    if (count != 5)
+         printf("LiquidHeader::Read: Failed to read some data expected 5, read %d\n", count);
+
+    return ret;
 }
 
-void LiquidData::Read(Stream* stream, LiquidHeader& header)
+LiquidData LiquidData::Read(FILE* stream, LiquidHeader& header)
 {
-    CountXVertices = header.CountXVertices;
-    Width = header.Width;
-
-    HeightMap = new float*[header.CountXVertices];
+    LiquidData ret;
+    ret.HeightMap = new float*[header.CountXVertices];
     for (uint32 i = 0; i < header.CountXVertices; ++i)
-        HeightMap[i] = new float[header.CountYVertices];
+        ret.HeightMap[i] = new float[header.CountYVertices];
 
-    RenderFlags = new uint8*[header.Width];
+    ret.RenderFlags = new uint8*[header.Width];
     for (uint32 i = 0; i < header.Width; ++i)
-        RenderFlags[i] = new uint8[header.Height];
+        ret.RenderFlags[i] = new uint8[header.Height];
 
     for (uint32 y = 0; y < header.CountYVertices; y++)
     {
         for (uint32 x = 0; x < header.CountXVertices; x++)
         {
-            stream->Skip<uint32>();
-            HeightMap[x][y] = stream->Read<float>();
+            uint32 discard;
+            float tmp;
+            if (fread(&discard, sizeof(uint32), 1, stream) == 1 &&
+                fread(&tmp, sizeof(float), 1, stream) == 1)
+            {
+                ret.HeightMap[x][y] = tmp;
+            }
         }
     }
 
     for (uint32 y = 0; y < header.Height; y++)
+    {
         for (uint32 x = 0; x < header.Width; x++)
-            RenderFlags[x][y] = stream->Read<uint8>();
+        {
+            uint8 tmp = 0;
+            if (fread(&tmp, sizeof(uint8), 1, stream) == 1)
+                ret.RenderFlags[x][y] = tmp;
+        }
+    }
+
+    return ret;
 }
 
-H2ORenderMask H2ORenderMask::Read(Stream* stream)
+H2ORenderMask H2ORenderMask::Read(FILE* stream)
 {
     H2ORenderMask ret;
-    stream->Read(ret.Mask, sizeof(uint8) * 8);
+    int32 count;
+    if ((count = fread(&ret.Mask, sizeof(uint8), 8, stream)) != 8)
+        printf("H2OHeader::Read: Failed to read some data expected 8, read %d\n", count);
     return ret;
 }
 
@@ -403,42 +497,38 @@ bool MCNKLiquidData::IsWater(int x, int y, float height)
     return false;
 }
 
-MCNKLiquidData::~MCNKLiquidData()
+H2OHeader H2OHeader::Read(FILE* stream)
 {
-    if (!Heights)
-        return;
+    H2OHeader ret;
+    int count = 0;
+    count += fread(&ret.OffsetInformation, sizeof(uint32), 1, stream);
+    count += fread(&ret.LayerCount, sizeof(uint32), 1, stream);
+    count += fread(&ret.OffsetRender, sizeof(uint32), 1, stream);
 
-    for (uint32 i = 0; i < 9; ++i)
-        delete[] Heights[i];
-    delete[] Heights;
-    Heights = NULL;
-}
+    if (count != 3)
+        printf("H2OHeader::Read: Failed to read some data expected 3, read %d\n", count);
 
-H2OHeader H2OHeader::Read(Stream* stream)
-{
-    H2OHeader ret;
-    
-    ret.OffsetInformation = stream->Read<uint32>();
-    ret.LayerCount = stream->Read<uint32>();
-    ret.OffsetRender = stream->Read<uint32>();
-    
     return ret;
 }
 
-H2OInformation H2OInformation::Read(Stream* stream)
+H2OInformation H2OInformation::Read(FILE* stream)
 {
     H2OInformation ret;
-    ret.LiquidType = stream->Read<uint16>();
-    ret.Flags = stream->Read<uint16>();
-    ret.HeightLevel1 = stream->Read<float>();
-    ret.HeightLevel2 = stream->Read<float>();
-    ret.OffsetX = stream->Read<uint8>();
-    ret.OffsetY = stream->Read<uint8>();
-    ret.Width = stream->Read<uint8>();
-    ret.Height = stream->Read<uint8>();
-    ret.OffsetMask2 = stream->Read<uint32>();
-    ret.OffsetHeightmap = stream->Read<uint32>();
-    
+    int count = 0;
+    count += fread(&ret.LiquidType, sizeof(uint16), 1, stream);
+    count += fread(&ret.Flags, sizeof(uint16), 1, stream);
+    count += fread(&ret.HeightLevel1, sizeof(float), 1, stream);
+    count += fread(&ret.HeightLevel2, sizeof(float), 1, stream);
+    count += fread(&ret.OffsetX, sizeof(uint8), 1, stream);
+    count += fread(&ret.OffsetY, sizeof(uint8), 1, stream);
+    count += fread(&ret.Width, sizeof(uint8), 1, stream);
+    count += fread(&ret.Height, sizeof(uint8), 1, stream);
+    count += fread(&ret.OffsetMask2, sizeof(uint32), 1, stream);
+    count += fread(&ret.OffsetHeightmap, sizeof(uint32), 1, stream);
+
+    if (count != 10)
+        printf("H2OInformation::Read: Failed to read some data expected 10, read %d\n", count);
+
     return ret;
 }
 
@@ -451,30 +541,24 @@ char* Utils::GetPlainName(const char* FileName)
     return (char*)FileName;
 }
 
-WMOGroupHeader WMOGroupHeader::Read(Stream* stream)
+WMOGroupHeader WMOGroupHeader::Read( FILE* stream )
 {
     WMOGroupHeader ret;
-    ret.OffsetGroupName = stream->Read<uint32>();
-    ret.OffsetDescriptiveName = stream->Read<uint32>();
-    ret.Flags = stream->Read<uint32>();
+    int count = 0;
+    count += fread(&ret.OffsetGroupName, sizeof(uint32), 1, stream);
+    count += fread(&ret.OffsetDescriptiveName, sizeof(uint32), 1, stream);
+    count += fread(&ret.Flags, sizeof(uint32), 1, stream);
     ret.BoundingBox[0] = Vector3::Read(stream);
     ret.BoundingBox[1] = Vector3::Read(stream);
-    ret.OffsetPortals = stream->Read<uint32>();
-    ret.CountPortals = stream->Read<uint32>();
-    stream->Read(ret.CountBatches, sizeof(uint16) * 4);
-    stream->Read(ret.Fogs, sizeof(uint8) * 4);
-    ret.LiquidTypeRelated = stream->Read<uint32>();
-    ret.WmoId = stream->Read<uint32>();
-    
-    return ret;
-}
+    count += fread(&ret.OffsetPortals, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountPortals, sizeof(uint32), 1, stream);
+    count += fread(&ret.CountBatches, sizeof(uint16), 4, stream);
+    count += fread(&ret.Fogs, sizeof(uint8), 4, stream);
+    count += fread(&ret.LiquidTypeRelated, sizeof(uint32), 1, stream);
+    count += fread(&ret.WmoId, sizeof(uint32), 1, stream);
 
-void Utils::InitializeMmapTileHeader(MmapTileHeader& header)
-{
-    memset(&header, 0, sizeof(MmapTileHeader));
-    header.mmapMagic = MMAP_MAGIC;
-    header.dtVersion = DT_NAVMESH_VERSION;
-    header.mmapVersion = MMAP_VERSION;
-    header.size = 0;
-    header.usesLiquids = true;
+    if (count != 15)
+        printf("WMOGroupHeader::Read: Failed to read some data expected 15, read %d\n", count);
+
+    return ret;
 }
diff --git a/src/tools/mesh_extractor/Utils.h b/src/tools/mesh_extractor/Utils.h
index f93bc6e6be6..267a32c27cd 100644
--- a/src/tools/mesh_extractor/Utils.h
+++ b/src/tools/mesh_extractor/Utils.h
@@ -27,8 +27,6 @@
 #include "Define.h"
 #include "Constants.h"
 
-#include "Stream.h"
-
 #include <ace/Stack_Trace.h>
 
 struct WorldModelDefinition;
@@ -61,7 +59,7 @@ struct Vector3
         return Vector3(x * s, y * s, z * s);
     }
 
-    static Vector3 Read(Stream* file);
+    static Vector3 Read(FILE* file);
 };
 
 struct TilePos
@@ -102,7 +100,7 @@ public:
     uint32 AreaId;
     uint32 MapObjectRefs;
     uint32 Holes;
-    uint32 LowQualityTextureMap[4];
+    uint32* LowQualityTextureMap;
     uint32 PredTex;
     uint32 NumberEffectDoodad;
     uint32 OffsetMCSE;
@@ -112,7 +110,7 @@ public:
     Vector3 Position;
     uint32 OffsetMCCV;
 
-    void Read(Stream* stream);
+    void Read(FILE* stream);
 };
 
 class MHDR
@@ -132,7 +130,7 @@ public:
     uint32 OffsetMH2O;
     uint32 OffsetMTFX;
 
-    void Read(Stream* stream);
+    void Read(FILE* stream);
 };
 
 class ModelHeader
@@ -189,7 +187,7 @@ public:
     uint32 CountBoundingNormals;
     uint32 OffsetBoundingNormals;
 
-    void Read(Stream* stream);
+    void Read(FILE* stream);
 };
 
 class WorldModelHeader
@@ -208,7 +206,7 @@ public:
     Vector3 BoundingBox[2];
     uint32 LiquidTypeRelated;
 
-    void Read(Stream* stream);
+    static WorldModelHeader Read(FILE* stream);
 };
 
 class DoodadInstance
@@ -225,7 +223,7 @@ public:
     float Scale;
     uint32 LightColor;
 
-    static DoodadInstance Read(Stream* stream);
+    static DoodadInstance Read(FILE* stream);
 };
 
 class DoodadSet
@@ -237,13 +235,13 @@ public:
     uint32 CountInstances;
     uint32 UnknownZero;
 
-    static DoodadSet Read(Stream* stream);
+    static DoodadSet Read(FILE* stream);
 };
 
 class LiquidHeader
 {
 public:
-    LiquidHeader() : CountXVertices(0), CountYVertices(0), Width(0), Height(0), BaseLocation(0,0,0), MaterialId(0) {}
+    LiquidHeader() {}
     uint32 CountXVertices;
     uint32 CountYVertices;
     uint32 Width;
@@ -251,36 +249,22 @@ public:
     Vector3 BaseLocation;
     uint16 MaterialId;
 
-    void Read(Stream* stream);
+    static LiquidHeader Read(FILE* stream);
 };
 
 class LiquidData
 {
 public:
-    LiquidData() : HeightMap(NULL), RenderFlags(NULL), CountXVertices(0), Width(0) {}
-    
-    ~LiquidData()
-    {
-        for (uint32 i = 0; i < CountXVertices; ++i)
-            delete[] HeightMap[i];
-        delete[] HeightMap;
-
-        for (uint32 i = 0; i < Width; ++i)
-            delete[] RenderFlags[i];
-        delete[] RenderFlags;
-    }
-
+    LiquidData() {}
     float** HeightMap;
     uint8** RenderFlags;
-    uint32 CountXVertices;
-    uint32 Width;
 
-    bool ShouldRender(int x, int y) const
+    bool ShouldRender(int x, int y)
     {
         return RenderFlags[x][y] != 0x0F;
     }
 
-    void Read(Stream* stream, LiquidHeader& header);
+    static LiquidData Read(FILE* stream, LiquidHeader& header);
 };
 
 class H2ORenderMask
@@ -294,15 +278,14 @@ public:
         return (Mask[y] >> x & 1) != 0;
     }
 
-    static H2ORenderMask Read(Stream* stream);
+    static H2ORenderMask Read(FILE* stream);
 };
 
 class MCNKLiquidData
 {
 public:
-    MCNKLiquidData() : Heights(NULL) {}
+    MCNKLiquidData() {}
     MCNKLiquidData(float** heights, H2ORenderMask mask) : Heights(heights), Mask(mask) {}
-    ~MCNKLiquidData();
 
     float** Heights;
     H2ORenderMask Mask;
@@ -318,7 +301,7 @@ public:
     uint32 LayerCount;
     uint32 OffsetRender;
 
-    static H2OHeader Read(Stream* stream);
+    static H2OHeader Read(FILE* stream);
 };
 
 class H2OInformation
@@ -336,7 +319,7 @@ public:
     uint32 OffsetMask2;
     uint32 OffsetHeightmap;
 
-    static H2OInformation Read(Stream* stream);
+    static H2OInformation Read(FILE* stream);
 };
 
 class WMOGroupHeader
@@ -355,7 +338,7 @@ public:
     uint32 LiquidTypeRelated;
     uint32 WmoId;
 
-    static WMOGroupHeader Read(Stream* stream);
+    static WMOGroupHeader Read(FILE* stream);
 };
 
 // Dummy class to act as an interface.
@@ -368,7 +351,7 @@ public:
 };
 
 #define MMAP_MAGIC 0x4d4d4150   // 'MMAP'
-#define MMAP_VERSION 5
+#define MMAP_VERSION 3
 
 struct MmapTileHeader
 {
@@ -376,13 +359,18 @@ struct MmapTileHeader
     uint32 dtVersion;
     uint32 mmapVersion;
     uint32 size;
-    bool usesLiquids : 1;
+    bool usesLiquids;
+
+    MmapTileHeader() : mmapMagic(MMAP_MAGIC), dtVersion(DT_NAVMESH_VERSION),
+        mmapVersion(MMAP_VERSION), size(0), usesLiquids(true) {}
 };
 
 class Utils
 {
 public:
-    static void Reverse(std::string& str);
+    static void Reverse(char word[]);
+    static std::string ReadString(FILE* file);
+    static uint32 Size(FILE* file);
     static Vector3 ToRecast(const Vector3& val );
     static std::string GetAdtPath(const std::string& world, int x, int y);
     static std::string FixModelPath(const std::string& path);
@@ -406,15 +394,14 @@ public:
                 return false;
         return true;
     }
-    static std::string Replace(std::string str, const std::string& oldStr, const std::string& newStr);
-    static void CreateDir(const std::string& Path);
-    static void SaveToDisk(Stream* stream, const std::string& path);
-    static Vector3 ToWoWCoords(const Vector3& vec);
-    static std::string GetExtension( std::string path);
+    static std::string Replace( std::string str, const std::string& oldStr, const std::string& newStr );
+    static void CreateDir( const std::string& Path );
+    static void SaveToDisk(FILE* stream, const std::string& path);
+    static Vector3 ToWoWCoords(const Vector3& vec );
+    static std::string GetExtension( std::string path );
     static char* GetPlainName(const char* FileName);
-    static Vector3 TransformDoodadVertex(const IDefinition& def, Vector3 vec, bool translate = true);
-    static Vector3 VectorTransform(const Vector3& vec, const G3D::Matrix4& matrix, bool normal = false);
-    static Vector3 TransformWmoDoodad(const DoodadInstance& inst, const WorldModelDefinition& root, const Vector3& vec, bool translate = true);
-    static void InitializeMmapTileHeader(MmapTileHeader& header);
+    static Vector3 TransformDoodadVertex(const IDefinition& def, Vector3& vec, bool translate = true);
+    static Vector3 VectorTransform(const Vector3& vec, const G3D::Matrix4& matrix, bool normal = false );
+    static Vector3 TransformWmoDoodad(const DoodadInstance& inst, const WorldModelDefinition& root, Vector3& vec, bool translate = true );
 };
 #endif
diff --git a/src/tools/mesh_extractor/WDT.cpp b/src/tools/mesh_extractor/WDT.cpp
index 42461f4f247..593127e0d34 100644
--- a/src/tools/mesh_extractor/WDT.cpp
+++ b/src/tools/mesh_extractor/WDT.cpp
@@ -20,7 +20,6 @@
 #include "ChunkedData.h"
 #include "Utils.h"
 #include "WorldModelHandler.h"
-#include "Cache.h"
 
 WDT::WDT(std::string file) : IsGlobalModel(false), IsValid(false), Model(NULL)
 {
@@ -38,8 +37,8 @@ void WDT::ReadGlobalModel()
 
     IsGlobalModel = true;
     ModelDefinition = WorldModelDefinition::Read(defChunk->GetStream());
-    ModelFile = fileChunk->GetStream()->ReadString();
-    Model = Cache->WorldModelCache.Get(ModelFile);
+    ModelFile = Utils::ReadString(fileChunk->GetStream());
+    Model = new WorldModelRoot(ModelFile);
 }
 
 void WDT::ReadTileTable()
@@ -48,14 +47,20 @@ void WDT::ReadTileTable()
     if (!chunk)
         return;
     IsValid = true;
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     for (int y = 0; y < 64; ++y)
     {
         for (int x = 0; x < 64; ++x)
         {
             const uint32 hasTileFlag = 0x1;
-            uint32 flags = stream->Read<uint32>();
-            stream->Skip<uint32>();
+            uint32 flags;
+            uint32 discard;
+            int count = 0;
+            count += fread(&flags, sizeof(uint32), 1, stream);
+            count += fread(&discard, sizeof(uint32), 1, stream);
+
+            if (count != 2)
+                printf("WDT::ReadTileTable: Failed to read some data expected 2, read %d\n", count);
 
             if (flags & hasTileFlag)
                 TileTable.push_back(TilePos(x, y));
@@ -64,9 +69,9 @@ void WDT::ReadTileTable()
     }
 }
 
-bool WDT::HasTile( int x, int y ) const
+bool WDT::HasTile( int x, int y )
 {
-    for (std::vector<TilePos>::const_iterator itr = TileTable.begin(); itr != TileTable.end(); ++itr)
+    for (std::vector<TilePos>::iterator itr = TileTable.begin(); itr != TileTable.end(); ++itr)
         if (itr->X == x && itr->Y == y)
             return true;
     return false;
diff --git a/src/tools/mesh_extractor/WDT.h b/src/tools/mesh_extractor/WDT.h
index 8943471ca86..55a1a9861ff 100644
--- a/src/tools/mesh_extractor/WDT.h
+++ b/src/tools/mesh_extractor/WDT.h
@@ -36,8 +36,8 @@ public:
     bool IsValid;
     std::string ModelFile;
     WorldModelDefinition ModelDefinition;
-    WorldModelRoot const* Model;
-    bool HasTile(int x, int y) const;
+    WorldModelRoot* Model;
+    bool HasTile(int x, int y);
 private:
     void ReadGlobalModel();
     void ReadTileTable();
diff --git a/src/tools/mesh_extractor/WorldModelGroup.cpp b/src/tools/mesh_extractor/WorldModelGroup.cpp
index 530b78e2792..9d32a096592 100644
--- a/src/tools/mesh_extractor/WorldModelGroup.cpp
+++ b/src/tools/mesh_extractor/WorldModelGroup.cpp
@@ -20,37 +20,14 @@
 #include "Chunk.h"
 #include "Utils.h"
 
-WorldModelGroup::WorldModelGroup(std::string path, int groupIndex) : SubData(NULL), GroupIndex(groupIndex), MOBA(NULL), MOBALength(0), HasLiquidData(false), IsBad(false)
+WorldModelGroup::WorldModelGroup( std::string path, int groupIndex ) : GroupIndex(groupIndex), MOBA(NULL), IsBad(false), HasLiquidData(false)
 {
     Data = new ChunkedData(path);
-    if (!Data->_Stream)
+    if (!Data->Stream)
     {
         IsBad = true;
         return;
     }
-    Load(path);
-}
-
-WorldModelGroup::WorldModelGroup(Stream* stream, std::string path, int groupIndex) : SubData(NULL), GroupIndex(groupIndex), MOBA(NULL), MOBALength(0), HasLiquidData(false), IsBad(false)
-{
-    Data = new ChunkedData(stream, stream->GetSize());
-    Load(path);
-}
-
-WorldModelGroup::~WorldModelGroup()
-{
-    // Temporarily delete the underlying stream, it is the same pointer for both Data and SubData.
-    // @TODO: Remove this code once the ChunkedData destructor properly releases _Stream
-    delete Data->_Stream;
-
-    delete Data;
-    delete SubData;
-    delete[] MOBA;
-    
-}
-
-void WorldModelGroup::Load(std::string& path)
-{
     Chunk* mainChunk = Data->GetChunkByName("MOGP");
     int32 firstSub = mainChunk->FindSubChunkOffset("MOPY");
     if (firstSub == -1)
@@ -58,8 +35,8 @@ void WorldModelGroup::Load(std::string& path)
 
     Name = Utils::GetPlainName(path.c_str());
 
-    Stream* stream = mainChunk->GetStream();
-    stream->Seek(firstSub, SEEK_SET);
+    FILE* stream = mainChunk->GetStream();
+    fseek(stream, firstSub, SEEK_SET);
     SubData = new ChunkedData(stream, mainChunk->Length - firstSub);
 
     ReadHeader();
@@ -80,7 +57,7 @@ void WorldModelGroup::ReadNormals()
     uint32 normalCount = chunk->Length / 12;
     ASSERT(normalCount == Vertices.size() && "normalCount is different than the Vertices count");
     Normals.reserve(normalCount);
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     for (uint32 i = 0; i < normalCount; i++)
         Normals.push_back(Vector3::Read(stream));
 }
@@ -92,9 +69,9 @@ void WorldModelGroup::ReadLiquid()
         return;
 
     HasLiquidData = true;
-    Stream* stream = chunk->GetStream();
-    LiquidDataHeader.Read(stream);
-    LiquidDataGeometry.Read(stream, LiquidDataHeader);
+    FILE* stream = chunk->GetStream();
+    LiquidDataHeader = LiquidHeader::Read(stream);
+    LiquidDataGeometry = LiquidData::Read(stream, LiquidDataHeader);
 }
 
 void WorldModelGroup::ReadVertices()
@@ -105,7 +82,7 @@ void WorldModelGroup::ReadVertices()
 
     uint32 verticeCount = chunk->Length / 12;
     Vertices.reserve(verticeCount);
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     for (uint32 i = 0; i < verticeCount; i++)
         Vertices.push_back(Vector3::Read(stream));
 }
@@ -118,13 +95,19 @@ void WorldModelGroup::ReadTriangles()
 
     uint32 triangleCount = chunk->Length / 6;
     ASSERT(triangleCount == TriangleFlags.size() && "triangleCount != TriangleFlags.size()");
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     Triangles.reserve(triangleCount);
     for (uint32 i = 0; i < triangleCount; i++)
     {
-        uint16 v0 = stream->Read<uint16>();
-        uint16 v1 = stream->Read<uint16>();
-        uint16 v2 = stream->Read<uint16>();
+        uint16 v0;
+        uint16 v1;
+        uint16 v2;
+        int count = 0;
+        count += fread(&v0, sizeof(uint16), 1, stream);
+        count += fread(&v1, sizeof(uint16), 1, stream);
+        count += fread(&v2, sizeof(uint16), 1, stream);
+        if (count != 3)
+            printf("WorldModelGroup::ReadMaterials: Error reading data, expected 3, read %d\n", count);
 
         Triangles.push_back(Triangle<uint16>(Constants::TRIANGLE_TYPE_WMO, v0, v1, v2));
     }
@@ -136,15 +119,20 @@ void WorldModelGroup::ReadMaterials()
     if (!chunk)
         return;
 
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     uint32 triangleCount = chunk->Length / 2;
     TriangleFlags.reserve(triangleCount);
     TriangleMaterials.reserve(triangleCount);
     for (uint32 i = 0; i < triangleCount; i++)
     {
-        TriangleFlags.push_back(stream->Read<uint8>());
+        uint8 tmp;
+        if (fread(&tmp, sizeof(uint8), 1, stream) != 1)
+            printf("WorldModelGroup::ReadMaterials: Error reading data, expected 1, read 0\n");
+        TriangleFlags.push_back(tmp);
         // Read again for material.
-        TriangleMaterials.push_back(stream->Read<uint8>());
+        if (fread(&tmp, sizeof(uint8), 1, stream) != 1)
+            printf("WorldModelGroup::ReadMaterials: Error reading data, expected 1, read 0\n");
+        TriangleMaterials.push_back(tmp);
     }
 }
 
@@ -154,7 +142,7 @@ void WorldModelGroup::ReadHeader()
     if (!chunk)
         return;
 
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     Header = WMOGroupHeader::Read(stream);
 }
 
@@ -166,5 +154,7 @@ void WorldModelGroup::ReadBatches()
 
     MOBALength = chunk->Length / 2;
     MOBA = new uint16[MOBALength];
-    chunk->GetStream()->Read(MOBA, sizeof(uint16) * MOBALength);
+    uint32 count = (uint32)fread(MOBA, sizeof(uint16), MOBALength, chunk->GetStream());
+    if (count != MOBALength)
+        printf("WorldModelGroup::ReadBatches: Error reading data, expected %u, read %u\n", MOBALength, count);
 }
diff --git a/src/tools/mesh_extractor/WorldModelGroup.h b/src/tools/mesh_extractor/WorldModelGroup.h
index 54056f9d37e..cf98dc8768a 100644
--- a/src/tools/mesh_extractor/WorldModelGroup.h
+++ b/src/tools/mesh_extractor/WorldModelGroup.h
@@ -24,10 +24,6 @@ class WorldModelGroup
 {
 public:
     WorldModelGroup(std::string path, int groupIndex);
-    WorldModelGroup(Stream* stream, std::string path, int groupIndex);
-    ~WorldModelGroup();
-    void Load(std::string& path);
-
     ChunkedData* Data;
     ChunkedData* SubData;
     int GroupIndex;
diff --git a/src/tools/mesh_extractor/WorldModelHandler.cpp b/src/tools/mesh_extractor/WorldModelHandler.cpp
index a0de6ec1172..fa816627435 100644
--- a/src/tools/mesh_extractor/WorldModelHandler.cpp
+++ b/src/tools/mesh_extractor/WorldModelHandler.cpp
@@ -21,24 +21,27 @@
 #include "Cache.h"
 #include "Model.h"
 #include "Define.h"
-#include "Stream.h"
 #include "G3D/Matrix4.h"
 #include "G3D/Quat.h"
 #include <cstdio>
 
-WorldModelDefinition WorldModelDefinition::Read(Stream* file)
+WorldModelDefinition WorldModelDefinition::Read( FILE* file )
 {
     WorldModelDefinition ret;
-    ret.MwidIndex = file->Read<uint32>();
-    ret.UniqueId = file->Read<uint32>();
+    int count = 0;
+    count += fread(&ret.MwidIndex, sizeof(uint32), 1, file);
+    count += fread(&ret.UniqueId, sizeof(uint32), 1, file);
     ret.Position = Vector3::Read(file);
     ret.Rotation = Vector3::Read(file);
     ret.UpperExtents = Vector3::Read(file);
     ret.LowerExtents = Vector3::Read(file);
-    ret.Flags = file->Read<uint16>();
-    ret.DoodadSet = file->Read<uint16>();
-    file->Read<uint32>(); // Discarded
-    
+    count += fread(&ret.Flags, sizeof(uint16), 1, file);
+    count += fread(&ret.DoodadSet, sizeof(uint16), 1, file);
+    uint32 discard;
+    count += fread(&discard, sizeof(uint32), 1, file);
+
+    if (count != 5)
+         printf("WorldModelDefinition::Read: Error reading data, expected 5, read %d\n", count);
     return ret;
 }
 
@@ -55,12 +58,14 @@ void WorldModelHandler::ProcessInternal( MapChunk* mcnk )
         return;
     
     uint32 refCount = mcnk->Header.MapObjectRefs;
-    Stream* stream = mcnk->Source->GetStream();
-    stream->Seek(mcnk->Source->Offset + mcnk->Header.OffsetMCRF, SEEK_SET);
+    FILE* stream = mcnk->Source->GetStream();
+    fseek(stream, mcnk->Source->Offset + mcnk->Header.OffsetMCRF, SEEK_SET);
     // Start looping at the last Doodad Ref index
     for (uint32 i = mcnk->Header.DoodadRefs; i < refCount; i++)
     {
-        int32 index = stream->Read<int32>();
+        int32 index;
+        if (fread(&index, sizeof(int32), 1, stream) != 1)
+            printf("WorldModelDefinition::Read: Error reading data, expected 1, read 0\n");
 
         if (index < 0 || uint32(index) >= _definitions->size())
             continue;
@@ -75,7 +80,12 @@ void WorldModelHandler::ProcessInternal( MapChunk* mcnk )
             continue;
 
         std::string path = (*_paths)[wmo.MwidIndex];
-        WorldModelRoot const* model = Cache->WorldModelCache.Get(path);
+        WorldModelRoot* model = Cache->WorldModelCache.Get(path);
+        if (!model)
+        {
+            model = new WorldModelRoot(path);
+            Cache->WorldModelCache.Insert(path, model);
+        }
 
         Vertices.reserve(1000);
         Triangles.reserve(1000);
@@ -83,16 +93,15 @@ void WorldModelHandler::ProcessInternal( MapChunk* mcnk )
         InsertModelGeometry(Vertices, Triangles, wmo, model);
     }
     // Restore the stream position
-    stream->Seek(mcnk->Source->Offset, SEEK_SET);
+    fseek(stream, mcnk->Source->Offset, SEEK_SET);
 }
 
-void WorldModelHandler::InsertModelGeometry( std::vector<Vector3>& verts, std::vector<Triangle<uint32> >& tris, const WorldModelDefinition& def, WorldModelRoot const* root, bool translate )
+void WorldModelHandler::InsertModelGeometry( std::vector<Vector3>& verts, std::vector<Triangle<uint32> >& tris, const WorldModelDefinition& def, WorldModelRoot* root, bool translate )
 {
-    for (std::vector<WorldModelGroup*>::const_iterator groupItr =  root->Groups.begin(); groupItr != root->Groups.end(); ++groupItr)
+    for (std::vector<WorldModelGroup>::iterator group =  root->Groups.begin(); group != root->Groups.end(); ++group)
     {
-        WorldModelGroup const* group = *groupItr;
         uint32 vertOffset = verts.size();
-        for (std::vector<Vector3>::const_iterator itr2 = group->Vertices.begin(); itr2 != group->Vertices.end(); ++itr2)
+        for (std::vector<Vector3>::iterator itr2 = group->Vertices.begin(); itr2 != group->Vertices.end(); ++itr2)
         {
             Vector3 v = Utils::TransformDoodadVertex(def, *itr2, translate);
             // If translate is false, then we were called directly from the TileBuilder to add data to it's _Geometry member, hence, we have to manually convert the vertices to Recast format.
@@ -104,7 +113,6 @@ void WorldModelHandler::InsertModelGeometry( std::vector<Vector3>& verts, std::v
             // only include colliding tris
             if ((group->TriangleFlags[i] & 0x04) != 0 || group->TriangleMaterials[i] == 0xFF)
                 continue;
-
             Triangle<uint16> tri = group->Triangles[i];
             tris.push_back(Triangle<uint32>(Constants::TRIANGLE_TYPE_WMO, tri.V0 + vertOffset, tri.V1 + vertOffset, tri.V2 + vertOffset));
         }
@@ -124,33 +132,38 @@ void WorldModelHandler::InsertModelGeometry( std::vector<Vector3>& verts, std::v
 
         for (std::vector<DoodadInstance>::iterator instance = instances.begin(); instance != instances.end(); ++instance)
         {
-            Model const* model = Cache->ModelCache.Get(instance->File);
+            Model* model = Cache->ModelCache.Get(instance->File);
+            if (!model)
+            {
+                model = new Model(instance->File);
+                Cache->ModelCache.Insert(instance->File, model);
+            }
 
             if (!model->IsCollidable)
                 continue;
             int vertOffset = verts.size();
-            for (std::vector<Vector3>::const_iterator itr2 = model->Vertices.begin(); itr2 != model->Vertices.end(); ++itr2)
+            for (std::vector<Vector3>::iterator itr2 = model->Vertices.begin(); itr2 != model->Vertices.end(); ++itr2)
             {
                 Vector3 v = Utils::TransformDoodadVertex(def, Utils::TransformWmoDoodad(*instance, def, *itr2, false), translate);
                 verts.push_back(translate ? v : Utils::ToRecast(v));
             }
-            for (std::vector<Triangle<uint16> >::const_iterator itr2 = model->Triangles.begin(); itr2 != model->Triangles.end(); ++itr2)
+            for (std::vector<Triangle<uint16> >::iterator itr2 = model->Triangles.begin(); itr2 != model->Triangles.end(); ++itr2)
                 tris.push_back(Triangle<uint32>(Constants::TRIANGLE_TYPE_WMO, itr2->V0 + vertOffset, itr2->V1 + vertOffset, itr2->V2 + vertOffset));
         }
 
-        for (std::vector<WorldModelGroup*>::const_iterator groupItr = root->Groups.begin(); groupItr != root->Groups.end(); ++groupItr)
+        for (std::vector<WorldModelGroup>::iterator group =  root->Groups.begin(); group != root->Groups.end(); ++group)
         {
-            WorldModelGroup const* group = *groupItr;
             if (!group->HasLiquidData)
                 continue;
 
             const LiquidHeader& liquidHeader = group->LiquidDataHeader;
-            const LiquidData& liquidDataGeometry = group->LiquidDataGeometry;
+            LiquidData& liquidDataGeometry = group->LiquidDataGeometry;
 
             for (uint32 y = 0; y < liquidHeader.Height; y++)
             {
                 for (uint32 x = 0; x < liquidHeader.Width; x++)
                 {
+
                     if (!liquidDataGeometry.ShouldRender(x, y))
                         continue;
 
@@ -189,7 +202,7 @@ void WorldModelHandler::ReadDefinitions()
     uint32 definitionCount = chunk->Length / definitionSize;
     _definitions = new std::vector<WorldModelDefinition>;
     _definitions->reserve(definitionCount);
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     for (uint32 i = 0; i < definitionCount; i++)
         _definitions->push_back(WorldModelDefinition::Read(stream));
 }
@@ -206,13 +219,14 @@ void WorldModelHandler::ReadModelPaths()
     _paths->reserve(paths);
     for (uint32 i = 0; i < paths; i++)
     {
-        Stream* stream = mwid->GetStream();
-        stream->Seek(i * 4, SEEK_CUR);
-        uint32 offset = stream->Read<uint32>();
-
-        Stream* dataStream = mwmo->GetStream();
-        dataStream->Seek(offset + mwmo->Offset, SEEK_SET);
-        _paths->push_back(dataStream->ReadString());
+        FILE* stream = mwid->GetStream();
+        fseek(stream, i * 4, SEEK_CUR);
+        uint32 offset;
+        if (fread(&offset, sizeof(uint32), 1, stream) != 1)
+            printf("WorldModelDefinition::Read: Error reading data, expected 1, read 0\n");
+        FILE* dataStream = mwmo->GetStream();
+        fseek(dataStream, offset + mwmo->Offset, SEEK_SET);
+        _paths->push_back(Utils::ReadString(dataStream));
     }
 }
 
diff --git a/src/tools/mesh_extractor/WorldModelHandler.h b/src/tools/mesh_extractor/WorldModelHandler.h
index ac7b7431c1e..972dda0f5d8 100644
--- a/src/tools/mesh_extractor/WorldModelHandler.h
+++ b/src/tools/mesh_extractor/WorldModelHandler.h
@@ -39,7 +39,7 @@ public:
     uint16 Flags;
     uint16 DoodadSet;
 
-    static WorldModelDefinition Read(Stream* file);
+    static WorldModelDefinition Read(FILE* file);
 };
 
 class WorldModelHandler : public ObjectDataHandler
@@ -50,8 +50,8 @@ public:
 
     std::vector<Vector3> Vertices;
     std::vector<Triangle<uint32> > Triangles;
-    bool IsSane() const { return _definitions && _paths; }
-    static void InsertModelGeometry(std::vector<Vector3>& verts, std::vector<Triangle<uint32> >& tris, const WorldModelDefinition& def, WorldModelRoot const* root, bool translate = true);
+    bool IsSane() { return _definitions && _paths; }
+    static void InsertModelGeometry(std::vector<Vector3>& verts, std::vector<Triangle<uint32> >& tris, const WorldModelDefinition& def, WorldModelRoot* root, bool translate = true);
 protected:
     void ProcessInternal(MapChunk* data);
 private:
diff --git a/src/tools/mesh_extractor/WorldModelRoot.cpp b/src/tools/mesh_extractor/WorldModelRoot.cpp
index ffc7d7c8484..d9bc4e550b3 100644
--- a/src/tools/mesh_extractor/WorldModelRoot.cpp
+++ b/src/tools/mesh_extractor/WorldModelRoot.cpp
@@ -18,7 +18,6 @@
 #include "WorldModelRoot.h"
 #include "ChunkedData.h"
 #include "Utils.h"
-#include "MPQManager.h"
 
 WorldModelRoot::WorldModelRoot( std::string path )
 {
@@ -33,10 +32,6 @@ WorldModelRoot::WorldModelRoot( std::string path )
 WorldModelRoot::~WorldModelRoot()
 {
     delete Data;
-    for (std::vector<WorldModelGroup*>::iterator group = Groups.begin(); group != Groups.end(); ++group)
-        delete *group;
-
-    Groups.clear();
 }
 
 void WorldModelRoot::ReadGroups()
@@ -47,10 +42,9 @@ void WorldModelRoot::ReadGroups()
     {
         char name[200];
         sprintf(name, "%s_%03u.wmo", pathBase.c_str(), i);
-        Stream* stream = MPQHandler->GetFile(name);
-        if (!stream)
-            continue;
-        Groups.push_back(new WorldModelGroup(stream, name, i));
+        WorldModelGroup group(name, i);
+        if (!group.IsBad)
+            Groups.push_back(group);
     }
 }
 
@@ -60,7 +54,7 @@ void WorldModelRoot::ReadDoodadSets()
     if (!chunk)
         return;
 
-    Stream* stream = chunk->GetStream();
+    FILE* stream = chunk->GetStream();
     ASSERT(chunk->Length / 32 == Header.CountSets && "chunk.Length / 32 == Header.CountSets");
     DoodadSets.reserve(Header.CountSets);
     for (uint32 i = 0; i < Header.CountSets; i++)
@@ -79,14 +73,14 @@ void WorldModelRoot::ReadDoodadInstances()
     DoodadInstances.reserve(countInstances);
     for (uint32 i = 0; i < countInstances; i++)
     {
-        Stream* stream = chunk->GetStream();
-        stream->Seek(instanceSize * i, SEEK_CUR);
+        FILE* stream = chunk->GetStream();
+        fseek(stream, instanceSize * i, SEEK_CUR);
         DoodadInstance instance = DoodadInstance::Read(stream);
-        Stream* nameStream = nameChunk->GetStream();
+        FILE* nameStream = nameChunk->GetStream();
         if (instance.FileOffset >= nameChunk->Length)
             continue;
-        nameStream->Seek(instance.FileOffset, SEEK_CUR);
-        instance.File = nameStream->ReadString();
+        fseek(nameStream, instance.FileOffset, SEEK_CUR);
+        instance.File = Utils::ReadString(nameStream);
         DoodadInstances.push_back(instance);
     }
 }
@@ -97,6 +91,6 @@ void WorldModelRoot::ReadHeader()
     if (!chunk)
         return;
 
-    Stream* stream = chunk->GetStream();
-    Header.Read(stream);
+    FILE* stream = chunk->GetStream();
+    Header = WorldModelHeader::Read(stream);
 }
diff --git a/src/tools/mesh_extractor/WorldModelRoot.h b/src/tools/mesh_extractor/WorldModelRoot.h
index 89ebb681f17..7fbc04d2b6d 100644
--- a/src/tools/mesh_extractor/WorldModelRoot.h
+++ b/src/tools/mesh_extractor/WorldModelRoot.h
@@ -34,7 +34,7 @@ public:
     WorldModelHeader Header;
     std::vector<DoodadInstance> DoodadInstances;
     std::vector<DoodadSet> DoodadSets;
-    std::vector<WorldModelGroup*> Groups;
+    std::vector<WorldModelGroup> Groups;
 private:
     void ReadGroups();
     void ReadDoodadSets();